sticky-scroll-trigger 0.13.0 → 0.14.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,6 +1,6 @@
1
1
  /*!
2
2
  * @license
3
- * StickyScrollTrigger v0.13.0
3
+ * StickyScrollTrigger v0.14.0
4
4
  * Copyright (c) 2026 Kuninori Ogino
5
5
  * Released under the MIT License
6
6
  * https://github.com/kuninori-ogino/sticky-scroll-trigger
@@ -87,10 +87,6 @@ var StickyScrollTrigger = (function() {
87
87
  el.style.position = "";
88
88
  el.style.top = "";
89
89
  };
90
- const applyStickyPosition = (el, topPx) => {
91
- el.style.position = "sticky";
92
- el.style.top = `${topPx}px`;
93
- };
94
90
  const captureInlinePosition = (el) => ({
95
91
  position: el.style.position,
96
92
  top: el.style.top
@@ -104,6 +100,15 @@ var StickyScrollTrigger = (function() {
104
100
  elements.forEach(resetStickyPosition);
105
101
  return () => elements.forEach((el, i) => restoreInlinePosition(el, saved[i]));
106
102
  };
103
+ const insertSpacers = (spacers) => {
104
+ const inserted = spacers.map(({ after, height }) => {
105
+ const spacer = document.createElement("div");
106
+ spacer.style.cssText = `height:${height}px;margin:0;padding:0;border:0`;
107
+ after.after(spacer);
108
+ return spacer;
109
+ });
110
+ return () => inserted.forEach((spacer) => spacer.remove());
111
+ };
107
112
  const wrapScene = (inner, holdTrailingMargin) => {
108
113
  if (!inner.parentNode) throw new Error(`StickyScrollTrigger: ${describeElement(inner)} is not attached to the document`);
109
114
  const container = document.createElement("div");
@@ -206,6 +211,41 @@ var StickyScrollTrigger = (function() {
206
211
  lifted.length = 0;
207
212
  };
208
213
  };
214
+ const classOf = (self) => self.constructor;
215
+ const isRefreshing = (cls) => cls?.isRefreshing === true;
216
+ const isScrolling = (cls) => Boolean(cls?.isScrolling?.());
217
+ const isScrollingOrUpdating = (cls) => Boolean(cls?.isScrolling?.() || cls?.isUpdating === true);
218
+ const addGsapListener = (cls, type, callback) => {
219
+ cls?.addEventListener?.(type, callback);
220
+ };
221
+ const removeGsapListener = (cls, type, callback) => {
222
+ cls?.removeEventListener?.(type, callback);
223
+ };
224
+ const refreshAll = (cls) => {
225
+ if (typeof cls?.refresh === "function") cls.refresh();
226
+ };
227
+ const scrollRecord = (cls, zero = false) => {
228
+ if (!cls || !isRefreshing(cls)) return null;
229
+ const scrollFunc = cls.getScrollFunc?.(window);
230
+ if (!(scrollFunc && typeof scrollFunc.rec === "number" && (zero || scrollFunc.rec))) return null;
231
+ const record = scrollFunc;
232
+ return {
233
+ read: () => record.rec,
234
+ write: (value) => {
235
+ record.rec = value;
236
+ }
237
+ };
238
+ };
239
+ const syncScrollCache = (cls) => {
240
+ const scrollFunc = cls?.getScrollFunc?.(window);
241
+ if (typeof scrollFunc !== "function") return;
242
+ const cached = scrollFunc();
243
+ if (typeof cached !== "number" || Math.abs(cached - window.scrollY) >= .5) scrollFunc(window.scrollY);
244
+ };
245
+ const revertAfterMeasure = (restore, result) => ({ render: (time) => {
246
+ result?.render?.(time);
247
+ restore();
248
+ } });
209
249
  const AUTO_MIN_DEPTH = 7;
210
250
  const MAX_CHAIN_IN_BAND = 4;
211
251
  const BUFFER_FLOOR_PX = 325;
@@ -281,7 +321,7 @@ var StickyScrollTrigger = (function() {
281
321
  let adoptedMidRefresh = false;
282
322
  let scannedThisTask = null;
283
323
  const gsapClasses = new Set();
284
- const gsapRefreshing = () => Array.from(gsapClasses).some((cls) => cls.isRefreshing === true);
324
+ const gsapRefreshing = () => Array.from(gsapClasses).some((cls) => isRefreshing(cls));
285
325
  const stateAt = (record, scroll) => {
286
326
  if (!record.demotable) return "in";
287
327
  if (scroll < record.lo - buffer) return "before";
@@ -359,22 +399,22 @@ var StickyScrollTrigger = (function() {
359
399
  queueMicrotask(onGsapRefreshDone);
360
400
  if (records.length) update(0);
361
401
  }
362
- return { render: restoreAfterGsapMeasure };
402
+ return revertAfterMeasure(restoreAfterGsapMeasure);
363
403
  };
364
404
  const adoptGsapClass = (cls) => {
365
405
  if (gsapClasses.has(cls)) return;
366
- if (cls.isRefreshing === true) adoptedMidRefresh = true;
406
+ if (isRefreshing(cls)) adoptedMidRefresh = true;
367
407
  gsapClasses.add(cls);
368
- cls.addEventListener?.("refresh", onGsapRefreshDone);
369
- cls.addEventListener?.("refreshInit", onGsapRefreshInit);
408
+ addGsapListener(cls, "refresh", onGsapRefreshDone);
409
+ addGsapListener(cls, "refreshInit", onGsapRefreshInit);
370
410
  };
371
411
  const dropGsapClassesLater = () => {
372
412
  if (!gsapClasses.size) return;
373
413
  queueMicrotask(() => {
374
414
  if (liveClients().length) return;
375
415
  gsapClasses.forEach((cls) => {
376
- cls.removeEventListener?.("refresh", onGsapRefreshDone);
377
- cls.removeEventListener?.("refreshInit", onGsapRefreshInit);
416
+ removeGsapListener(cls, "refresh", onGsapRefreshDone);
417
+ removeGsapListener(cls, "refreshInit", onGsapRefreshInit);
378
418
  });
379
419
  gsapClasses.clear();
380
420
  });
@@ -607,7 +647,14 @@ var StickyScrollTrigger = (function() {
607
647
  update(gsapPhase === "measuring" ? 0 : (gsapPhase === "restored" ? scrollBeforeGsapRefresh : null) ?? scroll);
608
648
  listen(true);
609
649
  };
610
- const takeGsapRefreshRestore = () => adoptedMidRefresh && gsapRefreshing() ? onGsapRefreshInit().render : null;
650
+ const takeGsapRefreshRestore = () => {
651
+ if (!adoptedMidRefresh || !gsapRefreshing()) return null;
652
+ onGsapRefreshInit();
653
+ return restoreAfterGsapMeasure;
654
+ };
655
+ const setGsapRefreshReturn = (scroll) => {
656
+ if (gsapPhase !== "idle") scrollBeforeGsapRefresh = scroll;
657
+ };
611
658
  const clearDormancy = clearTable;
612
659
  const releaseDormant = (elements) => {
613
660
  const released = new Set(elements);
@@ -638,6 +685,24 @@ var StickyScrollTrigger = (function() {
638
685
  if (liveClients().length) queueRebuild();
639
686
  else teardown();
640
687
  };
688
+ const commitSticky = (el, topPx) => {
689
+ el.style.position = "sticky";
690
+ el.style.top = `${topPx}px`;
691
+ };
692
+ const commitPosition = (el, saved) => {
693
+ el.style.position = saved.position;
694
+ el.style.top = saved.top;
695
+ };
696
+ const commitHeight = (el, height) => {
697
+ el.style.height = height;
698
+ };
699
+ const clearStickyForRead = (el) => {
700
+ el.style.position = "";
701
+ el.style.top = "";
702
+ };
703
+ const clearHeightForRead = (el) => {
704
+ el.style.height = "";
705
+ };
641
706
  const resolveMaybeFn = (value) => typeof value === "function" ? value() : value;
642
707
  const KEYWORD_FRACTIONS = {
643
708
  top: 0,
@@ -1302,6 +1367,7 @@ var StickyScrollTrigger = (function() {
1302
1367
  stopRamps();
1303
1368
  };
1304
1369
  return {
1370
+ targets: () => targetSelector === null ? [] : Array.from(rootElement.querySelectorAll(targetSelector)),
1305
1371
  sync(scenes, host, measureNaturalTops) {
1306
1372
  const ramps = scenes.filter((scene) => scene.freezeEnd > scene.freezeStart).sort((a, b) => a.freezeStart - b.freezeStart);
1307
1373
  if (targetSelector === null || !ramps.length || !host) {
@@ -1445,6 +1511,8 @@ var StickyScrollTrigger = (function() {
1445
1511
  const end = resolveEndSpec(rootElement, viewportHeight, layer, endResolved, ownIndex, endTriggerIndex);
1446
1512
  const endTriggerInContainer = end.mode === "clause" && !end.measureLive && !endTriggerIsSelf;
1447
1513
  const start = resolveStartSpec(layer, startResolved, elementHeight, viewportHeight);
1514
+ const { end: endInput } = layer;
1515
+ const liveEnd = layer.kind === "scene" && typeof endInput === "function" && (end.mode === "dwell" || end.mode === "absolute") ? () => resolveEndSpec(rootElement, viewportHeight, layer, prefixSpacedRelativeEnd(startResolved, endInput()), ownIndex, endTriggerIndex) : void 0;
1448
1516
  return {
1449
1517
  kind: layer.kind,
1450
1518
  start,
@@ -1460,7 +1528,8 @@ var StickyScrollTrigger = (function() {
1460
1528
  height: end.mode === "clause" ? measureUsedHeight(layer.endTrigger) : 0,
1461
1529
  enclosedBy: endTriggerInContainer ? indicesWhere((trigger) => trigger.contains(layer.endTrigger)) : [],
1462
1530
  nests: endTriggerInContainer ? indicesWhere((other) => other !== layer.endTrigger && layer.endTrigger.contains(other)) : []
1463
- }
1531
+ },
1532
+ liveEnd
1464
1533
  };
1465
1534
  };
1466
1535
  const EXCLUDED_VAR_KEYS = [
@@ -1497,10 +1566,55 @@ var StickyScrollTrigger = (function() {
1497
1566
  const index = list.indexOf(item);
1498
1567
  if (index !== -1) list.splice(index, 1);
1499
1568
  };
1569
+ const suspendLiveEvaluations = (evaluation, resolving) => {
1570
+ const resumes = [];
1571
+ for (let current = evaluation; current; current = current.outer) resumes.unshift(current.suspend(resolving && current === evaluation));
1572
+ return () => resumes.forEach((resume) => resume());
1573
+ };
1574
+ const liveEndValue = (spec) => {
1575
+ if (spec.mode === "dwell") return spec.distancePx;
1576
+ return spec.mode === "absolute" ? spec.value : 0;
1577
+ };
1578
+ const LIVE_END_ROUNDS = 6;
1579
+ const LIVE_END_TOLERANCE_PX = .5;
1500
1580
  const hasDuplicateTrigger = (list, trigger) => list.some((existing) => existing.trigger === trigger);
1501
1581
  const pendingDisarms = new Set();
1502
1582
  const pendingKeeps = new Set();
1583
+ const pendingCatchUps = new Map();
1503
1584
  let unbuildCount = 0;
1585
+ let refreshedInGsapRefresh = null;
1586
+ const armedInstances = new Set();
1587
+ let liveEvaluation = null;
1588
+ let layerHandlerDepth = 0;
1589
+ const scrollBackTo = (top) => {
1590
+ if (Math.abs(window.scrollY - top) >= .5) window.scrollTo({
1591
+ top,
1592
+ behavior: "instant"
1593
+ });
1594
+ };
1595
+ const holdLiveEvaluationForGsapRefresh = (cls) => {
1596
+ const evaluation = liveEvaluation;
1597
+ if (!evaluation) return;
1598
+ const resume = suspendLiveEvaluations(evaluation, false);
1599
+ const record = scrollRecord(cls, true);
1600
+ if (record && Math.abs(record.read() - evaluation.scroll) >= .5) {
1601
+ scrollBackTo(Math.round(evaluation.scroll));
1602
+ syncScrollCache(cls);
1603
+ record.write(window.scrollY);
1604
+ setGsapRefreshReturn(window.scrollY);
1605
+ }
1606
+ const depth = layerHandlerDepth - 1;
1607
+ let held = true;
1608
+ liveEvaluation = null;
1609
+ const onRefresh = () => {
1610
+ if (!held || layerHandlerDepth > depth) return;
1611
+ held = false;
1612
+ resume();
1613
+ if (!evaluation.ended) liveEvaluation = evaluation;
1614
+ };
1615
+ addGsapListener(cls, "refresh", onRefresh);
1616
+ queueMicrotask(() => removeGsapListener(cls, "refresh", onRefresh));
1617
+ };
1504
1618
  const REST_POLL_MS = 100;
1505
1619
  const runEach = (...steps) => {
1506
1620
  let failure = null;
@@ -1526,7 +1640,9 @@ var StickyScrollTrigger = (function() {
1526
1640
  #dirty = false;
1527
1641
  #outermostContainer = null;
1528
1642
  #destroyed = false;
1529
- #rebuildScheduled = false;
1643
+ #depth = 0;
1644
+ #refreshInitNestedUsed = false;
1645
+ #measureAgain = false;
1530
1646
  #keepContentPending = false;
1531
1647
  #deferredRun = null;
1532
1648
  #restTimer = null;
@@ -1537,6 +1653,7 @@ var StickyScrollTrigger = (function() {
1537
1653
  #scrollMarginTargets;
1538
1654
  #armed = false;
1539
1655
  #dispatchObserver = null;
1656
+ #readsPageHeight = false;
1540
1657
  #dormancyClient = null;
1541
1658
  constructor(root, options = {}) {
1542
1659
  this.#rootElement = resolveRoot(root);
@@ -1562,6 +1679,7 @@ var StickyScrollTrigger = (function() {
1562
1679
  if (pendingDisarms.delete(this)) this.#keepContentPending = false;
1563
1680
  if (this.#armed) return;
1564
1681
  this.#armed = true;
1682
+ armedInstances.add(this);
1565
1683
  pendingKeeps.forEach((keep) => {
1566
1684
  if (keep.owner.#overlaps(this)) keep.cancelled = true;
1567
1685
  });
@@ -1571,7 +1689,8 @@ var StickyScrollTrigger = (function() {
1571
1689
  #disarmIfEmpty() {
1572
1690
  if (this.#armed && !this.#destroyed && !this.#layers.length && !this.#pinLayers.length) {
1573
1691
  if (pendingDisarms.has(this)) return;
1574
- if (!this.#scrollTriggerClass?.isRefreshing && this.#scrolling()) {
1692
+ const cls = this.#scrollTriggerClass;
1693
+ if (!isRefreshing(cls) && isScrollingOrUpdating(cls)) {
1575
1694
  pendingDisarms.add(this);
1576
1695
  queueMicrotask(() => this.#settleWhenAtRest());
1577
1696
  return;
@@ -1585,16 +1704,12 @@ var StickyScrollTrigger = (function() {
1585
1704
  if (other !== this && other.#overlaps(this)) other.#flushPendingDisarmForRevert();
1586
1705
  });
1587
1706
  }
1588
- #scrolling() {
1589
- const cls = this.#scrollTriggerClass;
1590
- return Boolean(cls?.isScrolling?.() || cls?.isUpdating === true);
1591
- }
1592
1707
  #disarmKeepingContent(keepContent, onlyAtRest = false) {
1593
1708
  const position = keepContent && this.#built ? this.#naturalScrollTop(this.#builtLayers) : null;
1594
1709
  this.#keepContentPending = false;
1595
1710
  this.#disarm();
1596
1711
  if (!position) return;
1597
- if (this.#gsapScrollRecord()) {
1712
+ if (scrollRecord(this.#scrollTriggerClass)) {
1598
1713
  this.#keepContent(position);
1599
1714
  return;
1600
1715
  }
@@ -1614,7 +1729,7 @@ var StickyScrollTrigger = (function() {
1614
1729
  if (!keep) return;
1615
1730
  this.#pendingKeep = null;
1616
1731
  pendingKeeps.delete(keep);
1617
- if (keep.cancelled || keep.onlyAtRest && keep.cls?.isScrolling?.()) return;
1732
+ if (keep.cancelled || keep.onlyAtRest && isScrolling(keep.cls)) return;
1618
1733
  this.#keepContent(keep.position, keep.cls);
1619
1734
  }
1620
1735
  #overlaps(other) {
@@ -1622,7 +1737,7 @@ var StickyScrollTrigger = (function() {
1622
1737
  }
1623
1738
  #settleWhenAtRest() {
1624
1739
  if (this.#destroyed || this.#restTimer !== null) return;
1625
- if (this.#scrollTriggerClass?.isScrolling?.()) {
1740
+ if (isScrolling(this.#scrollTriggerClass)) {
1626
1741
  this.#restTimer = setTimeout(() => {
1627
1742
  this.#restTimer = null;
1628
1743
  this.#settleWhenAtRest();
@@ -1637,10 +1752,11 @@ var StickyScrollTrigger = (function() {
1637
1752
  if (pendingDisarms.delete(this) && !this.#destroyed && !this.#layers.length && !this.#pinLayers.length) this.#disarmKeepingContent(keepContent, onlyAtRest);
1638
1753
  }
1639
1754
  #flushPendingDisarmForRevert() {
1640
- this.#flushPendingDisarm(!this.#scrollTriggerClass?.isScrolling?.(), true);
1755
+ this.#flushPendingDisarm(!isScrolling(this.#scrollTriggerClass), true);
1641
1756
  }
1642
1757
  #disarm() {
1643
1758
  this.#armed = false;
1759
+ armedInstances.delete(this);
1644
1760
  unregisterDormancyClient(this.#dormancyClient);
1645
1761
  this.#scrollMarginSync?.restore();
1646
1762
  this.#scrollMarginSync = null;
@@ -1670,40 +1786,45 @@ var StickyScrollTrigger = (function() {
1670
1786
  }
1671
1787
  #catchUp() {
1672
1788
  this.#flushPendingDisarm();
1673
- this.refresh();
1789
+ this.#runRefresh();
1674
1790
  this.#applyPendingKeep();
1675
1791
  }
1676
1792
  #scheduleRebuild() {
1677
1793
  if (this.#destroyed) return;
1678
1794
  if (this.#built) this.#keepContentPending = true;
1679
- if (this.#rebuildScheduled) return;
1680
- this.#rebuildScheduled = true;
1795
+ if (pendingCatchUps.has(this)) return;
1681
1796
  const cls = this.#scrollTriggerClass;
1682
- const onRefreshInit = () => {
1683
- if (!this.#rebuildScheduled || this.#destroyed) return void 0;
1797
+ const pending = () => pendingCatchUps.get(this) === catchUpNow;
1798
+ const catchUpNow = () => {
1799
+ if (!pending()) return false;
1800
+ pendingCatchUps.delete(this);
1801
+ if (this.#destroyed) return false;
1684
1802
  try {
1685
1803
  this.#catchUp();
1686
1804
  } catch (error) {
1687
1805
  queueMicrotask(() => {
1688
1806
  throw error;
1689
1807
  });
1690
- } finally {
1691
- this.#rebuildScheduled = false;
1692
1808
  }
1809
+ return true;
1810
+ };
1811
+ pendingCatchUps.set(this, catchUpNow);
1812
+ const onRefreshInit = () => {
1813
+ if (!catchUpNow()) return void 0;
1693
1814
  const restoreDormancy = takeGsapRefreshRestore();
1694
- return restoreDormancy ? { render: () => restoreDormancy() } : void 0;
1815
+ return restoreDormancy ? revertAfterMeasure(restoreDormancy) : void 0;
1695
1816
  };
1696
- cls?.addEventListener?.("refreshInit", onRefreshInit);
1817
+ addGsapListener(cls, "refreshInit", onRefreshInit);
1697
1818
  const run = () => {
1698
- cls?.removeEventListener?.("refreshInit", onRefreshInit);
1699
- if (!this.#rebuildScheduled) return;
1700
- this.#rebuildScheduled = false;
1701
- if (this.#destroyed) return;
1702
- this.#catchUp();
1703
- if (typeof this.#scrollTriggerClass?.refresh === "function") this.#scrollTriggerClass.refresh();
1819
+ try {
1820
+ if (pending() && !this.#destroyed) refreshAll(this.#scrollTriggerClass);
1821
+ } finally {
1822
+ removeGsapListener(cls, "refreshInit", onRefreshInit);
1823
+ catchUpNow();
1824
+ }
1704
1825
  };
1705
1826
  queueMicrotask(() => {
1706
- if (this.#rebuildScheduled && !this.#destroyed && cls?.isScrolling?.()) {
1827
+ if (pending() && !this.#destroyed && isScrolling(cls)) {
1707
1828
  const earlier = this.#deferredRun;
1708
1829
  this.#deferredRun = earlier ? () => runEach(earlier, run) : run;
1709
1830
  this.#settleWhenAtRest();
@@ -1714,28 +1835,46 @@ var StickyScrollTrigger = (function() {
1714
1835
  }
1715
1836
  #captureScrollTriggerClass(self) {
1716
1837
  if (this.#destroyed) return;
1717
- this.#scrollTriggerClass = self.constructor;
1838
+ this.#scrollTriggerClass = classOf(self);
1718
1839
  }
1719
1840
  #createAutoRefreshHandler(userOnRefreshInit) {
1720
- return (self) => {
1841
+ const handle = (self) => {
1721
1842
  this.#captureScrollTriggerClass(self);
1843
+ if (isRefreshing(this.#scrollTriggerClass)) holdLiveEvaluationForGsapRefresh(this.#scrollTriggerClass);
1722
1844
  const result = userOnRefreshInit?.(self);
1723
- const inGsapRefresh = this.#scrollTriggerClass?.isRefreshing === true;
1724
- const unchanged = inGsapRefresh && !userOnRefreshInit && this.#dispatchObserver !== null && this.#dispatchObserver.takeRecords().length === 0;
1845
+ const inGsapRefresh = isRefreshing(this.#scrollTriggerClass);
1846
+ let caughtUp = false;
1847
+ let refreshed = false;
1848
+ if (inGsapRefresh) {
1849
+ [...pendingCatchUps].forEach(([owner, catchUpNow]) => owner !== this && catchUpNow());
1850
+ caughtUp = pendingCatchUps.get(this)?.() === true;
1851
+ if (caughtUp) this.#dispatchObserver?.takeRecords();
1852
+ }
1853
+ const unchanged = inGsapRefresh && !userOnRefreshInit && !this.#dirty && (caughtUp || this.#dispatchObserver !== null && this.#dispatchObserver.takeRecords().length === 0);
1725
1854
  try {
1726
- if (!unchanged) this.refresh();
1855
+ if (!unchanged) {
1856
+ refreshed = true;
1857
+ this.#refreshFrom(true);
1858
+ }
1727
1859
  } catch (error) {
1728
1860
  queueMicrotask(() => {
1729
1861
  throw error;
1730
1862
  });
1731
1863
  }
1732
- if (inGsapRefresh) this.#watchGsapRefresh();
1864
+ if (inGsapRefresh) {
1865
+ this.#watchGsapRefresh();
1866
+ if (refreshed || caughtUp) this.#remeasureEarlierInGsapRefresh();
1867
+ }
1733
1868
  const restoreDormancy = takeGsapRefreshRestore();
1734
- if (!restoreDormancy) return result;
1735
- return { render: (time) => {
1736
- result?.render?.(time);
1737
- restoreDormancy();
1738
- } };
1869
+ return restoreDormancy ? revertAfterMeasure(restoreDormancy, result) : result;
1870
+ };
1871
+ return (self) => {
1872
+ layerHandlerDepth += 1;
1873
+ try {
1874
+ return handle(self);
1875
+ } finally {
1876
+ layerHandlerDepth -= 1;
1877
+ }
1739
1878
  };
1740
1879
  }
1741
1880
  #watchGsapRefresh() {
@@ -1748,7 +1887,7 @@ var StickyScrollTrigger = (function() {
1748
1887
  const end = () => {
1749
1888
  observer.disconnect();
1750
1889
  if (this.#dispatchObserver === observer) this.#dispatchObserver = null;
1751
- queueMicrotask(() => cls?.removeEventListener?.("refresh", end));
1890
+ queueMicrotask(() => removeGsapListener(cls, "refresh", end));
1752
1891
  };
1753
1892
  observer.observe(document, {
1754
1893
  subtree: true,
@@ -1757,9 +1896,39 @@ var StickyScrollTrigger = (function() {
1757
1896
  characterData: true
1758
1897
  });
1759
1898
  this.#dispatchObserver = observer;
1760
- cls?.addEventListener?.("refresh", end);
1899
+ addGsapListener(cls, "refresh", end);
1761
1900
  queueMicrotask(end);
1762
1901
  }
1902
+ #remeasureEarlierInGsapRefresh() {
1903
+ const refreshed = refreshedInGsapRefresh ?? new Map();
1904
+ if (!refreshedInGsapRefresh) {
1905
+ refreshedInGsapRefresh = refreshed;
1906
+ queueMicrotask(() => {
1907
+ if (refreshedInGsapRefresh === refreshed) refreshedInGsapRefresh = null;
1908
+ });
1909
+ }
1910
+ refreshed.set(this, this.#outsideReads());
1911
+ refreshed.forEach((reads, other) => {
1912
+ if (other.#destroyed || reads === other.#outsideReads()) return;
1913
+ try {
1914
+ other.#refreshFrom(true);
1915
+ } catch (error) {
1916
+ queueMicrotask(() => {
1917
+ throw error;
1918
+ });
1919
+ }
1920
+ other.#dispatchObserver?.takeRecords();
1921
+ refreshed.set(other, other.#outsideReads());
1922
+ });
1923
+ }
1924
+ #outsideReads() {
1925
+ const reads = [documentTop(this.#rootElement)];
1926
+ if (this.#readsPageHeight) reads.push(measureDocumentHeightWithoutPinRanges());
1927
+ [...this.#layers, ...this.#pinLayers].forEach(({ endTrigger }) => {
1928
+ if (!this.#rootElement.contains(endTrigger)) reads.push(documentTop(endTrigger));
1929
+ });
1930
+ return reads.join(",");
1931
+ }
1763
1932
  #wrapUnwrappedPins() {
1764
1933
  this.#pinLayers.forEach((layer) => {
1765
1934
  if (layer.outer) return;
@@ -1776,16 +1945,14 @@ var StickyScrollTrigger = (function() {
1776
1945
  range: inner.style.height
1777
1946
  }] : []);
1778
1947
  wrapped.forEach(({ outer, inner }) => {
1779
- outer.style.height = "";
1780
- inner.style.height = "";
1948
+ clearHeightForRead(outer);
1949
+ clearHeightForRead(inner);
1781
1950
  });
1782
1951
  const reserved = wrapped.map(({ outer }) => measureUsedHeight(outer));
1783
1952
  wrapped.forEach(({ outer }, index) => {
1784
- outer.style.height = `${reserved[index]}px`;
1785
- });
1786
- wrapped.forEach(({ inner, range }) => {
1787
- inner.style.height = range;
1953
+ commitHeight(outer, `${reserved[index]}px`);
1788
1954
  });
1955
+ wrapped.forEach(({ inner, range }) => commitHeight(inner, range));
1789
1956
  }
1790
1957
  #unwrapPinLayer(layer) {
1791
1958
  if (!layer.outer) return false;
@@ -1799,7 +1966,13 @@ var StickyScrollTrigger = (function() {
1799
1966
  return stripStickyPositions(this.#builtLayers.flatMap(({ wrapper }) => wrapper ? [wrapper] : []));
1800
1967
  }
1801
1968
  #resetPinStickyState() {
1802
- return stripStickyPositions(this.#wrappedPinTriggers());
1969
+ const restores = this.#pinLayers.filter(({ inner }) => inner).map((layer) => ({
1970
+ layer,
1971
+ restore: stripStickyPositions([layer.trigger])
1972
+ }));
1973
+ return () => restores.forEach(({ layer, restore }) => {
1974
+ if (layer.inner) restore();
1975
+ });
1803
1976
  }
1804
1977
  #resetStickyState() {
1805
1978
  const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
@@ -1809,39 +1982,59 @@ var StickyScrollTrigger = (function() {
1809
1982
  restoreSceneCoverStickyState();
1810
1983
  };
1811
1984
  }
1812
- #resetPinState() {
1813
- const snapshots = this.#pinLayers.map((layer) => ({
1985
+ #refreshGeometry(viewportHeight) {
1986
+ const active = this.#layers.filter((layer) => layer.wrapper !== null);
1987
+ const wrappers = active.flatMap(({ wrapper }) => wrapper ? [wrapper] : []);
1988
+ const savedWrappers = wrappers.map(captureInlinePosition);
1989
+ const pins = this.#pinLayers.map((layer) => ({
1814
1990
  layer,
1815
1991
  position: captureInlinePosition(layer.trigger),
1816
- height: layer.inner ? layer.inner.style.height : ""
1992
+ range: layer.inner ? layer.inner.style.height : ""
1817
1993
  }));
1818
- snapshots.forEach(({ layer }) => {
1819
- resetStickyPosition(layer.trigger);
1820
- if (layer.inner) layer.inner.style.height = "";
1821
- });
1822
- return () => {
1823
- snapshots.forEach(({ layer, position, height }) => {
1824
- restoreInlinePosition(layer.trigger, position);
1825
- if (layer.inner) layer.inner.style.height = height;
1994
+ wrappers.forEach(clearStickyForRead);
1995
+ pins.forEach(({ layer }) => clearStickyForRead(layer.trigger));
1996
+ let stickyTops;
1997
+ let marginTops;
1998
+ try {
1999
+ const measured = active.length ? this.#measureLayers(viewportHeight, active) : null;
2000
+ marginTops = this.#measureScrollMarginTargets(active);
2001
+ stickyTops = measured ? this.#planLayerPositions(viewportHeight, active, measured) : new Map();
2002
+ this.#readsPageHeight = pins.length > 0 || (measured?.measured.some(({ end }) => end.mode === "max") ?? false);
2003
+ } catch (error) {
2004
+ wrappers.forEach((wrapper, i) => commitPosition(wrapper, savedWrappers[i]));
2005
+ pins.forEach(({ layer, position }) => {
2006
+ if (layer.inner) commitPosition(layer.trigger, position);
1826
2007
  });
1827
- };
1828
- }
1829
- #refreshPins(viewportHeight) {
1830
- if (!this.#pinLayers.length) return;
1831
- const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
1832
- const restorePinState = this.#resetPinState();
2008
+ throw error;
2009
+ }
2010
+ let plannedPins = [];
1833
2011
  try {
1834
- this.#refreshPinLayers(viewportHeight, measureDocumentHeightWithoutPinRanges());
2012
+ if (pins.length) {
2013
+ pins.forEach(({ layer }) => {
2014
+ if (layer.inner) clearHeightForRead(layer.inner);
2015
+ });
2016
+ plannedPins = this.#planPinLayers(viewportHeight, measureDocumentHeightWithoutPinRanges());
2017
+ }
1835
2018
  } catch (error) {
1836
- restorePinState();
2019
+ stickyTops.forEach((top, wrapper) => commitSticky(wrapper, top));
2020
+ pins.forEach(({ layer, position, range }) => {
2021
+ if (!layer.inner) return;
2022
+ commitPosition(layer.trigger, position);
2023
+ commitHeight(layer.inner, range);
2024
+ });
1837
2025
  throw error;
1838
- } finally {
1839
- restoreSceneCoverStickyState();
1840
2026
  }
1841
- }
1842
- #refreshPinLayers(viewportHeight, documentHeight) {
1843
- this.#pinLayers.forEach((layer) => {
2027
+ stickyTops.forEach((top, wrapper) => commitSticky(wrapper, top));
2028
+ plannedPins.forEach(({ layer, topPx, range }) => {
1844
2029
  if (!layer.inner) return;
2030
+ commitSticky(layer.trigger, topPx);
2031
+ commitHeight(layer.inner, `${range}px`);
2032
+ });
2033
+ this.#syncScrollMargins(marginTops);
2034
+ }
2035
+ #planPinLayers(viewportHeight, documentHeight) {
2036
+ return this.#pinLayers.flatMap((layer) => {
2037
+ if (!layer.inner) return [];
1845
2038
  const resolvedStart = resolveMaybeFn(layer.start);
1846
2039
  const resolvedEnd = prefixSpacedRelativeEnd(resolvedStart, resolveMaybeFn(layer.end));
1847
2040
  const classifiedEnd = classifyPosition(resolvedEnd);
@@ -1856,26 +2049,14 @@ var StickyScrollTrigger = (function() {
1856
2049
  const releaseScroll = resolvePinReleaseScroll(layer.endTrigger, classifiedEnd, toScroll(layer.trigger, triggerTop - topPx), viewportHeight, toScroll);
1857
2050
  const height = releaseScroll - (this.#rootElement.contains(layer.trigger) ? dwellConsumedAt(releaseScroll, this.#engagedWindows()) : 0) - triggerTop + topPx + triggerHeight + triggerMarginBottom;
1858
2051
  const room = documentHeight > 0 ? documentHeight - triggerTop : Infinity;
1859
- applyStickyPosition(layer.trigger, topPx);
1860
- layer.inner.style.height = `${Math.max(0, Math.min(height, room))}px`;
2052
+ return [{
2053
+ layer,
2054
+ topPx,
2055
+ range: Math.max(0, Math.min(height, room))
2056
+ }];
1861
2057
  });
1862
2058
  }
1863
- #refreshScenesAndCovers(viewportHeight) {
1864
- if (!this.#layers.length) return;
1865
- const active = this.#layers.filter((layer) => layer.wrapper !== null);
1866
- if (!active.length) return;
1867
- const restoreStickyState = this.#resetSceneCoverStickyState();
1868
- const restorePinStickyState = this.#resetPinStickyState();
1869
- try {
1870
- this.#planLayerPositions(viewportHeight, active);
1871
- } catch (error) {
1872
- restoreStickyState();
1873
- throw error;
1874
- } finally {
1875
- restorePinStickyState();
1876
- }
1877
- }
1878
- #planLayerPositions(viewportHeight, active) {
2059
+ #measureLayers(viewportHeight, active) {
1879
2060
  const structureTop = this.#outermostContainer ? documentTop(this.#outermostContainer) : 0;
1880
2061
  this.#measuredStructure = {
1881
2062
  top: structureTop,
@@ -1885,14 +2066,22 @@ var StickyScrollTrigger = (function() {
1885
2066
  active.forEach((layer, index) => {
1886
2067
  indexByTrigger.set(layer.trigger, index);
1887
2068
  });
1888
- const measured = active.map((layer, ownIndex) => measureLayer(this.#rootElement, viewportHeight, layer, ownIndex, indexByTrigger));
2069
+ return {
2070
+ structureTop,
2071
+ measured: active.map((layer, ownIndex) => measureLayer(this.#rootElement, viewportHeight, layer, ownIndex, indexByTrigger))
2072
+ };
2073
+ }
2074
+ #planLayerPositions(viewportHeight, active, { structureTop, measured }) {
2075
+ const needsLiveRemeasure = measured.some((measurement) => measurement.end.mode === "clause" && measurement.end.measureLive);
2076
+ const needsMaxRemeasure = measured.some((measurement) => measurement.end.mode === "max");
1889
2077
  let documentMaxScroll = 0;
2078
+ let measureLive = false;
1890
2079
  const stickyTops = new Map();
1891
2080
  const applyLayers = () => planLayers(measured, {
1892
2081
  viewportHeight,
1893
2082
  structureTop,
1894
2083
  documentMaxScroll,
1895
- measureLiveEndTriggerTop: (index) => documentTop(active[index].endTrigger),
2084
+ measureLiveEndTriggerTop: (index) => measureLive ? documentTop(active[index].endTrigger) : 0,
1896
2085
  onPlanned: (index, plan) => {
1897
2086
  const layer = active[index];
1898
2087
  layer.freezeStart = plan.freezeStart;
@@ -1901,25 +2090,137 @@ var StickyScrollTrigger = (function() {
1901
2090
  layer.engagedEnd = plan.engagedEnd;
1902
2091
  if (!layer.wrapper) return;
1903
2092
  stickyTops.set(layer.wrapper, plan.stickyTop);
1904
- if (layer.kind === "scene" && layer.padding && plan.paddingHeight !== null) layer.padding.style.height = `${plan.paddingHeight}px`;
2093
+ if (layer.kind === "scene" && layer.padding && plan.paddingHeight !== null) commitHeight(layer.padding, `${plan.paddingHeight}px`);
1905
2094
  }
1906
2095
  });
2096
+ this.#reevaluateLiveEnds(active, measured, () => {
2097
+ const heights = active.map(() => 0);
2098
+ planLayers(measured, {
2099
+ viewportHeight,
2100
+ structureTop,
2101
+ documentMaxScroll,
2102
+ measureLiveEndTriggerTop: () => 0,
2103
+ onPlanned: (index, plan) => {
2104
+ heights[index] = plan.paddingHeight ?? 0;
2105
+ }
2106
+ });
2107
+ return heights;
2108
+ });
1907
2109
  applyLayers();
1908
- const needsLiveRemeasure = measured.some((measurement) => measurement.end.mode === "clause" && measurement.end.measureLive);
1909
- const needsMaxRemeasure = measured.some((measurement) => measurement.end.mode === "max");
1910
- if (needsMaxRemeasure) documentMaxScroll = measureDocumentMaxScroll(viewportHeight);
2110
+ if (needsMaxRemeasure) documentMaxScroll = Math.max(0, measureDocumentHeightWithoutPinRanges() - viewportHeight);
2111
+ measureLive = true;
1911
2112
  if (needsLiveRemeasure || needsMaxRemeasure) applyLayers();
1912
- stickyTops.forEach((top, wrapper) => applyStickyPosition(wrapper, top));
2113
+ return stickyTops;
2114
+ }
2115
+ #reevaluateLiveEnds(active, measured, planPaddings) {
2116
+ const live = measured.flatMap(({ liveEnd }, index) => liveEnd ? [{
2117
+ index,
2118
+ liveEnd
2119
+ }] : []);
2120
+ if (!live.length) return;
2121
+ const scrollBefore = window.scrollY;
2122
+ try {
2123
+ for (let round = 0; round < LIVE_END_ROUNDS; round += 1) {
2124
+ const planned = planPaddings();
2125
+ let moved = false;
2126
+ live.forEach(({ index, liveEnd }) => {
2127
+ const next = this.#evaluateLiveEnd(active, planned, index, liveEnd, scrollBefore);
2128
+ const current = measured[index].end;
2129
+ if (!next || next.mode !== current.mode) return;
2130
+ if (Math.abs(liveEndValue(next) - liveEndValue(current)) <= LIVE_END_TOLERANCE_PX) return;
2131
+ measured[index] = {
2132
+ ...measured[index],
2133
+ end: next
2134
+ };
2135
+ moved = true;
2136
+ });
2137
+ if (!moved) break;
2138
+ }
2139
+ } finally {
2140
+ scrollBackTo(scrollBefore);
2141
+ }
2142
+ }
2143
+ #evaluateLiveEnd(active, planned, index, liveEnd, scroll) {
2144
+ const spacers = active.flatMap((layer, k) => k < index && layer.kind === "scene" && planned[k] ? [{
2145
+ after: layer.trigger,
2146
+ height: planned[k]
2147
+ }] : []);
2148
+ const setUp = () => {
2149
+ const later = [...armedInstances].filter((other) => other !== this && compareDocumentOrder(this.#rootElement, other.#rootElement) < 0);
2150
+ const paddings = [this, ...later].flatMap((instance) => instance.#layers.flatMap((layer) => layer.kind === "scene" && layer.padding ? [layer.padding] : []));
2151
+ const heights = paddings.map((padding) => padding.style.height);
2152
+ paddings.forEach((padding) => commitHeight(padding, "0px"));
2153
+ const removeSpacers = insertSpacers(spacers);
2154
+ return () => {
2155
+ removeSpacers();
2156
+ paddings.forEach((padding, k) => {
2157
+ if (padding.style.height === "0px") commitHeight(padding, heights[k]);
2158
+ });
2159
+ };
2160
+ };
2161
+ let takeDown = () => {};
2162
+ let holds = 0;
2163
+ const evaluation = {
2164
+ resolved: false,
2165
+ ended: false,
2166
+ outer: liveEvaluation,
2167
+ scroll: liveEvaluation?.scroll ?? scroll,
2168
+ suspend: (resolving) => {
2169
+ if (resolving) evaluation.resolved = true;
2170
+ holds += 1;
2171
+ if (holds === 1) {
2172
+ takeDown();
2173
+ takeDown = () => {};
2174
+ }
2175
+ return () => {
2176
+ holds -= 1;
2177
+ if (holds === 0 && !evaluation.ended) takeDown = setUp();
2178
+ };
2179
+ }
2180
+ };
2181
+ try {
2182
+ takeDown = setUp();
2183
+ liveEvaluation = evaluation;
2184
+ const next = liveEnd();
2185
+ return evaluation.resolved ? null : next;
2186
+ } finally {
2187
+ evaluation.ended = true;
2188
+ liveEvaluation = evaluation.outer;
2189
+ takeDown();
2190
+ }
1913
2191
  }
1914
2192
  refresh() {
2193
+ this.#refreshFrom(false);
2194
+ }
2195
+ #refreshFrom(refreshInit) {
2196
+ if (this.#depth > 0 && !this.#dirty) {
2197
+ if (!refreshInit) {
2198
+ this.#measureAgain = true;
2199
+ return;
2200
+ }
2201
+ if (this.#refreshInitNestedUsed) return;
2202
+ this.#refreshInitNestedUsed = true;
2203
+ }
2204
+ this.#runRefresh();
2205
+ }
2206
+ #runRefresh() {
2207
+ if (this.#depth > 0) this.#measureAgain = true;
1915
2208
  if (this.#destroyed || !this.#armed || pendingDisarms.has(this)) return;
1916
2209
  let failure = null;
1917
2210
  const position = this.#keepContentPending ? this.#naturalScrollTop(this.#builtLayers) : null;
1918
2211
  this.#keepContentPending = false;
2212
+ this.#depth += 1;
1919
2213
  try {
1920
2214
  this.#refreshLayout();
2215
+ if (this.#depth === 1 && this.#measureAgain && !this.#destroyed && this.#armed && !pendingDisarms.has(this)) this.#refreshLayout();
1921
2216
  } catch (error) {
1922
2217
  failure = { error };
2218
+ } finally {
2219
+ this.#depth -= 1;
2220
+ if (this.#depth === 0) {
2221
+ this.#refreshInitNestedUsed = false;
2222
+ this.#measureAgain = false;
2223
+ }
1923
2224
  }
1924
2225
  try {
1925
2226
  rebuildDormancy(this.#scrollTriggerClass);
@@ -1933,15 +2234,10 @@ var StickyScrollTrigger = (function() {
1933
2234
  if (!failure && position !== null) this.#keepContent(position);
1934
2235
  if (failure) throw failure.error;
1935
2236
  }
1936
- #gsapScrollRecord() {
1937
- if (!this.#scrollTriggerClass?.isRefreshing) return null;
1938
- const scrollFunc = this.#scrollTriggerClass.getScrollFunc?.(window);
1939
- return scrollFunc && typeof scrollFunc.rec === "number" && scrollFunc.rec ? scrollFunc : null;
1940
- }
1941
2237
  #naturalScrollTop(layers) {
1942
2238
  const measured = this.#measuredStructure;
1943
2239
  const moved = measured && this.#outermostContainer && measured.unbuilds !== unbuildCount ? documentTop(this.#outermostContainer) - measured.top : 0;
1944
- const scroll = (this.#gsapScrollRecord()?.rec ?? window.scrollY) - moved;
2240
+ const scroll = (scrollRecord(this.#scrollTriggerClass)?.read() ?? window.scrollY) - moved;
1945
2241
  const consumed = new Map();
1946
2242
  layers.forEach((layer) => {
1947
2243
  if (layer.kind !== "scene") return;
@@ -1954,20 +2250,17 @@ var StickyScrollTrigger = (function() {
1954
2250
  }
1955
2251
  #keepContent(position, cls = this.#scrollTriggerClass) {
1956
2252
  const target = this.#keptScrollTop(position);
1957
- const record = this.#gsapScrollRecord();
2253
+ const record = scrollRecord(this.#scrollTriggerClass);
1958
2254
  if (record) {
1959
- record.rec = target;
2255
+ record.write(target);
1960
2256
  return;
1961
2257
  }
1962
- if (cls?.isRefreshing) return;
2258
+ if (isRefreshing(cls)) return;
1963
2259
  if (Math.abs(window.scrollY - target) >= .5) window.scrollTo({
1964
2260
  top: Math.round(target),
1965
2261
  behavior: "instant"
1966
2262
  });
1967
- const scrollFunc = cls?.getScrollFunc?.(window);
1968
- if (typeof scrollFunc !== "function") return;
1969
- const cached = scrollFunc();
1970
- if (typeof cached !== "number" || Math.abs(cached - window.scrollY) >= .5) scrollFunc(window.scrollY);
2263
+ syncScrollCache(cls);
1971
2264
  }
1972
2265
  #keptScrollTop({ natural, consumed }) {
1973
2266
  let earlierDwell = 0;
@@ -1994,9 +2287,7 @@ var StickyScrollTrigger = (function() {
1994
2287
  this.#liftCovers();
1995
2288
  }
1996
2289
  const viewportHeight = this.#layers.length || this.#pinLayers.length ? measureViewportHeight() : 0;
1997
- this.#refreshScenesAndCovers(viewportHeight);
1998
- this.#refreshPins(viewportHeight);
1999
- this.#syncScrollMargins();
2290
+ this.#refreshGeometry(viewportHeight);
2000
2291
  }
2001
2292
  #coverLayers() {
2002
2293
  return this.#layers.filter((layer) => layer.kind === "cover");
@@ -2010,15 +2301,21 @@ var StickyScrollTrigger = (function() {
2010
2301
  this.#coverRestoreByLayer.set(layer, liftAboveStickyWrapper(pin?.outer ?? layer.cover));
2011
2302
  });
2012
2303
  }
2013
- #syncScrollMargins() {
2304
+ #syncScrollMargins(tops) {
2014
2305
  this.#scrollMarginSync?.sync(this.#engagedWindows(), this.#outermostContainer, (targets) => {
2015
- if (!targets.length) return [];
2016
- const restoreStickyState = this.#resetStickyState();
2017
- const tops = targets.map((target) => documentTop(target));
2018
- restoreStickyState();
2019
- return tops;
2306
+ const late = targets.filter((target) => !tops.has(target));
2307
+ if (late.length) {
2308
+ const restoreStickyState = this.#resetStickyState();
2309
+ late.forEach((target) => tops.set(target, documentTop(target)));
2310
+ restoreStickyState();
2311
+ }
2312
+ return targets.map((target) => tops.get(target));
2020
2313
  });
2021
2314
  }
2315
+ #measureScrollMarginTargets(active) {
2316
+ const targets = this.#scrollMarginSync && active.some(({ kind }) => kind === "scene") ? this.#scrollMarginSync.targets() : [];
2317
+ return new Map(targets.map((target) => [target, documentTop(target)]));
2318
+ }
2022
2319
  #assertNoExcludedVars(rest, context) {
2023
2320
  const found = EXCLUDED_VAR_KEYS.filter((key) => key in rest);
2024
2321
  if (found.length === 0) return;
@@ -2043,6 +2340,7 @@ var StickyScrollTrigger = (function() {
2043
2340
  this.#arm();
2044
2341
  this.#layers.push(layer);
2045
2342
  this.#dirty = true;
2343
+ if (this.#depth > 0) this.#measureAgain = true;
2046
2344
  return {
2047
2345
  ...rest,
2048
2346
  trigger: layer.trigger,
@@ -2051,6 +2349,10 @@ var StickyScrollTrigger = (function() {
2051
2349
  invalidateOnRefresh: rest.invalidateOnRefresh ?? true,
2052
2350
  onKill: (self) => {
2053
2351
  this.#captureScrollTriggerClass(self);
2352
+ if (!this.#layers.includes(layer)) {
2353
+ onKill?.(self);
2354
+ return;
2355
+ }
2054
2356
  removeItem(this.#layers, layer);
2055
2357
  this.#dirty = true;
2056
2358
  this.#scheduleRebuild();
@@ -2132,6 +2434,7 @@ var StickyScrollTrigger = (function() {
2132
2434
  };
2133
2435
  this.#arm();
2134
2436
  this.#pinLayers.push(layer);
2437
+ if (this.#depth > 0) this.#measureAgain = true;
2135
2438
  return {
2136
2439
  ...rest,
2137
2440
  trigger,
@@ -2146,6 +2449,14 @@ var StickyScrollTrigger = (function() {
2146
2449
  };
2147
2450
  }
2148
2451
  resolveScrollPosition(elementInput, position) {
2452
+ const resume = liveEvaluation && suspendLiveEvaluations(liveEvaluation, true);
2453
+ try {
2454
+ return this.#resolveScrollPosition(elementInput, position);
2455
+ } finally {
2456
+ resume?.();
2457
+ }
2458
+ }
2459
+ #resolveScrollPosition(elementInput, position) {
2149
2460
  const element = resolveElement(elementInput, "resolveScrollPosition");
2150
2461
  const resolved = resolveMaybeFn(position);
2151
2462
  const viewportHeight = measureViewportHeight();