vendor: 12,013 bytes, lines 1-339
1(function (global, factory) { 2 typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : 3 typeof define === 'function' && define.amd ? define(['exports'], factory) : 4 (global = global || self, factory(global.window = global.window || {})); 5}(this, (function (exports) { 'use strict'; 6 7 function _defineProperties(target, props) { 8 for (var i = 0; i < props.length; i++) { 9 var descriptor = props[i]; 10 descriptor.enumerable = descriptor.enumerable || false; 11 descriptor.configurable = true; 12 if ("value" in descriptor) descriptor.writable = true; 13 Object.defineProperty(target, descriptor.key, descriptor); 14 } 15 } 16 17 function _createClass(Constructor, protoProps, staticProps) { 18 if (protoProps) _defineProperties(Constructor.prototype, protoProps); 19 if (staticProps) _defineProperties(Constructor, staticProps); 20 return Constructor; 21 } 22 23 /*! 24 * Observer 3.12.5 25 * https://gsap.com 26 * 27 * @license Copyright 2008-2024, GreenSock. All rights reserved. 28 * Subject to the terms at https://gsap.com/standard-license or for 29 * Club GSAP members, the agreement issued with that membership. 30 * @author: Jack Doyle, [email protected] 31 */ 32 var gsap, 33 _coreInitted, 34 _clamp, 35 _win, 36 _doc, 37 _docEl, 38 _body, 39 _isTouch, 40 _pointerType, 41 ScrollTrigger, 42 _root, 43 _normalizer, 44 _eventTypes, 45 _context, 46 _getGSAP = function _getGSAP() { 47 return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap; 48 }, 49 _startup = 1, 50 _observers = [], 51 _scrollers = [], 52 _proxies = [], 53 _getTime = Date.now, 54 _bridge = function _bridge(name, value) { 55 return value; 56 }, 57 _integrate = function _integrate() { 58 var core = ScrollTrigger.core, 59 data = core.bridge || {}, 60 scrollers = core._scrollers, 61 proxies = core._proxies; 62 scrollers.push.apply(scrollers, _scrollers); 63 proxies.push.apply(proxies, _proxies); 64 _scrollers = scrollers; 65 _proxies = proxies; 66 67 _bridge = function _bridge(name, value) { 68 return data[name](value); 69 }; 70 }, 71 _getProxyProp = function _getProxyProp(element, property) { 72 return ~_proxies.indexOf(element) && _proxies[_proxies.indexOf(element) + 1][property]; 73 }, 74 _isViewport = function _isViewport(el) { 75 return !!~_root.indexOf(el); 76 }, 77 _addListener = function _addListener(element, type, func, passive, capture) { 78 return element.addEventListener(type, func, { 79 passive: passive !== false, 80 capture: !!capture 81 }); 82 }, 83 _removeListener = function _removeListener(element, type, func, capture) { 84 return element.removeEventListener(type, func, !!capture); 85 }, 86 _scrollLeft = "scrollLeft", 87 _scrollTop = "scrollTop", 88 _onScroll = function _onScroll() { 89 return _normalizer && _normalizer.isPressed || _scrollers.cache++; 90 }, 91 _scrollCacheFunc = function _scrollCacheFunc(f, doNotCache) { 92 var cachingFunc = function cachingFunc(value) { 93 if (value || value === 0) { 94 _startup && (_win.history.scrollRestoration = "manual"); 95 var isNormalizing = _normalizer && _normalizer.isPressed; 96 value = cachingFunc.v = Math.round(value) || (_normalizer && _normalizer.iOS ? 1 : 0); 97 f(value); 98 cachingFunc.cacheID = _scrollers.cache; 99 isNormalizing && _bridge("ss", value); 100 } else if (doNotCache || _scrollers.cache !== cachingFunc.cacheID || _bridge("ref")) { 101 cachingFunc.cacheID = _scrollers.cache; 102 cachingFunc.v = f(); 103 } 104 105 return cachingFunc.v + cachingFunc.offset; 106 }; 107 108 cachingFunc.offset = 0; 109 return f && cachingFunc; 110 }, 111 _horizontal = { 112 s: _scrollLeft, 113 p: "left", 114 p2: "Left", 115 os: "right", 116 os2: "Right", 117 d: "width", 118 d2: "Width", 119 a: "x", 120 sc: _scrollCacheFunc(function (value) { 121 return arguments.length ? _win.scrollTo(value, _vertical.sc()) : _win.pageXOffset || _doc[_scrollLeft] || _docEl[_scrollLeft] || _body[_scrollLeft] || 0; 122 }) 123 }, 124 _vertical = { 125 s: _scrollTop, 126 p: "top", 127 p2: "Top", 128 os: "bottom", 129 os2: "Bottom", 130 d: "height", 131 d2: "Height", 132 a: "y", 133 op: _horizontal, 134 sc: _scrollCacheFunc(function (value) { 135 return arguments.length ? _win.scrollTo(_horizontal.sc(), value) : _win.pageYOffset || _doc[_scrollTop] || _docEl[_scrollTop] || _body[_scrollTop] || 0; 136 }) 137 }, 138 _getTarget = function _getTarget(t, self) { 139 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); 140 }, 141 _getScrollFunc = function _getScrollFunc(element, _ref) { 142 var s = _ref.s, 143 sc = _ref.sc; 144 _isViewport(element) && (element = _doc.scrollingElement || _docEl); 145 146 var i = _scrollers.indexOf(element), 147 offset = sc === _vertical.sc ? 1 : 2; 148 149 !~i && (i = _scrollers.push(element) - 1); 150 _scrollers[i + offset] || _addListener(element, "scroll", _onScroll); 151 var prev = _scrollers[i + offset], 152 func = prev || (_scrollers[i + offset] = _scrollCacheFunc(_getProxyProp(element, s), true) || (_isViewport(element) ? sc : _scrollCacheFunc(function (value) { 153 return arguments.length ? element[s] = value : element[s]; 154 }))); 155 func.target = element; 156 prev || (func.smooth = gsap.getProperty(element, "scrollBehavior") === "smooth"); 157 return func; 158 }, 159 _getVelocityProp = function _getVelocityProp(value, minTimeRefresh, useDelta) { 160 var v1 = value, 161 v2 = value, 162 t1 = _getTime(), 163 t2 = t1, 164 min = minTimeRefresh || 50, 165 dropToZeroTime = Math.max(500, min * 3), 166 update = function update(value, force) { 167 var t = _getTime(); 168 169 if (force || t - t1 > min) { 170 v2 = v1; 171 v1 = value; 172 t2 = t1; 173 t1 = t; 174 } else if (useDelta) { 175 v1 += value; 176 } else { 177 v1 = v2 + (value - v2) / (t - t2) * (t1 - t2); 178 } 179 }, 180 reset = function reset() { 181 v2 = v1 = useDelta ? 0 : v1; 182 t2 = t1 = 0; 183 }, 184 getVelocity = function getVelocity(latestValue) { 185 var tOld = t2, 186 vOld = v2, 187 t = _getTime(); 188 189 (latestValue || latestValue === 0) && latestValue !== v1 && update(latestValue); 190 return t1 === t2 || t - t2 > dropToZeroTime ? 0 : (v1 + (useDelta ? vOld : -vOld)) / ((useDelta ? t : t1) - tOld) * 1000; 191 }; 192 193 return { 194 update: update, 195 reset: reset, 196 getVelocity: getVelocity 197 }; 198 }, 199 _getEvent = function _getEvent(e, preventDefault) { 200 preventDefault && !e._gsapAllow && e.preventDefault(); 201 return e.changedTouches ? e.changedTouches[0] : e; 202 }, 203 _getAbsoluteMax = function _getAbsoluteMax(a) { 204 var max = Math.max.apply(Math, a), 205 min = Math.min.apply(Math, a); 206 return Math.abs(max) >= Math.abs(min) ? max : min; 207 }, 208 _setScrollTrigger = function _setScrollTrigger() { 209 ScrollTrigger = gsap.core.globals().ScrollTrigger; 210 ScrollTrigger && ScrollTrigger.core && _integrate(); 211 }, 212 _initCore = function _initCore(core) { 213 gsap = core || _getGSAP(); 214 215 if (!_coreInitted && gsap && typeof document !== "undefined" && document.body) { 216 _win = window; 217 _doc = document; 218 _docEl = _doc.documentElement; 219 _body = _doc.body; 220 _root = [_win, _doc, _docEl, _body]; 221 _clamp = gsap.utils.clamp; 222 223 _context = gsap.core.context || function () {}; 224 225 _pointerType = "onpointerenter" in _body ? "pointer" : "mouse"; 226 _isTouch = Observer.isTouch = _win.matchMedia && _win.matchMedia("(hover: none), (pointer: coarse)").matches ? 1 : "ontouchstart" in _win || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0 ? 2 : 0; 227 _eventTypes = Observer.eventTypes = ("ontouchstart" in _docEl ? "touchstart,touchmove,touchcancel,touchend" : !("onpointerdown" in _docEl) ? "mousedown,mousemove,mouseup,mouseup" : "pointerdown,pointermove,pointercancel,pointerup").split(","); 228 setTimeout(function () { 229 return _startup = 0; 230 }, 500); 231 232 _setScrollTrigger(); 233 234 _coreInitted = 1; 235 } 236 237 return _coreInitted; 238 }; 239 240 _horizontal.op = _vertical; 241 _scrollers.cache = 0; 242 var Observer = function () { 243 function Observer(vars) { 244 this.init(vars); 245 } 246 247 var _proto = Observer.prototype; 248 249 _proto.init = function init(vars) { 250 _coreInitted || _initCore(gsap) || console.warn("Please gsap.registerPlugin(Observer)"); 251 ScrollTrigger || _setScrollTrigger(); 252 var tolerance = vars.tolerance, 253 dragMinimum = vars.dragMinimum, 254 type = vars.type, 255 target = vars.target, 256 lineHeight = vars.lineHeight, 257 debounce = vars.debounce, 258 preventDefault = vars.preventDefault, 259 onStop = vars.onStop, 260 onStopDelay = vars.onStopDelay, 261 ignore = vars.ignore, 262 wheelSpeed = vars.wheelSpeed, 263 event = vars.event, 264 onDragStart = vars.onDragStart, 265 onDragEnd = vars.onDragEnd, 266 onDrag = vars.onDrag, 267 onPress = vars.onPress, 268 onRelease = vars.onRelease, 269 onRight = vars.onRight, 270 onLeft = vars.onLeft, 271 onUp = vars.onUp, 272 onDown = vars.onDown, 273 onChangeX = vars.onChangeX, 274 onChangeY = vars.onChangeY, 275 onChange = vars.onChange, 276 onToggleX = vars.onToggleX, 277 onToggleY = vars.onToggleY, 278 onHover = vars.onHover, 279 onHoverEnd = vars.onHoverEnd, 280 onMove = vars.onMove, 281 ignoreCheck = vars.ignoreCheck, 282 isNormalizer = vars.isNormalizer, 283 onGestureStart = vars.onGestureStart, 284 onGestureEnd = vars.onGestureEnd, 285 onWheel = vars.onWheel, 286 onEnable = vars.onEnable, 287 onDisable = vars.onDisable, 288 onClick = vars.onClick, 289 scrollSpeed = vars.scrollSpeed, 290 capture = vars.capture, 291 allowClicks = vars.allowClicks, 292 lockAxis = vars.lockAxis, 293 onLockAxis = vars.onLockAxis; 294 this.target = target = _getTarget(target) || _docEl; 295 this.vars = vars; 296 ignore && (ignore = gsap.utils.toArray(ignore)); 297 tolerance = tolerance || 1e-9; 298 dragMinimum = dragMinimum || 0; 299 wheelSpeed = wheelSpeed || 1; 300 scrollSpeed = scrollSpeed || 1; 301 type = type || "wheel,touch,pointer"; 302 debounce = debounce !== false; 303 lineHeight || (lineHeight = parseFloat(_win.getComputedStyle(_body).lineHeight) || 22); 304 305 var id, 306 onStopDelayedCall, 307 dragged, 308 moved, 309 wheeled, 310 locked, 311 axis, 312 self = this, 313 prevDeltaX = 0, 314 prevDeltaY = 0, 315 passive = vars.passive || !preventDefault, 316 scrollFuncX = _getScrollFunc(target, _horizontal), 317 scrollFuncY = _getScrollFunc(target, _vertical), 318 scrollX = scrollFuncX(), 319 scrollY = scrollFuncY(), 320 limitToTouch = ~type.indexOf("touch") && !~type.indexOf("pointer") && _eventTypes[0] === "pointerdown", 321 isViewport = _isViewport(target), 322 ownerDoc = target.ownerDocument || _doc, 323 deltaX = [0, 0, 0], 324 deltaY = [0, 0, 0], 325 onClickTime = 0, 326 clickCapture = function clickCapture() { 327 return onClickTime = _getTime(); 328 }, 329 _ignoreCheck = function _ignoreCheck(e, isPointerOrTouch) { 330 return (self.event = e) && ignore && ~ignore.indexOf(e.target) || isPointerOrTouch && limitToTouch && e.pointerType !== "touch" || ignoreCheck && ignoreCheck(e, isPointerOrTouch); 331 }, 332 onStopFunc = function onStopFunc() { 333 self._vx.reset(); 334 335 self._vy.reset(); 336 337 onStopDelayedCall.pause(); 338 onStop && onStop(self); 339 },
vendor: 9,922 bytes, lines 340-631
340 update = function update() { 341 var dx = self.deltaX = _getAbsoluteMax(deltaX), 342 dy = self.deltaY = _getAbsoluteMax(deltaY), 343 changedX = Math.abs(dx) >= tolerance, 344 changedY = Math.abs(dy) >= tolerance; 345 346 onChange && (changedX || changedY) && onChange(self, dx, dy, deltaX, deltaY); 347 348 if (changedX) { 349 onRight && self.deltaX > 0 && onRight(self); 350 onLeft && self.deltaX < 0 && onLeft(self); 351 onChangeX && onChangeX(self); 352 onToggleX && self.deltaX < 0 !== prevDeltaX < 0 && onToggleX(self); 353 prevDeltaX = self.deltaX; 354 deltaX[0] = deltaX[1] = deltaX[2] = 0; 355 } 356 357 if (changedY) { 358 onDown && self.deltaY > 0 && onDown(self); 359 onUp && self.deltaY < 0 && onUp(self); 360 onChangeY && onChangeY(self); 361 onToggleY && self.deltaY < 0 !== prevDeltaY < 0 && onToggleY(self); 362 prevDeltaY = self.deltaY; 363 deltaY[0] = deltaY[1] = deltaY[2] = 0; 364 } 365 366 if (moved || dragged) { 367 onMove && onMove(self); 368 369 if (dragged) { 370 onDrag(self); 371 dragged = false; 372 } 373 374 moved = false; 375 } 376 377 locked && !(locked = false) && onLockAxis && onLockAxis(self); 378 379 if (wheeled) { 380 onWheel(self); 381 wheeled = false; 382 } 383 384 id = 0; 385 }, 386 onDelta = function onDelta(x, y, index) { 387 deltaX[index] += x; 388 deltaY[index] += y; 389 390 self._vx.update(x); 391 392 self._vy.update(y); 393 394 debounce ? id || (id = requestAnimationFrame(update)) : update(); 395 }, 396 onTouchOrPointerDelta = function onTouchOrPointerDelta(x, y) { 397 if (lockAxis && !axis) { 398 self.axis = axis = Math.abs(x) > Math.abs(y) ? "x" : "y"; 399 locked = true; 400 } 401 402 if (axis !== "y") { 403 deltaX[2] += x; 404 405 self._vx.update(x, true); 406 } 407 408 if (axis !== "x") { 409 deltaY[2] += y; 410 411 self._vy.update(y, true); 412 } 413 414 debounce ? id || (id = requestAnimationFrame(update)) : update(); 415 }, 416 _onDrag = function _onDrag(e) { 417 if (_ignoreCheck(e, 1)) { 418 return; 419 } 420 421 e = _getEvent(e, preventDefault); 422 var x = e.clientX, 423 y = e.clientY, 424 dx = x - self.x, 425 dy = y - self.y, 426 isDragging = self.isDragging; 427 self.x = x; 428 self.y = y; 429 430 if (isDragging || Math.abs(self.startX - x) >= dragMinimum || Math.abs(self.startY - y) >= dragMinimum) { 431 onDrag && (dragged = true); 432 isDragging || (self.isDragging = true); 433 onTouchOrPointerDelta(dx, dy); 434 isDragging || onDragStart && onDragStart(self); 435 } 436 }, 437 _onPress = self.onPress = function (e) { 438 if (_ignoreCheck(e, 1) || e && e.button) { 439 return; 440 } 441 442 self.axis = axis = null; 443 onStopDelayedCall.pause(); 444 self.isPressed = true; 445 e = _getEvent(e); 446 prevDeltaX = prevDeltaY = 0; 447 self.startX = self.x = e.clientX; 448 self.startY = self.y = e.clientY; 449 450 self._vx.reset(); 451 452 self._vy.reset(); 453 454 _addListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, passive, true); 455 456 self.deltaX = self.deltaY = 0; 457 onPress && onPress(self); 458 }, 459 _onRelease = self.onRelease = function (e) { 460 if (_ignoreCheck(e, 1)) { 461 return; 462 } 463 464 _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true); 465 466 var isTrackingDrag = !isNaN(self.y - self.startY), 467 wasDragging = self.isDragging, 468 isDragNotClick = wasDragging && (Math.abs(self.x - self.startX) > 3 || Math.abs(self.y - self.startY) > 3), 469 eventData = _getEvent(e); 470 471 if (!isDragNotClick && isTrackingDrag) { 472 self._vx.reset(); 473 474 self._vy.reset(); 475 476 if (preventDefault && allowClicks) { 477 gsap.delayedCall(0.08, function () { 478 if (_getTime() - onClickTime > 300 && !e.defaultPrevented) { 479 if (e.target.click) { 480 e.target.click(); 481 } else if (ownerDoc.createEvent) { 482 var syntheticEvent = ownerDoc.createEvent("MouseEvents"); 483 syntheticEvent.initMouseEvent("click", true, true, _win, 1, eventData.screenX, eventData.screenY, eventData.clientX, eventData.clientY, false, false, false, false, 0, null); 484 e.target.dispatchEvent(syntheticEvent); 485 } 486 } 487 }); 488 } 489 } 490 491 self.isDragging = self.isGesturing = self.isPressed = false; 492 onStop && wasDragging && !isNormalizer && onStopDelayedCall.restart(true); 493 onDragEnd && wasDragging && onDragEnd(self); 494 onRelease && onRelease(self, isDragNotClick); 495 }, 496 _onGestureStart = function _onGestureStart(e) { 497 return e.touches && e.touches.length > 1 && (self.isGesturing = true) && onGestureStart(e, self.isDragging); 498 }, 499 _onGestureEnd = function _onGestureEnd() { 500 return (self.isGesturing = false) || onGestureEnd(self); 501 }, 502 onScroll = function onScroll(e) { 503 if (_ignoreCheck(e)) { 504 return; 505 } 506 507 var x = scrollFuncX(), 508 y = scrollFuncY(); 509 onDelta((x - scrollX) * scrollSpeed, (y - scrollY) * scrollSpeed, 1); 510 scrollX = x; 511 scrollY = y; 512 onStop && onStopDelayedCall.restart(true); 513 }, 514 _onWheel = function _onWheel(e) { 515 if (_ignoreCheck(e)) { 516 return; 517 } 518 519 e = _getEvent(e, preventDefault); 520 onWheel && (wheeled = true); 521 var multiplier = (e.deltaMode === 1 ? lineHeight : e.deltaMode === 2 ? _win.innerHeight : 1) * wheelSpeed; 522 onDelta(e.deltaX * multiplier, e.deltaY * multiplier, 0); 523 onStop && !isNormalizer && onStopDelayedCall.restart(true); 524 }, 525 _onMove = function _onMove(e) { 526 if (_ignoreCheck(e)) { 527 return; 528 } 529 530 var x = e.clientX, 531 y = e.clientY, 532 dx = x - self.x, 533 dy = y - self.y; 534 self.x = x; 535 self.y = y; 536 moved = true; 537 onStop && onStopDelayedCall.restart(true); 538 (dx || dy) && onTouchOrPointerDelta(dx, dy); 539 }, 540 _onHover = function _onHover(e) { 541 self.event = e; 542 onHover(self); 543 }, 544 _onHoverEnd = function _onHoverEnd(e) { 545 self.event = e; 546 onHoverEnd(self); 547 }, 548 _onClick = function _onClick(e) { 549 return _ignoreCheck(e) || _getEvent(e, preventDefault) && onClick(self); 550 }; 551 552 onStopDelayedCall = self._dc = gsap.delayedCall(onStopDelay || 0.25, onStopFunc).pause(); 553 self.deltaX = self.deltaY = 0; 554 self._vx = _getVelocityProp(0, 50, true); 555 self._vy = _getVelocityProp(0, 50, true); 556 self.scrollX = scrollFuncX; 557 self.scrollY = scrollFuncY; 558 self.isDragging = self.isGesturing = self.isPressed = false; 559 560 _context(this); 561 562 self.enable = function (e) { 563 if (!self.isEnabled) { 564 _addListener(isViewport ? ownerDoc : target, "scroll", _onScroll); 565 566 type.indexOf("scroll") >= 0 && _addListener(isViewport ? ownerDoc : target, "scroll", onScroll, passive, capture); 567 type.indexOf("wheel") >= 0 && _addListener(target, "wheel", _onWheel, passive, capture); 568 569 if (type.indexOf("touch") >= 0 && _isTouch || type.indexOf("pointer") >= 0) { 570 _addListener(target, _eventTypes[0], _onPress, passive, capture); 571 572 _addListener(ownerDoc, _eventTypes[2], _onRelease); 573 574 _addListener(ownerDoc, _eventTypes[3], _onRelease); 575 576 allowClicks && _addListener(target, "click", clickCapture, true, true); 577 onClick && _addListener(target, "click", _onClick); 578 onGestureStart && _addListener(ownerDoc, "gesturestart", _onGestureStart); 579 onGestureEnd && _addListener(ownerDoc, "gestureend", _onGestureEnd); 580 onHover && _addListener(target, _pointerType + "enter", _onHover); 581 onHoverEnd && _addListener(target, _pointerType + "leave", _onHoverEnd); 582 onMove && _addListener(target, _pointerType + "move", _onMove); 583 } 584 585 self.isEnabled = true; 586 e && e.type && _onPress(e); 587 onEnable && onEnable(self); 588 } 589 590 return self; 591 }; 592 593 self.disable = function () { 594 if (self.isEnabled) { 595 _observers.filter(function (o) { 596 return o !== self && _isViewport(o.target); 597 }).length || _removeListener(isViewport ? ownerDoc : target, "scroll", _onScroll); 598 599 if (self.isPressed) { 600 self._vx.reset(); 601 602 self._vy.reset(); 603 604 _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true); 605 } 606 607 _removeListener(isViewport ? ownerDoc : target, "scroll", onScroll, capture); 608 609 _removeListener(target, "wheel", _onWheel, capture); 610 611 _removeListener(target, _eventTypes[0], _onPress, capture); 612 613 _removeListener(ownerDoc, _eventTypes[2], _onRelease); 614 615 _removeListener(ownerDoc, _eventTypes[3], _onRelease); 616 617 _removeListener(target, "click", clickCapture, true); 618 619 _removeListener(target, "click", _onClick); 620 621 _removeListener(ownerDoc, "gesturestart", _onGestureStart); 622 623 _removeListener(ownerDoc, "gestureend", _onGestureEnd); 624 625 _removeListener(target, _pointerType + "enter", _onHover); 626 627 _removeListener(target, _pointerType + "leave", _onHoverEnd); 628 629 _removeListener(target, _pointerType + "move", _onMove); 630 631 self.isEnabled = self.isPressed = self.isDragging = false;
vendor: 5,055 bytes, lines 632-801
632 onDisable && onDisable(self); 633 } 634 }; 635 636 self.kill = self.revert = function () { 637 self.disable(); 638 639 var i = _observers.indexOf(self); 640 641 i >= 0 && _observers.splice(i, 1); 642 _normalizer === self && (_normalizer = 0); 643 }; 644 645 _observers.push(self); 646 647 isNormalizer && _isViewport(target) && (_normalizer = self); 648 self.enable(event); 649 }; 650 651 _createClass(Observer, [{ 652 key: "velocityX", 653 get: function get() { 654 return this._vx.getVelocity(); 655 } 656 }, { 657 key: "velocityY", 658 get: function get() { 659 return this._vy.getVelocity(); 660 } 661 }]); 662 663 return Observer; 664 }(); 665 Observer.version = "3.12.5"; 666 667 Observer.create = function (vars) { 668 return new Observer(vars); 669 }; 670 671 Observer.register = _initCore; 672 673 Observer.getAll = function () { 674 return _observers.slice(); 675 }; 676 677 Observer.getById = function (id) { 678 return _observers.filter(function (o) { 679 return o.vars.id === id; 680 })[0]; 681 }; 682 683 _getGSAP() && gsap.registerPlugin(Observer); 684 685 /*! 686 * ScrollTrigger 3.12.5 687 * https://gsap.com 688 * 689 * @license Copyright 2008-2024, GreenSock. All rights reserved. 690 * Subject to the terms at https://gsap.com/standard-license or for 691 * Club GSAP members, the agreement issued with that membership. 692 * @author: Jack Doyle, [email protected] 693 */ 694 695 var gsap$1, 696 _coreInitted$1, 697 _win$1, 698 _doc$1, 699 _docEl$1, 700 _body$1, 701 _root$1, 702 _resizeDelay, 703 _toArray, 704 _clamp$1, 705 _time2, 706 _syncInterval, 707 _refreshing, 708 _pointerIsDown, 709 _transformProp, 710 _i, 711 _prevWidth, 712 _prevHeight, 713 _autoRefresh, 714 _sort, 715 _suppressOverwrites, 716 _ignoreResize, 717 _normalizer$1, 718 _ignoreMobileResize, 719 _baseScreenHeight, 720 _baseScreenWidth, 721 _fixIOSBug, 722 _context$1, 723 _scrollRestoration, 724 _div100vh, 725 _100vh, 726 _isReverted, 727 _clampingMax, 728 _limitCallbacks, 729 _startup$1 = 1, 730 _getTime$1 = Date.now, 731 _time1 = _getTime$1(), 732 _lastScrollTime = 0, 733 _enabled = 0, 734 _parseClamp = function _parseClamp(value, type, self) { 735 var clamp = _isString(value) && (value.substr(0, 6) === "clamp(" || value.indexOf("max") > -1); 736 self["_" + type + "Clamp"] = clamp; 737 return clamp ? value.substr(6, value.length - 7) : value; 738 }, 739 _keepClamp = function _keepClamp(value, clamp) { 740 return clamp && (!_isString(value) || value.substr(0, 6) !== "clamp(") ? "clamp(" + value + ")" : value; 741 }, 742 _rafBugFix = function _rafBugFix() { 743 return _enabled && requestAnimationFrame(_rafBugFix); 744 }, 745 _pointerDownHandler = function _pointerDownHandler() { 746 return _pointerIsDown = 1; 747 }, 748 _pointerUpHandler = function _pointerUpHandler() { 749 return _pointerIsDown = 0; 750 }, 751 _passThrough = function _passThrough(v) { 752 return v; 753 }, 754 _round = function _round(value) { 755 return Math.round(value * 100000) / 100000 || 0; 756 }, 757 _windowExists = function _windowExists() { 758 return typeof window !== "undefined"; 759 }, 760 _getGSAP$1 = function _getGSAP() { 761 return gsap$1 || _windowExists() && (gsap$1 = window.gsap) && gsap$1.registerPlugin && gsap$1; 762 }, 763 _isViewport$1 = function _isViewport(e) { 764 return !!~_root$1.indexOf(e); 765 }, 766 _getViewportDimension = function _getViewportDimension(dimensionProperty) { 767 return (dimensionProperty === "Height" ? _100vh : _win$1["inner" + dimensionProperty]) || _docEl$1["client" + dimensionProperty] || _body$1["client" + dimensionProperty]; 768 }, 769 _getBoundsFunc = function _getBoundsFunc(element) { 770 return _getProxyProp(element, "getBoundingClientRect") || (_isViewport$1(element) ? function () { 771 _winOffsets.width = _win$1.innerWidth; 772 _winOffsets.height = _100vh; 773 return _winOffsets; 774 } : function () { 775 return _getBounds(element); 776 }); 777 }, 778 _getSizeFunc = function _getSizeFunc(scroller, isViewport, _ref) { 779 var d = _ref.d, 780 d2 = _ref.d2, 781 a = _ref.a; 782 return (a = _getProxyProp(scroller, "getBoundingClientRect")) ? function () { 783 return a()[d]; 784 } : function () { 785 return (isViewport ? _getViewportDimension(d2) : scroller["client" + d2]) || 0; 786 }; 787 }, 788 _getOffsetsFunc = function _getOffsetsFunc(element, isViewport) { 789 return !isViewport || ~_proxies.indexOf(element) ? _getBoundsFunc(element) : function () { 790 return _winOffsets; 791 }; 792 }, 793 _maxScroll = function _maxScroll(element, _ref2) { 794 var s = _ref2.s, 795 d2 = _ref2.d2, 796 d = _ref2.d, 797 a = _ref2.a; 798 return Math.max(0, (s = "scroll" + d2) && (a = _getProxyProp(element, s)) ? a() - _getBoundsFunc(element)()[d] : _isViewport$1(element) ? (_docEl$1[s] || _body$1[s]) - _getViewportDimension(d2) : element[s] - element["offset" + d2]); 799 }, 800 _iterateAutoRefresh = function _iterateAutoRefresh(func, events) { 801 for (var i = 0; i < _autoRefresh.length; i += 3) {
vendor: 7,236 bytes, lines 802-1021
802 (!events || ~events.indexOf(_autoRefresh[i + 1])) && func(_autoRefresh[i], _autoRefresh[i + 1], _autoRefresh[i + 2]); 803 } 804 }, 805 _isString = function _isString(value) { 806 return typeof value === "string"; 807 }, 808 _isFunction = function _isFunction(value) { 809 return typeof value === "function"; 810 }, 811 _isNumber = function _isNumber(value) { 812 return typeof value === "number"; 813 }, 814 _isObject = function _isObject(value) { 815 return typeof value === "object"; 816 }, 817 _endAnimation = function _endAnimation(animation, reversed, pause) { 818 return animation && animation.progress(reversed ? 0 : 1) && pause && animation.pause(); 819 }, 820 _callback = function _callback(self, func) { 821 if (self.enabled) { 822 var result = self._ctx ? self._ctx.add(function () { 823 return func(self); 824 }) : func(self); 825 result && result.totalTime && (self.callbackAnimation = result); 826 } 827 }, 828 _abs = Math.abs, 829 _left = "left", 830 _top = "top", 831 _right = "right", 832 _bottom = "bottom", 833 _width = "width", 834 _height = "height", 835 _Right = "Right", 836 _Left = "Left", 837 _Top = "Top", 838 _Bottom = "Bottom", 839 _padding = "padding", 840 _margin = "margin", 841 _Width = "Width", 842 _Height = "Height", 843 _px = "px", 844 _getComputedStyle = function _getComputedStyle(element) { 845 return _win$1.getComputedStyle(element); 846 }, 847 _makePositionable = function _makePositionable(element) { 848 var position = _getComputedStyle(element).position; 849 850 element.style.position = position === "absolute" || position === "fixed" ? position : "relative"; 851 }, 852 _setDefaults = function _setDefaults(obj, defaults) { 853 for (var p in defaults) { 854 p in obj || (obj[p] = defaults[p]); 855 } 856 857 return obj; 858 }, 859 _getBounds = function _getBounds(element, withoutTransforms) { 860 var tween = withoutTransforms && _getComputedStyle(element)[_transformProp] !== "matrix(1, 0, 0, 1, 0, 0)" && gsap$1.to(element, { 861 x: 0, 862 y: 0, 863 xPercent: 0, 864 yPercent: 0, 865 rotation: 0, 866 rotationX: 0, 867 rotationY: 0, 868 scale: 1, 869 skewX: 0, 870 skewY: 0 871 }).progress(1), 872 bounds = element.getBoundingClientRect(); 873 tween && tween.progress(0).kill(); 874 return bounds; 875 }, 876 _getSize = function _getSize(element, _ref3) { 877 var d2 = _ref3.d2; 878 return element["offset" + d2] || element["client" + d2] || 0; 879 }, 880 _getLabelRatioArray = function _getLabelRatioArray(timeline) { 881 var a = [], 882 labels = timeline.labels, 883 duration = timeline.duration(), 884 p; 885 886 for (p in labels) { 887 a.push(labels[p] / duration); 888 } 889 890 return a; 891 }, 892 _getClosestLabel = function _getClosestLabel(animation) { 893 return function (value) { 894 return gsap$1.utils.snap(_getLabelRatioArray(animation), value); 895 }; 896 }, 897 _snapDirectional = function _snapDirectional(snapIncrementOrArray) { 898 var snap = gsap$1.utils.snap(snapIncrementOrArray), 899 a = Array.isArray(snapIncrementOrArray) && snapIncrementOrArray.slice(0).sort(function (a, b) { 900 return a - b; 901 }); 902 return a ? function (value, direction, threshold) { 903 if (threshold === void 0) { 904 threshold = 1e-3; 905 } 906 907 var i; 908 909 if (!direction) { 910 return snap(value); 911 } 912 913 if (direction > 0) { 914 value -= threshold; 915 916 for (i = 0; i < a.length; i++) { 917 if (a[i] >= value) { 918 return a[i]; 919 } 920 } 921 922 return a[i - 1]; 923 } else { 924 i = a.length; 925 value += threshold; 926 927 while (i--) { 928 if (a[i] <= value) { 929 return a[i]; 930 } 931 } 932 } 933 934 return a[0]; 935 } : function (value, direction, threshold) { 936 if (threshold === void 0) { 937 threshold = 1e-3; 938 } 939 940 var snapped = snap(value); 941 return !direction || Math.abs(snapped - value) < threshold || snapped - value < 0 === direction < 0 ? snapped : snap(direction < 0 ? value - snapIncrementOrArray : value + snapIncrementOrArray); 942 }; 943 }, 944 _getLabelAtDirection = function _getLabelAtDirection(timeline) { 945 return function (value, st) { 946 return _snapDirectional(_getLabelRatioArray(timeline))(value, st.direction); 947 }; 948 }, 949 _multiListener = function _multiListener(func, element, types, callback) { 950 return types.split(",").forEach(function (type) { 951 return func(element, type, callback); 952 }); 953 }, 954 _addListener$1 = function _addListener(element, type, func, nonPassive, capture) { 955 return element.addEventListener(type, func, { 956 passive: !nonPassive, 957 capture: !!capture 958 }); 959 }, 960 _removeListener$1 = function _removeListener(element, type, func, capture) { 961 return element.removeEventListener(type, func, !!capture); 962 }, 963 _wheelListener = function _wheelListener(func, el, scrollFunc) { 964 scrollFunc = scrollFunc && scrollFunc.wheelHandler; 965 966 if (scrollFunc) { 967 func(el, "wheel", scrollFunc); 968 func(el, "touchmove", scrollFunc); 969 } 970 }, 971 _markerDefaults = { 972 startColor: "green", 973 endColor: "red", 974 indent: 0, 975 fontSize: "16px", 976 fontWeight: "normal" 977 }, 978 _defaults = { 979 toggleActions: "play", 980 anticipatePin: 0 981 }, 982 _keywords = { 983 top: 0, 984 left: 0, 985 center: 0.5, 986 bottom: 1, 987 right: 1 988 }, 989 _offsetToPx = function _offsetToPx(value, size) { 990 if (_isString(value)) { 991 var eqIndex = value.indexOf("="), 992 relative = ~eqIndex ? +(value.charAt(eqIndex - 1) + 1) * parseFloat(value.substr(eqIndex + 1)) : 0; 993 994 if (~eqIndex) { 995 value.indexOf("%") > eqIndex && (relative *= size / 100); 996 value = value.substr(0, eqIndex - 1); 997 } 998 999 value = relative + (value in _keywords ? _keywords[value] * size : ~value.indexOf("%") ? parseFloat(value) * size / 100 : parseFloat(value) || 0); 1000 } 1001 1002 return value; 1003 }, 1004 _createMarker = function _createMarker(type, name, container, direction, _ref4, offset, matchWidthEl, containerAnimation) { 1005 var startColor = _ref4.startColor, 1006 endColor = _ref4.endColor, 1007 fontSize = _ref4.fontSize, 1008 indent = _ref4.indent, 1009 fontWeight = _ref4.fontWeight; 1010 1011 var e = _doc$1.createElement("div"), 1012 useFixedPosition = _isViewport$1(container) || _getProxyProp(container, "pinType") === "fixed", 1013 isScroller = type.indexOf("scroller") !== -1, 1014 parent = useFixedPosition ? _body$1 : container, 1015 isStart = type.indexOf("start") !== -1, 1016 color = isStart ? startColor : endColor, 1017 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;"; 1018 1019 css += "position:" + ((isScroller || containerAnimation) && useFixedPosition ? "fixed;" : "absolute;"); 1020 (isScroller || containerAnimation || !useFixedPosition) && (css += (direction === _vertical ? _right : _bottom) + ":" + (offset + parseFloat(indent)) + "px;"); 1021 matchWidthEl && (css += "box-sizing:border-box;text-align:left;
vendor: 15,878 bytes, lines 1021-1505
1021width:" + matchWidthEl.offsetWidth + "px;"); 1022 e._isStart = isStart; 1023 e.setAttribute("class", "gsap-marker-" + type + (name ? " marker-" + name : "")); 1024 e.style.cssText = css; 1025 e.innerText = name || name === 0 ? type + "-" + name : type; 1026 parent.children[0] ? parent.insertBefore(e, parent.children[0]) : parent.appendChild(e); 1027 e._offset = e["offset" + direction.op.d2]; 1028 1029 _positionMarker(e, 0, direction, isStart); 1030 1031 return e; 1032 }, 1033 _positionMarker = function _positionMarker(marker, start, direction, flipped) { 1034 var vars = { 1035 display: "block" 1036 }, 1037 side = direction[flipped ? "os2" : "p2"], 1038 oppositeSide = direction[flipped ? "p2" : "os2"]; 1039 marker._isFlipped = flipped; 1040 vars[direction.a + "Percent"] = flipped ? -100 : 0; 1041 vars[direction.a] = flipped ? "1px" : 0; 1042 vars["border" + side + _Width] = 1; 1043 vars["border" + oppositeSide + _Width] = 0; 1044 vars[direction.p] = start + "px"; 1045 gsap$1.set(marker, vars); 1046 }, 1047 _triggers = [], 1048 _ids = {}, 1049 _rafID, 1050 _sync = function _sync() { 1051 return _getTime$1() - _lastScrollTime > 34 && (_rafID || (_rafID = requestAnimationFrame(_updateAll))); 1052 }, 1053 _onScroll$1 = function _onScroll() { 1054 if (!_normalizer$1 || !_normalizer$1.isPressed || _normalizer$1.startX > _body$1.clientWidth) { 1055 _scrollers.cache++; 1056 1057 if (_normalizer$1) { 1058 _rafID || (_rafID = requestAnimationFrame(_updateAll)); 1059 } else { 1060 _updateAll(); 1061 } 1062 1063 _lastScrollTime || _dispatch("scrollStart"); 1064 _lastScrollTime = _getTime$1(); 1065 } 1066 }, 1067 _setBaseDimensions = function _setBaseDimensions() { 1068 _baseScreenWidth = _win$1.innerWidth; 1069 _baseScreenHeight = _win$1.innerHeight; 1070 }, 1071 _onResize = function _onResize() { 1072 _scrollers.cache++; 1073 !_refreshing && !_ignoreResize && !_doc$1.fullscreenElement && !_doc$1.webkitFullscreenElement && (!_ignoreMobileResize || _baseScreenWidth !== _win$1.innerWidth || Math.abs(_win$1.innerHeight - _baseScreenHeight) > _win$1.innerHeight * 0.25) && _resizeDelay.restart(true); 1074 }, 1075 _listeners = {}, 1076 _emptyArray = [], 1077 _softRefresh = function _softRefresh() { 1078 return _removeListener$1(ScrollTrigger$1, "scrollEnd", _softRefresh) || _refreshAll(true); 1079 }, 1080 _dispatch = function _dispatch(type) { 1081 return _listeners[type] && _listeners[type].map(function (f) { 1082 return f(); 1083 }) || _emptyArray; 1084 }, 1085 _savedStyles = [], 1086 _revertRecorded = function _revertRecorded(media) { 1087 for (var i = 0; i < _savedStyles.length; i += 5) { 1088 if (!media || _savedStyles[i + 4] && _savedStyles[i + 4].query === media) { 1089 _savedStyles[i].style.cssText = _savedStyles[i + 1]; 1090 _savedStyles[i].getBBox && _savedStyles[i].setAttribute("transform", _savedStyles[i + 2] || ""); 1091 _savedStyles[i + 3].uncache = 1; 1092 } 1093 } 1094 }, 1095 _revertAll = function _revertAll(kill, media) { 1096 var trigger; 1097 1098 for (_i = 0; _i < _triggers.length; _i++) { 1099 trigger = _triggers[_i]; 1100 1101 if (trigger && (!media || trigger._ctx === media)) { 1102 if (kill) { 1103 trigger.kill(1); 1104 } else { 1105 trigger.revert(true, true); 1106 } 1107 } 1108 } 1109 1110 _isReverted = true; 1111 media && _revertRecorded(media); 1112 media || _dispatch("revert"); 1113 }, 1114 _clearScrollMemory = function _clearScrollMemory(scrollRestoration, force) { 1115 _scrollers.cache++; 1116 (force || !_refreshingAll) && _scrollers.forEach(function (obj) { 1117 return _isFunction(obj) && obj.cacheID++ && (obj.rec = 0); 1118 }); 1119 _isString(scrollRestoration) && (_win$1.history.scrollRestoration = _scrollRestoration = scrollRestoration); 1120 }, 1121 _refreshingAll, 1122 _refreshID = 0, 1123 _queueRefreshID, 1124 _queueRefreshAll = function _queueRefreshAll() { 1125 if (_queueRefreshID !== _refreshID) { 1126 var id = _queueRefreshID = _refreshID; 1127 requestAnimationFrame(function () { 1128 return id === _refreshID && _refreshAll(true); 1129 }); 1130 } 1131 }, 1132 _refresh100vh = function _refresh100vh() { 1133 _body$1.appendChild(_div100vh); 1134 1135 _100vh = !_normalizer$1 && _div100vh.offsetHeight || _win$1.innerHeight; 1136 1137 _body$1.removeChild(_div100vh); 1138 }, 1139 _hideAllMarkers = function _hideAllMarkers(hide) { 1140 return _toArray(".gsap-marker-start, .gsap-marker-end, .gsap-marker-scroller-start, .gsap-marker-scroller-end").forEach(function (el) { 1141 return el.style.display = hide ? "none" : "block"; 1142 }); 1143 }, 1144 _refreshAll = function _refreshAll(force, skipRevert) { 1145 if (_lastScrollTime && !force && !_isReverted) { 1146 _addListener$1(ScrollTrigger$1, "scrollEnd", _softRefresh); 1147 1148 return; 1149 } 1150 1151 _refresh100vh(); 1152 1153 _refreshingAll = ScrollTrigger$1.isRefreshing = true; 1154 1155 _scrollers.forEach(function (obj) { 1156 return _isFunction(obj) && ++obj.cacheID && (obj.rec = obj()); 1157 }); 1158 1159 var refreshInits = _dispatch("refreshInit"); 1160 1161 _sort && ScrollTrigger$1.sort(); 1162 skipRevert || _revertAll(); 1163 1164 _scrollers.forEach(function (obj) { 1165 if (_isFunction(obj)) { 1166 obj.smooth && (obj.target.style.scrollBehavior = "auto"); 1167 obj(0); 1168 } 1169 }); 1170 1171 _triggers.slice(0).forEach(function (t) { 1172 return t.refresh(); 1173 }); 1174 1175 _isReverted = false; 1176 1177 _triggers.forEach(function (t) { 1178 if (t._subPinOffset && t.pin) { 1179 var prop = t.vars.horizontal ? "offsetWidth" : "offsetHeight", 1180 original = t.pin[prop]; 1181 t.revert(true, 1); 1182 t.adjustPinSpacing(t.pin[prop] - original); 1183 t.refresh(); 1184 } 1185 }); 1186 1187 _clampingMax = 1; 1188 1189 _hideAllMarkers(true); 1190 1191 _triggers.forEach(function (t) { 1192 var max = _maxScroll(t.scroller, t._dir), 1193 endClamp = t.vars.end === "max" || t._endClamp && t.end > max, 1194 startClamp = t._startClamp && t.start >= max; 1195 1196 (endClamp || startClamp) && t.setPositions(startClamp ? max - 1 : t.start, endClamp ? Math.max(startClamp ? max : t.start + 1, max) : t.end, true); 1197 }); 1198 1199 _hideAllMarkers(false); 1200 1201 _clampingMax = 0; 1202 refreshInits.forEach(function (result) { 1203 return result && result.render && result.render(-1); 1204 }); 1205 1206 _scrollers.forEach(function (obj) { 1207 if (_isFunction(obj)) { 1208 obj.smooth && requestAnimationFrame(function () { 1209 return obj.target.style.scrollBehavior = "smooth"; 1210 }); 1211 obj.rec && obj(obj.rec); 1212 } 1213 }); 1214 1215 _clearScrollMemory(_scrollRestoration, 1); 1216 1217 _resizeDelay.pause(); 1218 1219 _refreshID++; 1220 _refreshingAll = 2; 1221 1222 _updateAll(2); 1223 1224 _triggers.forEach(function (t) { 1225 return _isFunction(t.vars.onRefresh) && t.vars.onRefresh(t); 1226 }); 1227 1228 _refreshingAll = ScrollTrigger$1.isRefreshing = false; 1229 1230 _dispatch("refresh"); 1231 }, 1232 _lastScroll = 0, 1233 _direction = 1, 1234 _primary, 1235 _updateAll = function _updateAll(force) { 1236 if (force === 2 || !_refreshingAll && !_isReverted) { 1237 ScrollTrigger$1.isUpdating = true; 1238 _primary && _primary.update(0); 1239 1240 var l = _triggers.length, 1241 time = _getTime$1(), 1242 recordVelocity = time - _time1 >= 50, 1243 scroll = l && _triggers[0].scroll(); 1244 1245 _direction = _lastScroll > scroll ? -1 : 1; 1246 _refreshingAll || (_lastScroll = scroll); 1247 1248 if (recordVelocity) { 1249 if (_lastScrollTime && !_pointerIsDown && time - _lastScrollTime > 200) { 1250 _lastScrollTime = 0; 1251 1252 _dispatch("scrollEnd"); 1253 } 1254 1255 _time2 = _time1; 1256 _time1 = time; 1257 } 1258 1259 if (_direction < 0) { 1260 _i = l; 1261 1262 while (_i-- > 0) { 1263 _triggers[_i] && _triggers[_i].update(0, recordVelocity); 1264 } 1265 1266 _direction = 1; 1267 } else { 1268 for (_i = 0; _i < l; _i++) { 1269 _triggers[_i] && _triggers[_i].update(0, recordVelocity); 1270 } 1271 } 1272 1273 ScrollTrigger$1.isUpdating = false; 1274 } 1275 1276 _rafID = 0; 1277 }, 1278 _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"], 1279 _stateProps = _propNamesToCopy.concat([_width, _height, "boxSizing", "max" + _Width, "max" + _Height, "position", _margin, _padding, _padding + _Top, _padding + _Right, _padding + _Bottom, _padding + _Left]), 1280 _swapPinOut = function _swapPinOut(pin, spacer, state) { 1281 _setState(state); 1282 1283 var cache = pin._gsap; 1284 1285 if (cache.spacerIsNative) { 1286 _setState(cache.spacerState); 1287 } else if (pin._gsap.swappedIn) { 1288 var parent = spacer.parentNode; 1289 1290 if (parent) { 1291 parent.insertBefore(pin, spacer); 1292 parent.removeChild(spacer); 1293 } 1294 } 1295 1296 pin._gsap.swappedIn = false; 1297 }, 1298 _swapPinIn = function _swapPinIn(pin, spacer, cs, spacerState) { 1299 if (!pin._gsap.swappedIn) { 1300 var i = _propNamesToCopy.length, 1301 spacerStyle = spacer.style, 1302 pinStyle = pin.style, 1303 p; 1304 1305 while (i--) { 1306 p = _propNamesToCopy[i]; 1307 spacerStyle[p] = cs[p]; 1308 } 1309 1310 spacerStyle.position = cs.position === "absolute" ? "absolute" : "relative"; 1311 cs.display === "inline" && (spacerStyle.display = "inline-block"); 1312 pinStyle[_bottom] = pinStyle[_right] = "auto"; 1313 spacerStyle.flexBasis = cs.flexBasis || "auto"; 1314 spacerStyle.overflow = "visible"; 1315 spacerStyle.boxSizing = "border-box"; 1316 spacerStyle[_width] = _getSize(pin, _horizontal) + _px; 1317 spacerStyle[_height] = _getSize(pin, _vertical) + _px; 1318 spacerStyle[_padding] = pinStyle[_margin] = pinStyle[_top] = pinStyle[_left] = "0"; 1319 1320 _setState(spacerState); 1321 1322 pinStyle[_width] = pinStyle["max" + _Width] = cs[_width]; 1323 pinStyle[_height] = pinStyle["max" + _Height] = cs[_height]; 1324 pinStyle[_padding] = cs[_padding]; 1325 1326 if (pin.parentNode !== spacer) { 1327 pin.parentNode.insertBefore(spacer, pin); 1328 spacer.appendChild(pin); 1329 } 1330 1331 pin._gsap.swappedIn = true; 1332 } 1333 }, 1334 _capsExp = /([A-Z])/g, 1335 _setState = function _setState(state) { 1336 if (state) { 1337 var style = state.t.style, 1338 l = state.length, 1339 i = 0, 1340 p, 1341 value; 1342 (state.t._gsap || gsap$1.core.getCache(state.t)).uncache = 1; 1343 1344 for (; i < l; i += 2) { 1345 value = state[i + 1]; 1346 p = state[i]; 1347 1348 if (value) { 1349 style[p] = value; 1350 } else if (style[p]) { 1351 style.removeProperty(p.replace(_capsExp, "-$1").toLowerCase()); 1352 } 1353 } 1354 } 1355 }, 1356 _getState = function _getState(element) { 1357 var l = _stateProps.length, 1358 style = element.style, 1359 state = [], 1360 i = 0; 1361 1362 for (; i < l; i++) { 1363 state.push(_stateProps[i], style[_stateProps[i]]); 1364 } 1365 1366 state.t = element; 1367 return state; 1368 }, 1369 _copyState = function _copyState(state, override, omitOffsets) { 1370 var result = [], 1371 l = state.length, 1372 i = omitOffsets ? 8 : 0, 1373 p; 1374 1375 for (; i < l; i += 2) { 1376 p = state[i]; 1377 result.push(p, p in override ? override[p] : state[i + 1]); 1378 } 1379 1380 result.t = state.t; 1381 return result; 1382 }, 1383 _winOffsets = { 1384 left: 0, 1385 top: 0 1386 }, 1387 _parsePosition = function _parsePosition(value, trigger, scrollerSize, direction, scroll, marker, markerScroller, self, scrollerBounds, borderWidth, useFixedPosition, scrollerMax, containerAnimation, clampZeroProp) { 1388 _isFunction(value) && (value = value(self)); 1389 1390 if (_isString(value) && value.substr(0, 3) === "max") { 1391 value = scrollerMax + (value.charAt(4) === "=" ? _offsetToPx("0" + value.substr(3), scrollerSize) : 0); 1392 } 1393 1394 var time = containerAnimation ? containerAnimation.time() : 0, 1395 p1, 1396 p2, 1397 element; 1398 containerAnimation && containerAnimation.seek(0); 1399 isNaN(value) || (value = +value); 1400 1401 if (!_isNumber(value)) { 1402 _isFunction(trigger) && (trigger = trigger(self)); 1403 var offsets = (value || "0").split(" "), 1404 bounds, 1405 localOffset, 1406 globalOffset, 1407 display; 1408 element = _getTarget(trigger, self) || _body$1; 1409 bounds = _getBounds(element) || {}; 1410 1411 if ((!bounds || !bounds.left && !bounds.top) && _getComputedStyle(element).display === "none") { 1412 display = element.style.display; 1413 element.style.display = "block"; 1414 bounds = _getBounds(element); 1415 display ? element.style.display = display : element.style.removeProperty("display"); 1416 } 1417 1418 localOffset = _offsetToPx(offsets[0], bounds[direction.d]); 1419 globalOffset = _offsetToPx(offsets[1] || "0", scrollerSize); 1420 value = bounds[direction.p] - scrollerBounds[direction.p] - borderWidth + localOffset + scroll - globalOffset; 1421 markerScroller && _positionMarker(markerScroller, globalOffset, direction, scrollerSize - globalOffset < 20 || markerScroller._isStart && globalOffset > 20); 1422 scrollerSize -= scrollerSize - globalOffset; 1423 } else { 1424 containerAnimation && (value = gsap$1.utils.mapRange(containerAnimation.scrollTrigger.start, containerAnimation.scrollTrigger.end, 0, scrollerMax, value)); 1425 markerScroller && _positionMarker(markerScroller, scrollerSize, direction, true); 1426 } 1427 1428 if (clampZeroProp) { 1429 self[clampZeroProp] = value || -0.001; 1430 value < 0 && (value = 0); 1431 } 1432 1433 if (marker) { 1434 var position = value + scrollerSize, 1435 isStart = marker._isStart; 1436 p1 = "scroll" + direction.d2; 1437 1438 _positionMarker(marker, position, direction, isStart && position > 20 || !isStart && (useFixedPosition ? Math.max(_body$1[p1], _docEl$1[p1]) : marker.parentNode[p1]) <= position + 1); 1439 1440 if (useFixedPosition) { 1441 scrollerBounds = _getBounds(markerScroller); 1442 useFixedPosition && (marker.style[direction.op.p] = scrollerBounds[direction.op.p] - direction.op.m - marker._offset + _px); 1443 } 1444 } 1445 1446 if (containerAnimation && element) { 1447 p1 = _getBounds(element); 1448 containerAnimation.seek(scrollerMax); 1449 p2 = _getBounds(element); 1450 containerAnimation._caScrollDist = p1[direction.p] - p2[direction.p]; 1451 value = value / containerAnimation._caScrollDist * scrollerMax; 1452 } 1453 1454 containerAnimation && containerAnimation.seek(time); 1455 return containerAnimation ? value : Math.round(value); 1456 }, 1457 _prefixExp = /(webkit|moz|length|cssText|inset)/i, 1458 _reparent = function _reparent(element, parent, top, left) { 1459 if (element.parentNode !== parent) { 1460 var style = element.style, 1461 p, 1462 cs; 1463 1464 if (parent === _body$1) { 1465 element._stOrig = style.cssText; 1466 cs = _getComputedStyle(element); 1467 1468 for (p in cs) { 1469 if (!+p && !_prefixExp.test(p) && cs[p] && typeof style[p] === "string" && p !== "0") { 1470 style[p] = cs[p]; 1471 } 1472 } 1473 1474 style.top = top; 1475 style.left = left; 1476 } else { 1477 style.cssText = element._stOrig; 1478 } 1479 1480 gsap$1.core.getCache(element).uncache = 1; 1481 parent.appendChild(element); 1482 } 1483 }, 1484 _interruptionTracker = function _interruptionTracker(getValueFunc, initialValue, onInterrupt) { 1485 var last1 = initialValue, 1486 last2 = last1; 1487 return function (value) { 1488 var current = Math.round(getValueFunc()); 1489 1490 if (current !== last1 && current !== last2 && Math.abs(current - last1) > 3 && Math.abs(current - last2) > 3) { 1491 value = current; 1492 onInterrupt && onInterrupt(); 1493 } 1494 1495 last2 = last1; 1496 last1 = value; 1497 return value; 1498 }; 1499 }, 1500 _shiftMarker = function _shiftMarker(marker, direction, value) { 1501 var vars = {}; 1502 vars[direction.p] = "+=" + value; 1503 gsap$1.set(marker, vars); 1504 }, 1505 _getTweenCreator = function _getTweenCreator(scroller, direction) {
vendor: 4,601 bytes, lines 1506-1634
1506 var getScroll = _getScrollFunc(scroller, direction), 1507 prop = "_scroll" + direction.p2, 1508 getTween = function getTween(scrollTo, vars, initialValue, change1, change2) { 1509 var tween = getTween.tween, 1510 onComplete = vars.onComplete, 1511 modifiers = {}; 1512 initialValue = initialValue || getScroll(); 1513 1514 var checkForInterruption = _interruptionTracker(getScroll, initialValue, function () { 1515 tween.kill(); 1516 getTween.tween = 0; 1517 }); 1518 1519 change2 = change1 && change2 || 0; 1520 change1 = change1 || scrollTo - initialValue; 1521 tween && tween.kill(); 1522 vars[prop] = scrollTo; 1523 vars.inherit = false; 1524 vars.modifiers = modifiers; 1525 1526 modifiers[prop] = function () { 1527 return checkForInterruption(initialValue + change1 * tween.ratio + change2 * tween.ratio * tween.ratio); 1528 }; 1529 1530 vars.onUpdate = function () { 1531 _scrollers.cache++; 1532 getTween.tween && _updateAll(); 1533 }; 1534 1535 vars.onComplete = function () { 1536 getTween.tween = 0; 1537 onComplete && onComplete.call(tween); 1538 }; 1539 1540 tween = getTween.tween = gsap$1.to(scroller, vars); 1541 return tween; 1542 }; 1543 1544 scroller[prop] = getScroll; 1545 1546 getScroll.wheelHandler = function () { 1547 return getTween.tween && getTween.tween.kill() && (getTween.tween = 0); 1548 }; 1549 1550 _addListener$1(scroller, "wheel", getScroll.wheelHandler); 1551 1552 ScrollTrigger$1.isTouch && _addListener$1(scroller, "touchmove", getScroll.wheelHandler); 1553 return getTween; 1554 }; 1555 1556 var ScrollTrigger$1 = function () { 1557 function ScrollTrigger(vars, animation) { 1558 _coreInitted$1 || ScrollTrigger.register(gsap$1) || console.warn("Please gsap.registerPlugin(ScrollTrigger)"); 1559 1560 _context$1(this); 1561 1562 this.init(vars, animation); 1563 } 1564 1565 var _proto = ScrollTrigger.prototype; 1566 1567 _proto.init = function init(vars, animation) { 1568 this.progress = this.start = 0; 1569 this.vars && this.kill(true, true); 1570 1571 if (!_enabled) { 1572 this.update = this.refresh = this.kill = _passThrough; 1573 return; 1574 } 1575 1576 vars = _setDefaults(_isString(vars) || _isNumber(vars) || vars.nodeType ? { 1577 trigger: vars 1578 } : vars, _defaults); 1579 1580 var _vars = vars, 1581 onUpdate = _vars.onUpdate, 1582 toggleClass = _vars.toggleClass, 1583 id = _vars.id, 1584 onToggle = _vars.onToggle, 1585 onRefresh = _vars.onRefresh, 1586 scrub = _vars.scrub, 1587 trigger = _vars.trigger, 1588 pin = _vars.pin, 1589 pinSpacing = _vars.pinSpacing, 1590 invalidateOnRefresh = _vars.invalidateOnRefresh, 1591 anticipatePin = _vars.anticipatePin, 1592 onScrubComplete = _vars.onScrubComplete, 1593 onSnapComplete = _vars.onSnapComplete, 1594 once = _vars.once, 1595 snap = _vars.snap, 1596 pinReparent = _vars.pinReparent, 1597 pinSpacer = _vars.pinSpacer, 1598 containerAnimation = _vars.containerAnimation, 1599 fastScrollEnd = _vars.fastScrollEnd, 1600 preventOverlaps = _vars.preventOverlaps, 1601 direction = vars.horizontal || vars.containerAnimation && vars.horizontal !== false ? _horizontal : _vertical, 1602 isToggle = !scrub && scrub !== 0, 1603 scroller = _getTarget(vars.scroller || _win$1), 1604 scrollerCache = gsap$1.core.getCache(scroller), 1605 isViewport = _isViewport$1(scroller), 1606 useFixedPosition = ("pinType" in vars ? vars.pinType : _getProxyProp(scroller, "pinType") || isViewport && "fixed") === "fixed", 1607 callbacks = [vars.onEnter, vars.onLeave, vars.onEnterBack, vars.onLeaveBack], 1608 toggleActions = isToggle && vars.toggleActions.split(" "), 1609 markers = "markers" in vars ? vars.markers : _defaults.markers, 1610 borderWidth = isViewport ? 0 : parseFloat(_getComputedStyle(scroller)["border" + direction.p2 + _Width]) || 0, 1611 self = this, 1612 onRefreshInit = vars.onRefreshInit && function () { 1613 return vars.onRefreshInit(self); 1614 }, 1615 getScrollerSize = _getSizeFunc(scroller, isViewport, direction), 1616 getScrollerOffsets = _getOffsetsFunc(scroller, isViewport), 1617 lastSnap = 0, 1618 lastRefresh = 0, 1619 prevProgress = 0, 1620 scrollFunc = _getScrollFunc(scroller, direction), 1621 tweenTo, 1622 pinCache, 1623 snapFunc, 1624 scroll1, 1625 scroll2, 1626 start, 1627 end, 1628 markerStart, 1629 markerEnd, 1630 markerStartTrigger, 1631 markerEndTrigger, 1632 markerVars, 1633 executingOnRefresh, 1634 change,
vendor: 5,454 bytes, lines 1635-1771
1635 pinOriginalState, 1636 pinActiveState, 1637 pinState, 1638 spacer, 1639 offset, 1640 pinGetter, 1641 pinSetter, 1642 pinStart, 1643 pinChange, 1644 spacingStart, 1645 spacerState, 1646 markerStartSetter, 1647 pinMoves, 1648 markerEndSetter, 1649 cs, 1650 snap1, 1651 snap2, 1652 scrubTween, 1653 scrubSmooth, 1654 snapDurClamp, 1655 snapDelayedCall, 1656 prevScroll, 1657 prevAnimProgress, 1658 caMarkerSetter, 1659 customRevertReturn; 1660 1661 self._startClamp = self._endClamp = false; 1662 self._dir = direction; 1663 anticipatePin *= 45; 1664 self.scroller = scroller; 1665 self.scroll = containerAnimation ? containerAnimation.time.bind(containerAnimation) : scrollFunc; 1666 scroll1 = scrollFunc(); 1667 self.vars = vars; 1668 animation = animation || vars.animation; 1669 1670 if ("refreshPriority" in vars) { 1671 _sort = 1; 1672 vars.refreshPriority === -9999 && (_primary = self); 1673 } 1674 1675 scrollerCache.tweenScroll = scrollerCache.tweenScroll || { 1676 top: _getTweenCreator(scroller, _vertical), 1677 left: _getTweenCreator(scroller, _horizontal) 1678 }; 1679 self.tweenTo = tweenTo = scrollerCache.tweenScroll[direction.p]; 1680 1681 self.scrubDuration = function (value) { 1682 scrubSmooth = _isNumber(value) && value; 1683 1684 if (!scrubSmooth) { 1685 scrubTween && scrubTween.progress(1).kill(); 1686 scrubTween = 0; 1687 } else { 1688 scrubTween ? scrubTween.duration(value) : scrubTween = gsap$1.to(animation, { 1689 ease: "expo", 1690 totalProgress: "+=0", 1691 inherit: false, 1692 duration: scrubSmooth, 1693 paused: true, 1694 onComplete: function onComplete() { 1695 return onScrubComplete && onScrubComplete(self); 1696 } 1697 }); 1698 } 1699 }; 1700 1701 if (animation) { 1702 animation.vars.lazy = false; 1703 animation._initted && !self.isReverted || animation.vars.immediateRender !== false && vars.immediateRender !== false && animation.duration() && animation.render(0, true, true); 1704 self.animation = animation.pause(); 1705 animation.scrollTrigger = self; 1706 self.scrubDuration(scrub); 1707 snap1 = 0; 1708 id || (id = animation.vars.id); 1709 } 1710 1711 if (snap) { 1712 if (!_isObject(snap) || snap.push) { 1713 snap = { 1714 snapTo: snap 1715 }; 1716 } 1717 1718 "scrollBehavior" in _body$1.style && gsap$1.set(isViewport ? [_body$1, _docEl$1] : scroller, { 1719 scrollBehavior: "auto" 1720 }); 1721 1722 _scrollers.forEach(function (o) { 1723 return _isFunction(o) && o.target === (isViewport ? _doc$1.scrollingElement || _docEl$1 : scroller) && (o.smooth = false); 1724 }); 1725 1726 snapFunc = _isFunction(snap.snapTo) ? snap.snapTo : snap.snapTo === "labels" ? _getClosestLabel(animation) : snap.snapTo === "labelsDirectional" ? _getLabelAtDirection(animation) : snap.directional !== false ? function (value, st) { 1727 return _snapDirectional(snap.snapTo)(value, _getTime$1() - lastRefresh < 500 ? 0 : st.direction); 1728 } : gsap$1.utils.snap(snap.snapTo); 1729 snapDurClamp = snap.duration || { 1730 min: 0.1, 1731 max: 2 1732 }; 1733 snapDurClamp = _isObject(snapDurClamp) ? _clamp$1(snapDurClamp.min, snapDurClamp.max) : _clamp$1(snapDurClamp, snapDurClamp); 1734 snapDelayedCall = gsap$1.delayedCall(snap.delay || scrubSmooth / 2 || 0.1, function () { 1735 var scroll = scrollFunc(), 1736 refreshedRecently = _getTime$1() - lastRefresh < 500, 1737 tween = tweenTo.tween; 1738 1739 if ((refreshedRecently || Math.abs(self.getVelocity()) < 10) && !tween && !_pointerIsDown && lastSnap !== scroll) { 1740 var progress = (scroll - start) / change, 1741 totalProgress = animation && !isToggle ? animation.totalProgress() : progress, 1742 velocity = refreshedRecently ? 0 : (totalProgress - snap2) / (_getTime$1() - _time2) * 1000 || 0, 1743 change1 = gsap$1.utils.clamp(-progress, 1 - progress, _abs(velocity / 2) * velocity / 0.185), 1744 naturalEnd = progress + (snap.inertia === false ? 0 : change1), 1745 endValue, 1746 endScroll, 1747 _snap = snap, 1748 onStart = _snap.onStart, 1749 _onInterrupt = _snap.onInterrupt, 1750 _onComplete = _snap.onComplete; 1751 endValue = snapFunc(naturalEnd, self); 1752 _isNumber(endValue) || (endValue = naturalEnd); 1753 endScroll = Math.round(start + endValue * change); 1754 1755 if (scroll <= end && scroll >= start && endScroll !== scroll) { 1756 if (tween && !tween._initted && tween.data <= _abs(endScroll - scroll)) { 1757 return; 1758 } 1759 1760 if (snap.inertia === false) { 1761 change1 = endValue - progress; 1762 } 1763 1764 tweenTo(endScroll, { 1765 duration: snapDurClamp(_abs(Math.max(_abs(naturalEnd - totalProgress), _abs(endValue - totalProgress)) * 0.185 / velocity / 0.05 || 0)), 1766 ease: snap.ease || "power3", 1767 data: _abs(endScroll - scroll), 1768 onInterrupt: function onInterrupt() { 1769 return snapDelayedCall.restart(true) && _onInterrupt && _onInterrupt(self); 1770 }, 1771 onComplete: function onComplete() {
vendor: 4,106 bytes, lines 1772-1862
1772 self.update(); 1773 lastSnap = scrollFunc(); 1774 1775 if (animation) { 1776 scrubTween ? scrubTween.resetTo("totalProgress", endValue, animation._tTime / animation._tDur) : animation.progress(endValue); 1777 } 1778 1779 snap1 = snap2 = animation && !isToggle ? animation.totalProgress() : self.progress; 1780 onSnapComplete && onSnapComplete(self); 1781 _onComplete && _onComplete(self); 1782 } 1783 }, scroll, change1 * change, endScroll - scroll - change1 * change); 1784 onStart && onStart(self, tweenTo.tween); 1785 } 1786 } else if (self.isActive && lastSnap !== scroll) { 1787 snapDelayedCall.restart(true); 1788 } 1789 }).pause(); 1790 } 1791 1792 id && (_ids[id] = self); 1793 trigger = self.trigger = _getTarget(trigger || pin !== true && pin); 1794 customRevertReturn = trigger && trigger._gsap && trigger._gsap.stRevert; 1795 customRevertReturn && (customRevertReturn = customRevertReturn(self)); 1796 pin = pin === true ? trigger : _getTarget(pin); 1797 _isString(toggleClass) && (toggleClass = { 1798 targets: trigger, 1799 className: toggleClass 1800 }); 1801 1802 if (pin) { 1803 pinSpacing === false || pinSpacing === _margin || (pinSpacing = !pinSpacing && pin.parentNode && pin.parentNode.style && _getComputedStyle(pin.parentNode).display === "flex" ? false : _padding); 1804 self.pin = pin; 1805 pinCache = gsap$1.core.getCache(pin); 1806 1807 if (!pinCache.spacer) { 1808 if (pinSpacer) { 1809 pinSpacer = _getTarget(pinSpacer); 1810 pinSpacer && !pinSpacer.nodeType && (pinSpacer = pinSpacer.current || pinSpacer.nativeElement); 1811 pinCache.spacerIsNative = !!pinSpacer; 1812 pinSpacer && (pinCache.spacerState = _getState(pinSpacer)); 1813 } 1814 1815 pinCache.spacer = spacer = pinSpacer || _doc$1.createElement("div"); 1816 spacer.classList.add("pin-spacer"); 1817 id && spacer.classList.add("pin-spacer-" + id); 1818 pinCache.pinState = pinOriginalState = _getState(pin); 1819 } else { 1820 pinOriginalState = pinCache.pinState; 1821 } 1822 1823 vars.force3D !== false && gsap$1.set(pin, { 1824 force3D: true 1825 }); 1826 self.spacer = spacer = pinCache.spacer; 1827 cs = _getComputedStyle(pin); 1828 spacingStart = cs[pinSpacing + direction.os2]; 1829 pinGetter = gsap$1.getProperty(pin); 1830 pinSetter = gsap$1.quickSetter(pin, direction.a, _px); 1831 1832 _swapPinIn(pin, spacer, cs); 1833 1834 pinState = _getState(pin); 1835 } 1836 1837 if (markers) { 1838 markerVars = _isObject(markers) ? _setDefaults(markers, _markerDefaults) : _markerDefaults; 1839 markerStartTrigger = _createMarker("scroller-start", id, scroller, direction, markerVars, 0); 1840 markerEndTrigger = _createMarker("scroller-end", id, scroller, direction, markerVars, 0, markerStartTrigger); 1841 offset = markerStartTrigger["offset" + direction.op.d2]; 1842 1843 var content = _getTarget(_getProxyProp(scroller, "content") || scroller); 1844 1845 markerStart = this.markerStart = _createMarker("start", id, content, direction, markerVars, offset, 0, containerAnimation); 1846 markerEnd = this.markerEnd = _createMarker("end", id, content, direction, markerVars, offset, 0, containerAnimation); 1847 containerAnimation && (caMarkerSetter = gsap$1.quickSetter([markerStart, markerEnd], direction.a, _px)); 1848 1849 if (!useFixedPosition && !(_proxies.length && _getProxyProp(scroller, "fixedMarkers") === true)) { 1850 _makePositionable(isViewport ? _body$1 : scroller); 1851 1852 gsap$1.set([markerStartTrigger, markerEndTrigger], { 1853 force3D: true 1854 }); 1855 markerStartSetter = gsap$1.quickSetter(markerStartTrigger, direction.a, _px); 1856 markerEndSetter = gsap$1.quickSetter(markerEndTrigger, direction.a, _px); 1857 } 1858 } 1859 1860 if (containerAnimation) { 1861 var oldOnUpdate = containerAnimation.vars.onUpdate, 1862 oldParams = containerAnimation.vars.onUpdateParams;
vendor: 5,884 bytes, lines 1863-2014
1863 containerAnimation.eventCallback("onUpdate", function () { 1864 self.update(0, 0, 1); 1865 oldOnUpdate && oldOnUpdate.apply(containerAnimation, oldParams || []); 1866 }); 1867 } 1868 1869 self.previous = function () { 1870 return _triggers[_triggers.indexOf(self) - 1]; 1871 }; 1872 1873 self.next = function () { 1874 return _triggers[_triggers.indexOf(self) + 1]; 1875 }; 1876 1877 self.revert = function (revert, temp) { 1878 if (!temp) { 1879 return self.kill(true); 1880 } 1881 1882 var r = revert !== false || !self.enabled, 1883 prevRefreshing = _refreshing; 1884 1885 if (r !== self.isReverted) { 1886 if (r) { 1887 prevScroll = Math.max(scrollFunc(), self.scroll.rec || 0); 1888 prevProgress = self.progress; 1889 prevAnimProgress = animation && animation.progress(); 1890 } 1891 1892 markerStart && [markerStart, markerEnd, markerStartTrigger, markerEndTrigger].forEach(function (m) { 1893 return m.style.display = r ? "none" : "block"; 1894 }); 1895 1896 if (r) { 1897 _refreshing = self; 1898 self.update(r); 1899 } 1900 1901 if (pin && (!pinReparent || !self.isActive)) { 1902 if (r) { 1903 _swapPinOut(pin, spacer, pinOriginalState); 1904 } else { 1905 _swapPinIn(pin, spacer, _getComputedStyle(pin), spacerState); 1906 } 1907 } 1908 1909 r || self.update(r); 1910 _refreshing = prevRefreshing; 1911 self.isReverted = r; 1912 } 1913 }; 1914 1915 self.refresh = function (soft, force, position, pinOffset) { 1916 if ((_refreshing || !self.enabled) && !force) { 1917 return; 1918 } 1919 1920 if (pin && soft && _lastScrollTime) { 1921 _addListener$1(ScrollTrigger, "scrollEnd", _softRefresh); 1922 1923 return; 1924 } 1925 1926 !_refreshingAll && onRefreshInit && onRefreshInit(self); 1927 _refreshing = self; 1928 1929 if (tweenTo.tween && !position) { 1930 tweenTo.tween.kill(); 1931 tweenTo.tween = 0; 1932 } 1933 1934 scrubTween && scrubTween.pause(); 1935 invalidateOnRefresh && animation && animation.revert({ 1936 kill: false 1937 }).invalidate(); 1938 self.isReverted || self.revert(true, true); 1939 self._subPinOffset = false; 1940 1941 var size = getScrollerSize(), 1942 scrollerBounds = getScrollerOffsets(), 1943 max = containerAnimation ? containerAnimation.duration() : _maxScroll(scroller, direction), 1944 isFirstRefresh = change <= 0.01, 1945 offset = 0, 1946 otherPinOffset = pinOffset || 0, 1947 parsedEnd = _isObject(position) ? position.end : vars.end, 1948 parsedEndTrigger = vars.endTrigger || trigger, 1949 parsedStart = _isObject(position) ? position.start : vars.start || (vars.start === 0 || !trigger ? 0 : pin ? "0 0" : "0 100%"), 1950 pinnedContainer = self.pinnedContainer = vars.pinnedContainer && _getTarget(vars.pinnedContainer, self), 1951 triggerIndex = trigger && Math.max(0, _triggers.indexOf(self)) || 0, 1952 i = triggerIndex, 1953 cs, 1954 bounds, 1955 scroll, 1956 isVertical, 1957 override, 1958 curTrigger, 1959 curPin, 1960 oppositeScroll, 1961 initted, 1962 revertedPins, 1963 forcedOverflow, 1964 markerStartOffset, 1965 markerEndOffset; 1966 1967 if (markers && _isObject(position)) { 1968 markerStartOffset = gsap$1.getProperty(markerStartTrigger, direction.p); 1969 markerEndOffset = gsap$1.getProperty(markerEndTrigger, direction.p); 1970 } 1971 1972 while (i--) { 1973 curTrigger = _triggers[i]; 1974 curTrigger.end || curTrigger.refresh(0, 1) || (_refreshing = self); 1975 curPin = curTrigger.pin; 1976 1977 if (curPin && (curPin === trigger || curPin === pin || curPin === pinnedContainer) && !curTrigger.isReverted) { 1978 revertedPins || (revertedPins = []); 1979 revertedPins.unshift(curTrigger); 1980 curTrigger.revert(true, true); 1981 } 1982 1983 if (curTrigger !== _triggers[i]) { 1984 triggerIndex--; 1985 i--; 1986 } 1987 } 1988 1989 _isFunction(parsedStart) && (parsedStart = parsedStart(self)); 1990 parsedStart = _parseClamp(parsedStart, "start", self); 1991 start = _parsePosition(parsedStart, trigger, size, direction, scrollFunc(), markerStart, markerStartTrigger, self, scrollerBounds, borderWidth, useFixedPosition, max, containerAnimation, self._startClamp && "_startClamp") || (pin ? -0.001 : 0); 1992 _isFunction(parsedEnd) && (parsedEnd = parsedEnd(self)); 1993 1994 if (_isString(parsedEnd) && !parsedEnd.indexOf("+=")) { 1995 if (~parsedEnd.indexOf(" ")) { 1996 parsedEnd = (_isString(parsedStart) ? parsedStart.split(" ")[0] : "") + parsedEnd; 1997 } else { 1998 offset = _offsetToPx(parsedEnd.substr(2), size); 1999 parsedEnd = _isString(parsedStart) ? parsedStart : (containerAnimation ? gsap$1.utils.mapRange(0, containerAnimation.duration(), containerAnimation.scrollTrigger.start, containerAnimation.scrollTrigger.end, start) : start) + offset; 2000 parsedEndTrigger = trigger; 2001 } 2002 } 2003 2004 parsedEnd = _parseClamp(parsedEnd, "end", self); 2005 end = Math.max(start, _parsePosition(parsedEnd || (parsedEndTrigger ? "100% 0" : max), parsedEndTrigger, size, direction, scrollFunc() + offset, markerEnd, markerEndTrigger, self, scrollerBounds, borderWidth, useFixedPosition, max, containerAnimation, self._endClamp && "_endClamp")) || -0.001; 2006 offset = 0; 2007 i = triggerIndex; 2008 2009 while (i--) { 2010 curTrigger = _triggers[i]; 2011 curPin = curTrigger.pin; 2012 2013 if (curPin && curTrigger.start - curTrigger._pinPush <= start && !containerAnimation && curTrigger.end > 0) { 2014 cs = curTrigger.end - (self._startClamp ? Math.max(0, curTr
vendor: 6,320 bytes, lines 2014-2173
2014igger.start) : curTrigger.start); 2015 2016 if ((curPin === trigger && curTrigger.start - curTrigger._pinPush < start || curPin === pinnedContainer) && isNaN(parsedStart)) { 2017 offset += cs * (1 - curTrigger.progress); 2018 } 2019 2020 curPin === pin && (otherPinOffset += cs); 2021 } 2022 } 2023 2024 start += offset; 2025 end += offset; 2026 self._startClamp && (self._startClamp += offset); 2027 2028 if (self._endClamp && !_refreshingAll) { 2029 self._endClamp = end || -0.001; 2030 end = Math.min(end, _maxScroll(scroller, direction)); 2031 } 2032 2033 change = end - start || (start -= 0.01) && 0.001; 2034 2035 if (isFirstRefresh) { 2036 prevProgress = gsap$1.utils.clamp(0, 1, gsap$1.utils.normalize(start, end, prevScroll)); 2037 } 2038 2039 self._pinPush = otherPinOffset; 2040 2041 if (markerStart && offset) { 2042 cs = {}; 2043 cs[direction.a] = "+=" + offset; 2044 pinnedContainer && (cs[direction.p] = "-=" + scrollFunc()); 2045 gsap$1.set([markerStart, markerEnd], cs); 2046 } 2047 2048 if (pin && !(_clampingMax && self.end >= _maxScroll(scroller, direction))) { 2049 cs = _getComputedStyle(pin); 2050 isVertical = direction === _vertical; 2051 scroll = scrollFunc(); 2052 pinStart = parseFloat(pinGetter(direction.a)) + otherPinOffset; 2053 2054 if (!max && end > 1) { 2055 forcedOverflow = (isViewport ? _doc$1.scrollingElement || _docEl$1 : scroller).style; 2056 forcedOverflow = { 2057 style: forcedOverflow, 2058 value: forcedOverflow["overflow" + direction.a.toUpperCase()] 2059 }; 2060 2061 if (isViewport && _getComputedStyle(_body$1)["overflow" + direction.a.toUpperCase()] !== "scroll") { 2062 forcedOverflow.style["overflow" + direction.a.toUpperCase()] = "scroll"; 2063 } 2064 } 2065 2066 _swapPinIn(pin, spacer, cs); 2067 2068 pinState = _getState(pin); 2069 bounds = _getBounds(pin, true); 2070 oppositeScroll = useFixedPosition && _getScrollFunc(scroller, isVertical ? _horizontal : _vertical)(); 2071 2072 if (pinSpacing) { 2073 spacerState = [pinSpacing + direction.os2, change + otherPinOffset + _px]; 2074 spacerState.t = spacer; 2075 i = pinSpacing === _padding ? _getSize(pin, direction) + change + otherPinOffset : 0; 2076 2077 if (i) { 2078 spacerState.push(direction.d, i + _px); 2079 spacer.style.flexBasis !== "auto" && (spacer.style.flexBasis = i + _px); 2080 } 2081 2082 _setState(spacerState); 2083 2084 if (pinnedContainer) { 2085 _triggers.forEach(function (t) { 2086 if (t.pin === pinnedContainer && t.vars.pinSpacing !== false) { 2087 t._subPinOffset = true; 2088 } 2089 }); 2090 } 2091 2092 useFixedPosition && scrollFunc(prevScroll); 2093 } else { 2094 i = _getSize(pin, direction); 2095 i && spacer.style.flexBasis !== "auto" && (spacer.style.flexBasis = i + _px); 2096 } 2097 2098 if (useFixedPosition) { 2099 override = { 2100 top: bounds.top + (isVertical ? scroll - start : oppositeScroll) + _px, 2101 left: bounds.left + (isVertical ? oppositeScroll : scroll - start) + _px, 2102 boxSizing: "border-box", 2103 position: "fixed" 2104 }; 2105 override[_width] = override["max" + _Width] = Math.ceil(bounds.width) + _px; 2106 override[_height] = override["max" + _Height] = Math.ceil(bounds.height) + _px; 2107 override[_margin] = override[_margin + _Top] = override[_margin + _Right] = override[_margin + _Bottom] = override[_margin + _Left] = "0"; 2108 override[_padding] = cs[_padding]; 2109 override[_padding + _Top] = cs[_padding + _Top]; 2110 override[_padding + _Right] = cs[_padding + _Right]; 2111 override[_padding + _Bottom] = cs[_padding + _Bottom]; 2112 override[_padding + _Left] = cs[_padding + _Left]; 2113 pinActiveState = _copyState(pinOriginalState, override, pinReparent); 2114 _refreshingAll && scrollFunc(0); 2115 } 2116 2117 if (animation) { 2118 initted = animation._initted; 2119 2120 _suppressOverwrites(1); 2121 2122 animation.render(animation.duration(), true, true); 2123 pinChange = pinGetter(direction.a) - pinStart + change + otherPinOffset; 2124 pinMoves = Math.abs(change - pinChange) > 1; 2125 useFixedPosition && pinMoves && pinActiveState.splice(pinActiveState.length - 2, 2); 2126 animation.render(0, true, true); 2127 initted || animation.invalidate(true); 2128 animation.parent || animation.totalTime(animation.totalTime()); 2129 2130 _suppressOverwrites(0); 2131 } else { 2132 pinChange = change; 2133 } 2134 2135 forcedOverflow && (forcedOverflow.value ? forcedOverflow.style["overflow" + direction.a.toUpperCase()] = forcedOverflow.value : forcedOverflow.style.removeProperty("overflow-" + direction.a)); 2136 } else if (trigger && scrollFunc() && !containerAnimation) { 2137 bounds = trigger.parentNode; 2138 2139 while (bounds && bounds !== _body$1) { 2140 if (bounds._pinOffset) { 2141 start -= bounds._pinOffset; 2142 end -= bounds._pinOffset; 2143 } 2144 2145 bounds = bounds.parentNode; 2146 } 2147 } 2148 2149 revertedPins && revertedPins.forEach(function (t) { 2150 return t.revert(false, true); 2151 }); 2152 self.start = start; 2153 self.end = end; 2154 scroll1 = scroll2 = _refreshingAll ? prevScroll : scrollFunc(); 2155 2156 if (!containerAnimation && !_refreshingAll) { 2157 scroll1 < prevScroll && scrollFunc(prevScroll); 2158 self.scroll.rec = 0; 2159 } 2160 2161 self.revert(false, true); 2162 lastRefresh = _getTime$1(); 2163 2164 if (snapDelayedCall) { 2165 lastSnap = -1; 2166 snapDelayedCall.restart(true); 2167 } 2168 2169 _refreshing = 0; 2170 animation && isToggle && (animation._initted || prevAnimProgress) && animation.progress() !== prevAnimProgress && animation.progress(prevAnimProgress || 0, true).render(animation.time(), true, true); 2171 2172 if (isFirstRefresh || prevProgress !== self.progress || containerAnimation || invalidateOnRefresh) { 2173 animation && !isToggle
vendor: 10,310 bytes, lines 2173-2429
2173 && animation.totalProgress(containerAnimation && start < -0.001 && !prevProgress ? gsap$1.utils.normalize(start, end, 0) : prevProgress, true); 2174 self.progress = isFirstRefresh || (scroll1 - start) / change === prevProgress ? 0 : prevProgress; 2175 } 2176 2177 pin && pinSpacing && (spacer._pinOffset = Math.round(self.progress * pinChange)); 2178 scrubTween && scrubTween.invalidate(); 2179 2180 if (!isNaN(markerStartOffset)) { 2181 markerStartOffset -= gsap$1.getProperty(markerStartTrigger, direction.p); 2182 markerEndOffset -= gsap$1.getProperty(markerEndTrigger, direction.p); 2183 2184 _shiftMarker(markerStartTrigger, direction, markerStartOffset); 2185 2186 _shiftMarker(markerStart, direction, markerStartOffset - (pinOffset || 0)); 2187 2188 _shiftMarker(markerEndTrigger, direction, markerEndOffset); 2189 2190 _shiftMarker(markerEnd, direction, markerEndOffset - (pinOffset || 0)); 2191 } 2192 2193 isFirstRefresh && !_refreshingAll && self.update(); 2194 2195 if (onRefresh && !_refreshingAll && !executingOnRefresh) { 2196 executingOnRefresh = true; 2197 onRefresh(self); 2198 executingOnRefresh = false; 2199 } 2200 }; 2201 2202 self.getVelocity = function () { 2203 return (scrollFunc() - scroll2) / (_getTime$1() - _time2) * 1000 || 0; 2204 }; 2205 2206 self.endAnimation = function () { 2207 _endAnimation(self.callbackAnimation); 2208 2209 if (animation) { 2210 scrubTween ? scrubTween.progress(1) : !animation.paused() ? _endAnimation(animation, animation.reversed()) : isToggle || _endAnimation(animation, self.direction < 0, 1); 2211 } 2212 }; 2213 2214 self.labelToScroll = function (label) { 2215 return animation && animation.labels && (start || self.refresh() || start) + animation.labels[label] / animation.duration() * change || 0; 2216 }; 2217 2218 self.getTrailing = function (name) { 2219 var i = _triggers.indexOf(self), 2220 a = self.direction > 0 ? _triggers.slice(0, i).reverse() : _triggers.slice(i + 1); 2221 2222 return (_isString(name) ? a.filter(function (t) { 2223 return t.vars.preventOverlaps === name; 2224 }) : a).filter(function (t) { 2225 return self.direction > 0 ? t.end <= start : t.start >= end; 2226 }); 2227 }; 2228 2229 self.update = function (reset, recordVelocity, forceFake) { 2230 if (containerAnimation && !forceFake && !reset) { 2231 return; 2232 } 2233 2234 var scroll = _refreshingAll === true ? prevScroll : self.scroll(), 2235 p = reset ? 0 : (scroll - start) / change, 2236 clipped = p < 0 ? 0 : p > 1 ? 1 : p || 0, 2237 prevProgress = self.progress, 2238 isActive, 2239 wasActive, 2240 toggleState, 2241 action, 2242 stateChanged, 2243 toggled, 2244 isAtMax, 2245 isTakingAction; 2246 2247 if (recordVelocity) { 2248 scroll2 = scroll1; 2249 scroll1 = containerAnimation ? scrollFunc() : scroll; 2250 2251 if (snap) { 2252 snap2 = snap1; 2253 snap1 = animation && !isToggle ? animation.totalProgress() : clipped; 2254 } 2255 } 2256 2257 if (anticipatePin && pin && !_refreshing && !_startup$1 && _lastScrollTime) { 2258 if (!clipped && start < scroll + (scroll - scroll2) / (_getTime$1() - _time2) * anticipatePin) { 2259 clipped = 0.0001; 2260 } else if (clipped === 1 && end > scroll + (scroll - scroll2) / (_getTime$1() - _time2) * anticipatePin) { 2261 clipped = 0.9999; 2262 } 2263 } 2264 2265 if (clipped !== prevProgress && self.enabled) { 2266 isActive = self.isActive = !!clipped && clipped < 1; 2267 wasActive = !!prevProgress && prevProgress < 1; 2268 toggled = isActive !== wasActive; 2269 stateChanged = toggled || !!clipped !== !!prevProgress; 2270 self.direction = clipped > prevProgress ? 1 : -1; 2271 self.progress = clipped; 2272 2273 if (stateChanged && !_refreshing) { 2274 toggleState = clipped && !prevProgress ? 0 : clipped === 1 ? 1 : prevProgress === 1 ? 2 : 3; 2275 2276 if (isToggle) { 2277 action = !toggled && toggleActions[toggleState + 1] !== "none" && toggleActions[toggleState + 1] || toggleActions[toggleState]; 2278 isTakingAction = animation && (action === "complete" || action === "reset" || action in animation); 2279 } 2280 } 2281 2282 preventOverlaps && (toggled || isTakingAction) && (isTakingAction || scrub || !animation) && (_isFunction(preventOverlaps) ? preventOverlaps(self) : self.getTrailing(preventOverlaps).forEach(function (t) { 2283 return t.endAnimation(); 2284 })); 2285 2286 if (!isToggle) { 2287 if (scrubTween && !_refreshing && !_startup$1) { 2288 scrubTween._dp._time - scrubTween._start !== scrubTween._time && scrubTween.render(scrubTween._dp._time - scrubTween._start); 2289 2290 if (scrubTween.resetTo) { 2291 scrubTween.resetTo("totalProgress", clipped, animation._tTime / animation._tDur); 2292 } else { 2293 scrubTween.vars.totalProgress = clipped; 2294 scrubTween.invalidate().restart(); 2295 } 2296 } else if (animation) { 2297 animation.totalProgress(clipped, !!(_refreshing && (lastRefresh || reset))); 2298 } 2299 } 2300 2301 if (pin) { 2302 reset && pinSpacing && (spacer.style[pinSpacing + direction.os2] = spacingStart); 2303 2304 if (!useFixedPosition) { 2305 pinSetter(_round(pinStart + pinChange * clipped)); 2306 } else if (stateChanged) { 2307 isAtMax = !reset && clipped > prevProgress && end + 1 > scroll && scroll + 1 >= _maxScroll(scroller, direction); 2308 2309 if (pinReparent) { 2310 if (!reset && (isActive || isAtMax)) { 2311 var bounds = _getBounds(pin, true), 2312 _offset = scroll - start; 2313 2314 _reparent(pin, _body$1, bounds.top + (direction === _vertical ? _offset : 0) + _px, bounds.left + (direction === _vertical ? 0 : _offset) + _px); 2315 } else { 2316 _reparent(pin, spacer); 2317 } 2318 } 2319 2320 _setState(isActive || isAtMax ? pinActiveState : pinState); 2321 2322 pinMoves && clipped < 1 && isActive || pinSetter(pinStart + (clipped === 1 && !isAtMax ? pinChange : 0)); 2323 } 2324 } 2325 2326 snap && !tweenTo.tween && !_refreshing && !_startup$1 && snapDelayedCall.restart(true); 2327 toggleClass && (toggled || once && clipped && (clipped < 1 || !_limitCallbacks)) && _toArray(toggleClass.targets).forEach(function (el) { 2328 return el.classList[isActive || once ? "add" : "remove"](toggleClass.className); 2329 }); 2330 onUpdate && !isToggle && !reset && onUpdate(self); 2331 2332 if (stateChanged && !_refreshing) { 2333 if (isToggle) { 2334 if (isTakingAction) { 2335 if (action === "complete") { 2336 animation.pause().totalProgress(1); 2337 } else if (action === "reset") { 2338 animation.restart(true).pause(); 2339 } else if (action === "restart") { 2340 animation.restart(true); 2341 } else { 2342 animation[action](); 2343 } 2344 } 2345 2346 onUpdate && onUpdate(self); 2347 } 2348 2349 if (toggled || !_limitCallbacks) { 2350 onToggle && toggled && _callback(self, onToggle); 2351 callbacks[toggleState] && _callback(self, callbacks[toggleState]); 2352 once && (clipped === 1 ? self.kill(false, 1) : callbacks[toggleState] = 0); 2353 2354 if (!toggled) { 2355 toggleState = clipped === 1 ? 1 : 3; 2356 callbacks[toggleState] && _callback(self, callbacks[toggleState]); 2357 } 2358 } 2359 2360 if (fastScrollEnd && !isActive && Math.abs(self.getVelocity()) > (_isNumber(fastScrollEnd) ? fastScrollEnd : 2500)) { 2361 _endAnimation(self.callbackAnimation); 2362 2363 scrubTween ? scrubTween.progress(1) : _endAnimation(animation, action === "reverse" ? 1 : !clipped, 1); 2364 } 2365 } else if (isToggle && onUpdate && !_refreshing) { 2366 onUpdate(self); 2367 } 2368 } 2369 2370 if (markerEndSetter) { 2371 var n = containerAnimation ? scroll / containerAnimation.duration() * (containerAnimation._caScrollDist || 0) : scroll; 2372 markerStartSetter(n + (markerStartTrigger._isFlipped ? 1 : 0)); 2373 markerEndSetter(n); 2374 } 2375 2376 caMarkerSetter && caMarkerSetter(-scroll / containerAnimation.duration() * (containerAnimation._caScrollDist || 0)); 2377 }; 2378 2379 self.enable = function (reset, refresh) { 2380 if (!self.enabled) { 2381 self.enabled = true; 2382 2383 _addListener$1(scroller, "resize", _onResize); 2384 2385 isViewport || _addListener$1(scroller, "scroll", _onScroll$1); 2386 onRefreshInit && _addListener$1(ScrollTrigger, "refreshInit", onRefreshInit); 2387 2388 if (reset !== false) { 2389 self.progress = prevProgress = 0; 2390 scroll1 = scroll2 = lastSnap = scrollFunc(); 2391 } 2392 2393 refresh !== false && self.refresh(); 2394 } 2395 }; 2396 2397 self.getTween = function (snap) { 2398 return snap && tweenTo ? tweenTo.tween : scrubTween; 2399 }; 2400 2401 self.setPositions = function (newStart, newEnd, keepClamp, pinOffset) { 2402 if (containerAnimation) { 2403 var st = containerAnimation.scrollTrigger, 2404 duration = containerAnimation.duration(), 2405 _change = st.end - st.start; 2406 2407 newStart = st.start + _change * newStart / duration; 2408 newEnd = st.start + _change * newEnd / duration; 2409 } 2410 2411 self.refresh(false, false, { 2412 start: _keepClamp(newStart, keepClamp && !!self._startClamp), 2413 end: _keepClamp(newEnd, keepClamp && !!self._endClamp) 2414 }, pinOffset); 2415 self.update(); 2416 }; 2417 2418 self.adjustPinSpacing = function (amount) { 2419 if (spacerState && amount) { 2420 var i = spacerState.indexOf(direction.d) + 1; 2421 spacerState[i] = parseFloat(spacerState[i]) + amount + _px; 2422 spacerState[1] = parseFloat(spacerState[1]) + amount + _px; 2423 2424 _setState(spacerState); 2425 } 2426 }; 2427 2428 self.disable = function (reset, allowAnimation) { 2429
vendor: 12,071 bytes, lines 2429-2793
2429if (self.enabled) { 2430 reset !== false && self.revert(true, true); 2431 self.enabled = self.isActive = false; 2432 allowAnimation || scrubTween && scrubTween.pause(); 2433 prevScroll = 0; 2434 pinCache && (pinCache.uncache = 1); 2435 onRefreshInit && _removeListener$1(ScrollTrigger, "refreshInit", onRefreshInit); 2436 2437 if (snapDelayedCall) { 2438 snapDelayedCall.pause(); 2439 tweenTo.tween && tweenTo.tween.kill() && (tweenTo.tween = 0); 2440 } 2441 2442 if (!isViewport) { 2443 var i = _triggers.length; 2444 2445 while (i--) { 2446 if (_triggers[i].scroller === scroller && _triggers[i] !== self) { 2447 return; 2448 } 2449 } 2450 2451 _removeListener$1(scroller, "resize", _onResize); 2452 2453 isViewport || _removeListener$1(scroller, "scroll", _onScroll$1); 2454 } 2455 } 2456 }; 2457 2458 self.kill = function (revert, allowAnimation) { 2459 self.disable(revert, allowAnimation); 2460 scrubTween && !allowAnimation && scrubTween.kill(); 2461 id && delete _ids[id]; 2462 2463 var i = _triggers.indexOf(self); 2464 2465 i >= 0 && _triggers.splice(i, 1); 2466 i === _i && _direction > 0 && _i--; 2467 i = 0; 2468 2469 _triggers.forEach(function (t) { 2470 return t.scroller === self.scroller && (i = 1); 2471 }); 2472 2473 i || _refreshingAll || (self.scroll.rec = 0); 2474 2475 if (animation) { 2476 animation.scrollTrigger = null; 2477 revert && animation.revert({ 2478 kill: false 2479 }); 2480 allowAnimation || animation.kill(); 2481 } 2482 2483 markerStart && [markerStart, markerEnd, markerStartTrigger, markerEndTrigger].forEach(function (m) { 2484 return m.parentNode && m.parentNode.removeChild(m); 2485 }); 2486 _primary === self && (_primary = 0); 2487 2488 if (pin) { 2489 pinCache && (pinCache.uncache = 1); 2490 i = 0; 2491 2492 _triggers.forEach(function (t) { 2493 return t.pin === pin && i++; 2494 }); 2495 2496 i || (pinCache.spacer = 0); 2497 } 2498 2499 vars.onKill && vars.onKill(self); 2500 }; 2501 2502 _triggers.push(self); 2503 2504 self.enable(false, false); 2505 customRevertReturn && customRevertReturn(self); 2506 2507 if (animation && animation.add && !change) { 2508 var updateFunc = self.update; 2509 2510 self.update = function () { 2511 self.update = updateFunc; 2512 start || end || self.refresh(); 2513 }; 2514 2515 gsap$1.delayedCall(0.01, self.update); 2516 change = 0.01; 2517 start = end = 0; 2518 } else { 2519 self.refresh(); 2520 } 2521 2522 pin && _queueRefreshAll(); 2523 }; 2524 2525 ScrollTrigger.register = function register(core) { 2526 if (!_coreInitted$1) { 2527 gsap$1 = core || _getGSAP$1(); 2528 _windowExists() && window.document && ScrollTrigger.enable(); 2529 _coreInitted$1 = _enabled; 2530 } 2531 2532 return _coreInitted$1; 2533 }; 2534 2535 ScrollTrigger.defaults = function defaults(config) { 2536 if (config) { 2537 for (var p in config) { 2538 _defaults[p] = config[p]; 2539 } 2540 } 2541 2542 return _defaults; 2543 }; 2544 2545 ScrollTrigger.disable = function disable(reset, kill) { 2546 _enabled = 0; 2547 2548 _triggers.forEach(function (trigger) { 2549 return trigger[kill ? "kill" : "disable"](reset); 2550 }); 2551 2552 _removeListener$1(_win$1, "wheel", _onScroll$1); 2553 2554 _removeListener$1(_doc$1, "scroll", _onScroll$1); 2555 2556 clearInterval(_syncInterval); 2557 2558 _removeListener$1(_doc$1, "touchcancel", _passThrough); 2559 2560 _removeListener$1(_body$1, "touchstart", _passThrough); 2561 2562 _multiListener(_removeListener$1, _doc$1, "pointerdown,touchstart,mousedown", _pointerDownHandler); 2563 2564 _multiListener(_removeListener$1, _doc$1, "pointerup,touchend,mouseup", _pointerUpHandler); 2565 2566 _resizeDelay.kill(); 2567 2568 _iterateAutoRefresh(_removeListener$1); 2569 2570 for (var i = 0; i < _scrollers.length; i += 3) { 2571 _wheelListener(_removeListener$1, _scrollers[i], _scrollers[i + 1]); 2572 2573 _wheelListener(_removeListener$1, _scrollers[i], _scrollers[i + 2]); 2574 } 2575 }; 2576 2577 ScrollTrigger.enable = function enable() { 2578 _win$1 = window; 2579 _doc$1 = document; 2580 _docEl$1 = _doc$1.documentElement; 2581 _body$1 = _doc$1.body; 2582 2583 if (gsap$1) { 2584 _toArray = gsap$1.utils.toArray; 2585 _clamp$1 = gsap$1.utils.clamp; 2586 _context$1 = gsap$1.core.context || _passThrough; 2587 _suppressOverwrites = gsap$1.core.suppressOverwrites || _passThrough; 2588 _scrollRestoration = _win$1.history.scrollRestoration || "auto"; 2589 _lastScroll = _win$1.pageYOffset; 2590 gsap$1.core.globals("ScrollTrigger", ScrollTrigger); 2591 2592 if (_body$1) { 2593 _enabled = 1; 2594 _div100vh = document.createElement("div"); 2595 _div100vh.style.height = "100vh"; 2596 _div100vh.style.position = "absolute"; 2597 2598 _refresh100vh(); 2599 2600 _rafBugFix(); 2601 2602 Observer.register(gsap$1); 2603 ScrollTrigger.isTouch = Observer.isTouch; 2604 _fixIOSBug = Observer.isTouch && /(iPad|iPhone|iPod|Mac)/g.test(navigator.userAgent); 2605 _ignoreMobileResize = Observer.isTouch === 1; 2606 2607 _addListener$1(_win$1, "wheel", _onScroll$1); 2608 2609 _root$1 = [_win$1, _doc$1, _docEl$1, _body$1]; 2610 2611 if (gsap$1.matchMedia) { 2612 ScrollTrigger.matchMedia = function (vars) { 2613 var mm = gsap$1.matchMedia(), 2614 p; 2615 2616 for (p in vars) { 2617 mm.add(p, vars[p]); 2618 } 2619 2620 return mm; 2621 }; 2622 2623 gsap$1.addEventListener("matchMediaInit", function () { 2624 return _revertAll(); 2625 }); 2626 gsap$1.addEventListener("matchMediaRevert", function () { 2627 return _revertRecorded(); 2628 }); 2629 gsap$1.addEventListener("matchMedia", function () { 2630 _refreshAll(0, 1); 2631 2632 _dispatch("matchMedia"); 2633 }); 2634 gsap$1.matchMedia("(orientation: portrait)", function () { 2635 _setBaseDimensions(); 2636 2637 return _setBaseDimensions; 2638 }); 2639 } else { 2640 console.warn("Requires GSAP 3.11.0 or later"); 2641 } 2642 2643 _setBaseDimensions(); 2644 2645 _addListener$1(_doc$1, "scroll", _onScroll$1); 2646 2647 var bodyStyle = _body$1.style, 2648 border = bodyStyle.borderTopStyle, 2649 AnimationProto = gsap$1.core.Animation.prototype, 2650 bounds, 2651 i; 2652 AnimationProto.revert || Object.defineProperty(AnimationProto, "revert", { 2653 value: function value() { 2654 return this.time(-0.01, true); 2655 } 2656 }); 2657 bodyStyle.borderTopStyle = "solid"; 2658 bounds = _getBounds(_body$1); 2659 _vertical.m = Math.round(bounds.top + _vertical.sc()) || 0; 2660 _horizontal.m = Math.round(bounds.left + _horizontal.sc()) || 0; 2661 border ? bodyStyle.borderTopStyle = border : bodyStyle.removeProperty("border-top-style"); 2662 _syncInterval = setInterval(_sync, 250); 2663 gsap$1.delayedCall(0.5, function () { 2664 return _startup$1 = 0; 2665 }); 2666 2667 _addListener$1(_doc$1, "touchcancel", _passThrough); 2668 2669 _addListener$1(_body$1, "touchstart", _passThrough); 2670 2671 _multiListener(_addListener$1, _doc$1, "pointerdown,touchstart,mousedown", _pointerDownHandler); 2672 2673 _multiListener(_addListener$1, _doc$1, "pointerup,touchend,mouseup", _pointerUpHandler); 2674 2675 _transformProp = gsap$1.utils.checkPrefix("transform"); 2676 2677 _stateProps.push(_transformProp); 2678 2679 _coreInitted$1 = _getTime$1(); 2680 _resizeDelay = gsap$1.delayedCall(0.2, _refreshAll).pause(); 2681 _autoRefresh = [_doc$1, "visibilitychange", function () { 2682 var w = _win$1.innerWidth, 2683 h = _win$1.innerHeight; 2684 2685 if (_doc$1.hidden) { 2686 _prevWidth = w; 2687 _prevHeight = h; 2688 } else if (_prevWidth !== w || _prevHeight !== h) { 2689 _onResize(); 2690 } 2691 }, _doc$1, "DOMContentLoaded", _refreshAll, _win$1, "load", _refreshAll, _win$1, "resize", _onResize]; 2692 2693 _iterateAutoRefresh(_addListener$1); 2694 2695 _triggers.forEach(function (trigger) { 2696 return trigger.enable(0, 1); 2697 }); 2698 2699 for (i = 0; i < _scrollers.length; i += 3) { 2700 _wheelListener(_removeListener$1, _scrollers[i], _scrollers[i + 1]); 2701 2702 _wheelListener(_removeListener$1, _scrollers[i], _scrollers[i + 2]); 2703 } 2704 } 2705 } 2706 }; 2707 2708 ScrollTrigger.config = function config(vars) { 2709 "limitCallbacks" in vars && (_limitCallbacks = !!vars.limitCallbacks); 2710 var ms = vars.syncInterval; 2711 ms && clearInterval(_syncInterval) || (_syncInterval = ms) && setInterval(_sync, ms); 2712 "ignoreMobileResize" in vars && (_ignoreMobileResize = ScrollTrigger.isTouch === 1 && vars.ignoreMobileResize); 2713 2714 if ("autoRefreshEvents" in vars) { 2715 _iterateAutoRefresh(_removeListener$1) || _iterateAutoRefresh(_addListener$1, vars.autoRefreshEvents || "none"); 2716 _ignoreResize = (vars.autoRefreshEvents + "").indexOf("resize") === -1; 2717 } 2718 }; 2719 2720 ScrollTrigger.scrollerProxy = function scrollerProxy(target, vars) { 2721 var t = _getTarget(target), 2722 i = _scrollers.indexOf(t), 2723 isViewport = _isViewport$1(t); 2724 2725 if (~i) { 2726 _scrollers.splice(i, isViewport ? 6 : 2); 2727 } 2728 2729 if (vars) { 2730 isViewport ? _proxies.unshift(_win$1, vars, _body$1, vars, _docEl$1, vars) : _proxies.unshift(t, vars); 2731 } 2732 }; 2733 2734 ScrollTrigger.clearMatchMedia = function clearMatchMedia(query) { 2735 _triggers.forEach(function (t) { 2736 return t._ctx && t._ctx.query === query && t._ctx.kill(true, true); 2737 }); 2738 }; 2739 2740 ScrollTrigger.isInViewport = function isInViewport(element, ratio, horizontal) { 2741 var bounds = (_isString(element) ? _getTarget(element) : element).getBoundingClientRect(), 2742 offset = bounds[horizontal ? _width : _height] * ratio || 0; 2743 return horizontal ? bounds.right - offset > 0 && bounds.left + offset < _win$1.innerWidth : bounds.bottom - offset > 0 && bounds.top + offset < _win$1.innerHeight; 2744 }; 2745 2746 ScrollTrigger.positionInViewport = function positionInViewport(element, referencePoint, horizontal) { 2747 _isString(element) && (element = _getTarget(element)); 2748 var bounds = element.getBoundingClientRect(), 2749 size = bounds[horizontal ? _width : _height], 2750 offset = referencePoint == null ? size / 2 : referencePoint in _keywords ? _keywords[referencePoint] * size : ~referencePoint.indexOf("%") ? parseFloat(referencePoint) * size / 100 : parseFloat(referencePoint) || 0; 2751 return horizontal ? (bounds.left + offset) / _win$1.innerWidth : (bounds.top + offset) / _win$1.innerHeight; 2752 }; 2753 2754 ScrollTrigger.killAll = function killAll(allowListeners) { 2755 _triggers.slice(0).forEach(function (t) { 2756 return t.vars.id !== "ScrollSmoother" && t.kill(); 2757 }); 2758 2759 if (allowListeners !== true) { 2760 var listeners = _listeners.killAll || []; 2761 _listeners = {}; 2762 listeners.forEach(function (f) { 2763 return f(); 2764 }); 2765 } 2766 }; 2767 2768 return ScrollTrigger; 2769 }(); 2770 ScrollTrigger$1.version = "3.12.5"; 2771 2772 ScrollTrigger$1.saveStyles = function (targets) { 2773 return targets ? _toArray(targets).forEach(function (target) { 2774 if (target && target.style) { 2775 var i = _savedStyles.indexOf(target); 2776 2777 i >= 0 && _savedStyles.splice(i, 5); 2778 2779 _savedStyles.push(target, target.style.cssText, target.getBBox && target.getAttribute("transform"), gsap$1.core.getCache(target), _context$1()); 2780 } 2781 }) : _savedStyles; 2782 }; 2783 2784 ScrollTrigger$1.revert = function (soft, media) { 2785 return _revertAll(!soft, media); 2786 }; 2787 2788 ScrollTrigger$1.create = function (vars, animation) { 2789 return new ScrollTrigger$1(vars, animation); 2790 }; 2791 2792 ScrollTrigger$1.refresh = function (safe) { 2793 return safe ? _onResize(
vendor: 12,785 bytes, lines 2793-3167
2793) : (_coreInitted$1 || ScrollTrigger$1.register()) && _refreshAll(true); 2794 }; 2795 2796 ScrollTrigger$1.update = function (force) { 2797 return ++_scrollers.cache && _updateAll(force === true ? 2 : 0); 2798 }; 2799 2800 ScrollTrigger$1.clearScrollMemory = _clearScrollMemory; 2801 2802 ScrollTrigger$1.maxScroll = function (element, horizontal) { 2803 return _maxScroll(element, horizontal ? _horizontal : _vertical); 2804 }; 2805 2806 ScrollTrigger$1.getScrollFunc = function (element, horizontal) { 2807 return _getScrollFunc(_getTarget(element), horizontal ? _horizontal : _vertical); 2808 }; 2809 2810 ScrollTrigger$1.getById = function (id) { 2811 return _ids[id]; 2812 }; 2813 2814 ScrollTrigger$1.getAll = function () { 2815 return _triggers.filter(function (t) { 2816 return t.vars.id !== "ScrollSmoother"; 2817 }); 2818 }; 2819 2820 ScrollTrigger$1.isScrolling = function () { 2821 return !!_lastScrollTime; 2822 }; 2823 2824 ScrollTrigger$1.snapDirectional = _snapDirectional; 2825 2826 ScrollTrigger$1.addEventListener = function (type, callback) { 2827 var a = _listeners[type] || (_listeners[type] = []); 2828 ~a.indexOf(callback) || a.push(callback); 2829 }; 2830 2831 ScrollTrigger$1.removeEventListener = function (type, callback) { 2832 var a = _listeners[type], 2833 i = a && a.indexOf(callback); 2834 i >= 0 && a.splice(i, 1); 2835 }; 2836 2837 ScrollTrigger$1.batch = function (targets, vars) { 2838 var result = [], 2839 varsCopy = {}, 2840 interval = vars.interval || 0.016, 2841 batchMax = vars.batchMax || 1e9, 2842 proxyCallback = function proxyCallback(type, callback) { 2843 var elements = [], 2844 triggers = [], 2845 delay = gsap$1.delayedCall(interval, function () { 2846 callback(elements, triggers); 2847 elements = []; 2848 triggers = []; 2849 }).pause(); 2850 return function (self) { 2851 elements.length || delay.restart(true); 2852 elements.push(self.trigger); 2853 triggers.push(self); 2854 batchMax <= elements.length && delay.progress(1); 2855 }; 2856 }, 2857 p; 2858 2859 for (p in vars) { 2860 varsCopy[p] = p.substr(0, 2) === "on" && _isFunction(vars[p]) && p !== "onRefreshInit" ? proxyCallback(p, vars[p]) : vars[p]; 2861 } 2862 2863 if (_isFunction(batchMax)) { 2864 batchMax = batchMax(); 2865 2866 _addListener$1(ScrollTrigger$1, "refresh", function () { 2867 return batchMax = vars.batchMax(); 2868 }); 2869 } 2870 2871 _toArray(targets).forEach(function (target) { 2872 var config = {}; 2873 2874 for (p in varsCopy) { 2875 config[p] = varsCopy[p]; 2876 } 2877 2878 config.trigger = target; 2879 result.push(ScrollTrigger$1.create(config)); 2880 }); 2881 2882 return result; 2883 }; 2884 2885 var _clampScrollAndGetDurationMultiplier = function _clampScrollAndGetDurationMultiplier(scrollFunc, current, end, max) { 2886 current > max ? scrollFunc(max) : current < 0 && scrollFunc(0); 2887 return end > max ? (max - current) / (end - current) : end < 0 ? current / (current - end) : 1; 2888 }, 2889 _allowNativePanning = function _allowNativePanning(target, direction) { 2890 if (direction === true) { 2891 target.style.removeProperty("touch-action"); 2892 } else { 2893 target.style.touchAction = direction === true ? "auto" : direction ? "pan-" + direction + (Observer.isTouch ? " pinch-zoom" : "") : "none"; 2894 } 2895 2896 target === _docEl$1 && _allowNativePanning(_body$1, direction); 2897 }, 2898 _overflow = { 2899 auto: 1, 2900 scroll: 1 2901 }, 2902 _nestedScroll = function _nestedScroll(_ref5) { 2903 var event = _ref5.event, 2904 target = _ref5.target, 2905 axis = _ref5.axis; 2906 2907 var node = (event.changedTouches ? event.changedTouches[0] : event).target, 2908 cache = node._gsap || gsap$1.core.getCache(node), 2909 time = _getTime$1(), 2910 cs; 2911 2912 if (!cache._isScrollT || time - cache._isScrollT > 2000) { 2913 while (node && node !== _body$1 && (node.scrollHeight <= node.clientHeight && node.scrollWidth <= node.clientWidth || !(_overflow[(cs = _getComputedStyle(node)).overflowY] || _overflow[cs.overflowX]))) { 2914 node = node.parentNode; 2915 } 2916 2917 cache._isScroll = node && node !== target && !_isViewport$1(node) && (_overflow[(cs = _getComputedStyle(node)).overflowY] || _overflow[cs.overflowX]); 2918 cache._isScrollT = time; 2919 } 2920 2921 if (cache._isScroll || axis === "x") { 2922 event.stopPropagation(); 2923 event._gsapAllow = true; 2924 } 2925 }, 2926 _inputObserver = function _inputObserver(target, type, inputs, nested) { 2927 return Observer.create({ 2928 target: target, 2929 capture: true, 2930 debounce: false, 2931 lockAxis: true, 2932 type: type, 2933 onWheel: nested = nested && _nestedScroll, 2934 onPress: nested, 2935 onDrag: nested, 2936 onScroll: nested, 2937 onEnable: function onEnable() { 2938 return inputs && _addListener$1(_doc$1, Observer.eventTypes[0], _captureInputs, false, true); 2939 }, 2940 onDisable: function onDisable() { 2941 return _removeListener$1(_doc$1, Observer.eventTypes[0], _captureInputs, true); 2942 } 2943 }); 2944 }, 2945 _inputExp = /(input|label|select|textarea)/i, 2946 _inputIsFocused, 2947 _captureInputs = function _captureInputs(e) { 2948 var isInput = _inputExp.test(e.target.tagName); 2949 2950 if (isInput || _inputIsFocused) { 2951 e._gsapAllow = true; 2952 _inputIsFocused = isInput; 2953 } 2954 }, 2955 _getScrollNormalizer = function _getScrollNormalizer(vars) { 2956 _isObject(vars) || (vars = {}); 2957 vars.preventDefault = vars.isNormalizer = vars.allowClicks = true; 2958 vars.type || (vars.type = "wheel,touch"); 2959 vars.debounce = !!vars.debounce; 2960 vars.id = vars.id || "normalizer"; 2961 2962 var _vars2 = vars, 2963 normalizeScrollX = _vars2.normalizeScrollX, 2964 momentum = _vars2.momentum, 2965 allowNestedScroll = _vars2.allowNestedScroll, 2966 onRelease = _vars2.onRelease, 2967 self, 2968 maxY, 2969 target = _getTarget(vars.target) || _docEl$1, 2970 smoother = gsap$1.core.globals().ScrollSmoother, 2971 smootherInstance = smoother && smoother.get(), 2972 content = _fixIOSBug && (vars.content && _getTarget(vars.content) || smootherInstance && vars.content !== false && !smootherInstance.smooth() && smootherInstance.content()), 2973 scrollFuncY = _getScrollFunc(target, _vertical), 2974 scrollFuncX = _getScrollFunc(target, _horizontal), 2975 scale = 1, 2976 initialScale = (Observer.isTouch && _win$1.visualViewport ? _win$1.visualViewport.scale * _win$1.visualViewport.width : _win$1.outerWidth) / _win$1.innerWidth, 2977 wheelRefresh = 0, 2978 resolveMomentumDuration = _isFunction(momentum) ? function () { 2979 return momentum(self); 2980 } : function () { 2981 return momentum || 2.8; 2982 }, 2983 lastRefreshID, 2984 skipTouchMove, 2985 inputObserver = _inputObserver(target, vars.type, true, allowNestedScroll), 2986 resumeTouchMove = function resumeTouchMove() { 2987 return skipTouchMove = false; 2988 }, 2989 scrollClampX = _passThrough, 2990 scrollClampY = _passThrough, 2991 updateClamps = function updateClamps() { 2992 maxY = _maxScroll(target, _vertical); 2993 scrollClampY = _clamp$1(_fixIOSBug ? 1 : 0, maxY); 2994 normalizeScrollX && (scrollClampX = _clamp$1(0, _maxScroll(target, _horizontal))); 2995 lastRefreshID = _refreshID; 2996 }, 2997 removeContentOffset = function removeContentOffset() { 2998 content._gsap.y = _round(parseFloat(content._gsap.y) + scrollFuncY.offset) + "px"; 2999 content.style.transform = "matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, " + parseFloat(content._gsap.y) + ", 0, 1)"; 3000 scrollFuncY.offset = scrollFuncY.cacheID = 0; 3001 }, 3002 ignoreDrag = function ignoreDrag() { 3003 if (skipTouchMove) { 3004 requestAnimationFrame(resumeTouchMove); 3005 3006 var offset = _round(self.deltaY / 2), 3007 scroll = scrollClampY(scrollFuncY.v - offset); 3008 3009 if (content && scroll !== scrollFuncY.v + scrollFuncY.offset) { 3010 scrollFuncY.offset = scroll - scrollFuncY.v; 3011 3012 var y = _round((parseFloat(content && content._gsap.y) || 0) - scrollFuncY.offset); 3013 3014 content.style.transform = "matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, " + y + ", 0, 1)"; 3015 content._gsap.y = y + "px"; 3016 scrollFuncY.cacheID = _scrollers.cache; 3017 3018 _updateAll(); 3019 } 3020 3021 return true; 3022 } 3023 3024 scrollFuncY.offset && removeContentOffset(); 3025 skipTouchMove = true; 3026 }, 3027 tween, 3028 startScrollX, 3029 startScrollY, 3030 onStopDelayedCall, 3031 onResize = function onResize() { 3032 updateClamps(); 3033 3034 if (tween.isActive() && tween.vars.scrollY > maxY) { 3035 scrollFuncY() > maxY ? tween.progress(1) && scrollFuncY(maxY) : tween.resetTo("scrollY", maxY); 3036 } 3037 }; 3038 3039 content && gsap$1.set(content, { 3040 y: "+=0" 3041 }); 3042 3043 vars.ignoreCheck = function (e) { 3044 return _fixIOSBug && e.type === "touchmove" && ignoreDrag() || scale > 1.05 && e.type !== "touchstart" || self.isGesturing || e.touches && e.touches.length > 1; 3045 }; 3046 3047 vars.onPress = function () { 3048 skipTouchMove = false; 3049 var prevScale = scale; 3050 scale = _round((_win$1.visualViewport && _win$1.visualViewport.scale || 1) / initialScale); 3051 tween.pause(); 3052 prevScale !== scale && _allowNativePanning(target, scale > 1.01 ? true : normalizeScrollX ? false : "x"); 3053 startScrollX = scrollFuncX(); 3054 startScrollY = scrollFuncY(); 3055 updateClamps(); 3056 lastRefreshID = _refreshID; 3057 }; 3058 3059 vars.onRelease = vars.onGestureStart = function (self, wasDragging) { 3060 scrollFuncY.offset && removeContentOffset(); 3061 3062 if (!wasDragging) { 3063 onStopDelayedCall.restart(true); 3064 } else { 3065 _scrollers.cache++; 3066 var dur = resolveMomentumDuration(), 3067 currentScroll, 3068 endScroll; 3069 3070 if (normalizeScrollX) { 3071 currentScroll = scrollFuncX(); 3072 endScroll = currentScroll + dur * 0.05 * -self.velocityX / 0.227; 3073 dur *= _clampScrollAndGetDurationMultiplier(scrollFuncX, currentScroll, endScroll, _maxScroll(target, _horizontal)); 3074 tween.vars.scrollX = scrollClampX(endScroll); 3075 } 3076 3077 currentScroll = scrollFuncY(); 3078 endScroll = currentScroll + dur * 0.05 * -self.velocityY / 0.227; 3079 dur *= _clampScrollAndGetDurationMultiplier(scrollFuncY, currentScroll, endScroll, _maxScroll(target, _vertical)); 3080 tween.vars.scrollY = scrollClampY(endScroll); 3081 tween.invalidate().duration(dur).play(0.01); 3082 3083 if (_fixIOSBug && tween.vars.scrollY >= maxY || currentScroll >= maxY - 1) { 3084 gsap$1.to({}, { 3085 onUpdate: onResize, 3086 duration: dur 3087 }); 3088 } 3089 } 3090 3091 onRelease && onRelease(self); 3092 }; 3093 3094 vars.onWheel = function () { 3095 tween._ts && tween.pause(); 3096 3097 if (_getTime$1() - wheelRefresh > 1000) { 3098 lastRefreshID = 0; 3099 wheelRefresh = _getTime$1(); 3100 } 3101 }; 3102 3103 vars.onChange = function (self, dx, dy, xArray, yArray) { 3104 _refreshID !== lastRefreshID && updateClamps(); 3105 dx && normalizeScrollX && scrollFuncX(scrollClampX(xArray[2] === dx ? startScrollX + (self.startX - self.x) : scrollFuncX() + dx - xArray[1])); 3106 3107 if (dy) { 3108 scrollFuncY.offset && removeContentOffset(); 3109 var isTouch = yArray[2] === dy, 3110 y = isTouch ? startScrollY + self.startY - self.y : scrollFuncY() + dy - yArray[1], 3111 yClamped = scrollClampY(y); 3112 isTouch && y !== yClamped && (startScrollY += yClamped - y); 3113 scrollFuncY(yClamped); 3114 } 3115 3116 (dy || dx) && _updateAll(); 3117 }; 3118 3119 vars.onEnable = function () { 3120 _allowNativePanning(target, normalizeScrollX ? false : "x"); 3121 3122 ScrollTrigger$1.addEventListener("refresh", onResize); 3123 3124 _addListener$1(_win$1, "resize", onResize); 3125 3126 if (scrollFuncY.smooth) { 3127 scrollFuncY.target.style.scrollBehavior = "auto"; 3128 scrollFuncY.smooth = scrollFuncX.smooth = false; 3129 } 3130 3131 inputObserver.enable(); 3132 }; 3133 3134 vars.onDisable = function () { 3135 _allowNativePanning(target, true); 3136 3137 _removeListener$1(_win$1, "resize", onResize); 3138 3139 ScrollTrigger$1.removeEventListener("refresh", onResize); 3140 inputObserver.kill(); 3141 }; 3142 3143 vars.lockAxis = vars.lockAxis !== false; 3144 self = new Observer(vars); 3145 self.iOS = _fixIOSBug; 3146 _fixIOSBug && !scrollFuncY() && scrollFuncY(1); 3147 _fixIOSBug && gsap$1.ticker.add(_passThrough); 3148 onStopDelayedCall = self._dc; 3149 tween = gsap$1.to(self, { 3150 ease: "power4", 3151 paused: true, 3152 inherit: false, 3153 scrollX: normalizeScrollX ? "+=0.1" : "+=0", 3154 scrollY: "+=0.1", 3155 modifiers: { 3156 scrollY: _interruptionTracker(scrollFuncY, scrollFuncY(), function () { 3157 return tween.pause(); 3158 }) 3159 }, 3160 onUpdate: _updateAll, 3161 onComplete: onStopDelayedCall.vars.onComplete 3162 }); 3163 return self; 3164 }; 3165 3166 ScrollTrigger$1.sort = function (func) { 3167
vendor: 1,536 bytes, lines 3167-3219
3167return _triggers.sort(func || function (a, b) { 3168 return (a.vars.refreshPriority || 0) * -1e6 + a.start - (b.start + (b.vars.refreshPriority || 0) * -1e6); 3169 }); 3170 }; 3171 3172 ScrollTrigger$1.observe = function (vars) { 3173 return new Observer(vars); 3174 }; 3175 3176 ScrollTrigger$1.normalizeScroll = function (vars) { 3177 if (typeof vars === "undefined") { 3178 return _normalizer$1; 3179 } 3180 3181 if (vars === true && _normalizer$1) { 3182 return _normalizer$1.enable(); 3183 } 3184 3185 if (vars === false) { 3186 _normalizer$1 && _normalizer$1.kill(); 3187 _normalizer$1 = vars; 3188 return; 3189 } 3190 3191 var normalizer = vars instanceof Observer ? vars : _getScrollNormalizer(vars); 3192 _normalizer$1 && _normalizer$1.target === normalizer.target && _normalizer$1.kill(); 3193 _isViewport$1(normalizer.target) && (_normalizer$1 = normalizer); 3194 return normalizer; 3195 }; 3196 3197 ScrollTrigger$1.core = { 3198 _getVelocityProp: _getVelocityProp, 3199 _inputObserver: _inputObserver, 3200 _scrollers: _scrollers, 3201 _proxies: _proxies, 3202 bridge: { 3203 ss: function ss() { 3204 _lastScrollTime || _dispatch("scrollStart"); 3205 _lastScrollTime = _getTime$1(); 3206 }, 3207 ref: function ref() { 3208 return _refreshing; 3209 } 3210 } 3211 }; 3212 _getGSAP$1() && gsap$1.registerPlugin(ScrollTrigger$1); 3213 3214 exports.ScrollTrigger = ScrollTrigger$1; 3215 exports.default = ScrollTrigger$1; 3216 3217 if (typeof(window) === 'undefined' || window !== exports) {Object.defineProperty(exports, '__esModule', { value: true });} else {delete window.default;} 3218 3219})));
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.