sticky-scroll-trigger 0.12.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.12.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
@@ -86,10 +86,6 @@ const resetStickyPosition = (el) => {
86
86
  el.style.position = "";
87
87
  el.style.top = "";
88
88
  };
89
- const applyStickyPosition = (el, topPx) => {
90
- el.style.position = "sticky";
91
- el.style.top = `${topPx}px`;
92
- };
93
89
  const captureInlinePosition = (el) => ({
94
90
  position: el.style.position,
95
91
  top: el.style.top
@@ -103,6 +99,15 @@ const stripStickyPositions = (elements) => {
103
99
  elements.forEach(resetStickyPosition);
104
100
  return () => elements.forEach((el, i) => restoreInlinePosition(el, saved[i]));
105
101
  };
102
+ const insertSpacers = (spacers) => {
103
+ const inserted = spacers.map(({ after, height }) => {
104
+ const spacer = document.createElement("div");
105
+ spacer.style.cssText = `height:${height}px;margin:0;padding:0;border:0`;
106
+ after.after(spacer);
107
+ return spacer;
108
+ });
109
+ return () => inserted.forEach((spacer) => spacer.remove());
110
+ };
106
111
  const wrapScene = (inner, holdTrailingMargin) => {
107
112
  if (!inner.parentNode) throw new Error(`StickyScrollTrigger: ${describeElement(inner)} is not attached to the document`);
108
113
  const container = document.createElement("div");
@@ -205,6 +210,41 @@ const liftAboveStickyWrapper = (cover) => {
205
210
  lifted.length = 0;
206
211
  };
207
212
  };
213
+ const classOf = (self) => self.constructor;
214
+ const isRefreshing = (cls) => cls?.isRefreshing === true;
215
+ const isScrolling = (cls) => Boolean(cls?.isScrolling?.());
216
+ const isScrollingOrUpdating = (cls) => Boolean(cls?.isScrolling?.() || cls?.isUpdating === true);
217
+ const addGsapListener = (cls, type, callback) => {
218
+ cls?.addEventListener?.(type, callback);
219
+ };
220
+ const removeGsapListener = (cls, type, callback) => {
221
+ cls?.removeEventListener?.(type, callback);
222
+ };
223
+ const refreshAll = (cls) => {
224
+ if (typeof cls?.refresh === "function") cls.refresh();
225
+ };
226
+ const scrollRecord = (cls, zero = false) => {
227
+ if (!cls || !isRefreshing(cls)) return null;
228
+ const scrollFunc = cls.getScrollFunc?.(window);
229
+ if (!(scrollFunc && typeof scrollFunc.rec === "number" && (zero || scrollFunc.rec))) return null;
230
+ const record = scrollFunc;
231
+ return {
232
+ read: () => record.rec,
233
+ write: (value) => {
234
+ record.rec = value;
235
+ }
236
+ };
237
+ };
238
+ const syncScrollCache = (cls) => {
239
+ const scrollFunc = cls?.getScrollFunc?.(window);
240
+ if (typeof scrollFunc !== "function") return;
241
+ const cached = scrollFunc();
242
+ if (typeof cached !== "number" || Math.abs(cached - window.scrollY) >= .5) scrollFunc(window.scrollY);
243
+ };
244
+ const revertAfterMeasure = (restore, result) => ({ render: (time) => {
245
+ result?.render?.(time);
246
+ restore();
247
+ } });
208
248
  const AUTO_MIN_DEPTH = 7;
209
249
  const MAX_CHAIN_IN_BAND = 4;
210
250
  const BUFFER_FLOOR_PX = 325;
@@ -280,7 +320,7 @@ let gsapPhase = "idle";
280
320
  let adoptedMidRefresh = false;
281
321
  let scannedThisTask = null;
282
322
  const gsapClasses = new Set();
283
- const gsapRefreshing = () => Array.from(gsapClasses).some((cls) => cls.isRefreshing === true);
323
+ const gsapRefreshing = () => Array.from(gsapClasses).some((cls) => isRefreshing(cls));
284
324
  const stateAt = (record, scroll) => {
285
325
  if (!record.demotable) return "in";
286
326
  if (scroll < record.lo - buffer) return "before";
@@ -358,22 +398,22 @@ const onGsapRefreshInit = () => {
358
398
  queueMicrotask(onGsapRefreshDone);
359
399
  if (records.length) update(0);
360
400
  }
361
- return { render: restoreAfterGsapMeasure };
401
+ return revertAfterMeasure(restoreAfterGsapMeasure);
362
402
  };
363
403
  const adoptGsapClass = (cls) => {
364
404
  if (gsapClasses.has(cls)) return;
365
- if (cls.isRefreshing === true) adoptedMidRefresh = true;
405
+ if (isRefreshing(cls)) adoptedMidRefresh = true;
366
406
  gsapClasses.add(cls);
367
- cls.addEventListener?.("refresh", onGsapRefreshDone);
368
- cls.addEventListener?.("refreshInit", onGsapRefreshInit);
407
+ addGsapListener(cls, "refresh", onGsapRefreshDone);
408
+ addGsapListener(cls, "refreshInit", onGsapRefreshInit);
369
409
  };
370
410
  const dropGsapClassesLater = () => {
371
411
  if (!gsapClasses.size) return;
372
412
  queueMicrotask(() => {
373
413
  if (liveClients().length) return;
374
414
  gsapClasses.forEach((cls) => {
375
- cls.removeEventListener?.("refresh", onGsapRefreshDone);
376
- cls.removeEventListener?.("refreshInit", onGsapRefreshInit);
415
+ removeGsapListener(cls, "refresh", onGsapRefreshDone);
416
+ removeGsapListener(cls, "refreshInit", onGsapRefreshInit);
377
417
  });
378
418
  gsapClasses.clear();
379
419
  });
@@ -606,7 +646,14 @@ const rebuildDormancy = (scrollTriggerClass) => {
606
646
  update(gsapPhase === "measuring" ? 0 : (gsapPhase === "restored" ? scrollBeforeGsapRefresh : null) ?? scroll);
607
647
  listen(true);
608
648
  };
609
- const takeGsapRefreshRestore = () => adoptedMidRefresh && gsapRefreshing() ? onGsapRefreshInit().render : null;
649
+ const takeGsapRefreshRestore = () => {
650
+ if (!adoptedMidRefresh || !gsapRefreshing()) return null;
651
+ onGsapRefreshInit();
652
+ return restoreAfterGsapMeasure;
653
+ };
654
+ const setGsapRefreshReturn = (scroll) => {
655
+ if (gsapPhase !== "idle") scrollBeforeGsapRefresh = scroll;
656
+ };
610
657
  const clearDormancy = clearTable;
611
658
  const releaseDormant = (elements) => {
612
659
  const released = new Set(elements);
@@ -637,6 +684,24 @@ const unregisterDormancyClient = (client) => {
637
684
  if (liveClients().length) queueRebuild();
638
685
  else teardown();
639
686
  };
687
+ const commitSticky = (el, topPx) => {
688
+ el.style.position = "sticky";
689
+ el.style.top = `${topPx}px`;
690
+ };
691
+ const commitPosition = (el, saved) => {
692
+ el.style.position = saved.position;
693
+ el.style.top = saved.top;
694
+ };
695
+ const commitHeight = (el, height) => {
696
+ el.style.height = height;
697
+ };
698
+ const clearStickyForRead = (el) => {
699
+ el.style.position = "";
700
+ el.style.top = "";
701
+ };
702
+ const clearHeightForRead = (el) => {
703
+ el.style.height = "";
704
+ };
640
705
  const resolveMaybeFn = (value) => typeof value === "function" ? value() : value;
641
706
  const KEYWORD_FRACTIONS = {
642
707
  top: 0,
@@ -1287,7 +1352,6 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
1287
1352
  if (usesJsRamp) {
1288
1353
  jsRamps = ramps;
1289
1354
  jsHost = host;
1290
- applyJsRamp();
1291
1355
  return;
1292
1356
  }
1293
1357
  if (!sheet) {
@@ -1302,6 +1366,7 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
1302
1366
  stopRamps();
1303
1367
  };
1304
1368
  return {
1369
+ targets: () => targetSelector === null ? [] : Array.from(rootElement.querySelectorAll(targetSelector)),
1305
1370
  sync(scenes, host, measureNaturalTops) {
1306
1371
  const ramps = scenes.filter((scene) => scene.freezeEnd > scene.freezeStart).sort((a, b) => a.freezeStart - b.freezeStart);
1307
1372
  if (targetSelector === null || !ramps.length || !host) {
@@ -1333,6 +1398,9 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
1333
1398
  });
1334
1399
  written = next;
1335
1400
  },
1401
+ applyRamps() {
1402
+ applyJsRamp();
1403
+ },
1336
1404
  restore() {
1337
1405
  if (usesJsRamp) window.removeEventListener("scroll", applyJsRamp);
1338
1406
  release();
@@ -1362,6 +1430,11 @@ const buildStructure = (rootElement, layers) => {
1362
1430
  }
1363
1431
  return outermost;
1364
1432
  };
1433
+ const unbuildCover = (layer) => {
1434
+ if (!layer.wrapper) return;
1435
+ unwrapCover(layer.wrapper);
1436
+ layer.wrapper = null;
1437
+ };
1365
1438
  const unbuildStructure = (rootElement, layers, outermostContainer) => {
1366
1439
  if (outermostContainer) {
1367
1440
  outermostContainer.parentNode?.insertBefore(rootElement, outermostContainer);
@@ -1369,15 +1442,13 @@ const unbuildStructure = (rootElement, layers, outermostContainer) => {
1369
1442
  }
1370
1443
  for (let i = layers.length - 1; i >= 0; i -= 1) {
1371
1444
  const layer = layers[i];
1372
- if (layer.kind === "cover" && layer.wrapper) unwrapCover(layer.wrapper);
1373
- }
1374
- layers.forEach((layer) => {
1375
- layer.wrapper = null;
1376
- if (layer.kind === "scene") {
1445
+ if (layer.kind === "cover") unbuildCover(layer);
1446
+ else {
1447
+ layer.wrapper = null;
1377
1448
  layer.container = null;
1378
1449
  layer.padding = null;
1379
1450
  }
1380
- });
1451
+ }
1381
1452
  };
1382
1453
  const resolveEndSpec = (rootElement, viewportHeight, layer, endResolved, ownIndex, endTriggerIndex) => {
1383
1454
  if (endResolved === null) return { mode: "auto" };
@@ -1439,6 +1510,8 @@ const measureLayer = (rootElement, viewportHeight, layer, ownIndex, indexByTrigg
1439
1510
  const end = resolveEndSpec(rootElement, viewportHeight, layer, endResolved, ownIndex, endTriggerIndex);
1440
1511
  const endTriggerInContainer = end.mode === "clause" && !end.measureLive && !endTriggerIsSelf;
1441
1512
  const start = resolveStartSpec(layer, startResolved, elementHeight, viewportHeight);
1513
+ const { end: endInput } = layer;
1514
+ 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;
1442
1515
  return {
1443
1516
  kind: layer.kind,
1444
1517
  start,
@@ -1454,7 +1527,8 @@ const measureLayer = (rootElement, viewportHeight, layer, ownIndex, indexByTrigg
1454
1527
  height: end.mode === "clause" ? measureUsedHeight(layer.endTrigger) : 0,
1455
1528
  enclosedBy: endTriggerInContainer ? indicesWhere((trigger) => trigger.contains(layer.endTrigger)) : [],
1456
1529
  nests: endTriggerInContainer ? indicesWhere((other) => other !== layer.endTrigger && layer.endTrigger.contains(other)) : []
1457
- }
1530
+ },
1531
+ liveEnd
1458
1532
  };
1459
1533
  };
1460
1534
  const EXCLUDED_VAR_KEYS = [
@@ -1491,20 +1565,94 @@ const removeItem = (list, item) => {
1491
1565
  const index = list.indexOf(item);
1492
1566
  if (index !== -1) list.splice(index, 1);
1493
1567
  };
1568
+ const suspendLiveEvaluations = (evaluation, resolving) => {
1569
+ const resumes = [];
1570
+ for (let current = evaluation; current; current = current.outer) resumes.unshift(current.suspend(resolving && current === evaluation));
1571
+ return () => resumes.forEach((resume) => resume());
1572
+ };
1573
+ const liveEndValue = (spec) => {
1574
+ if (spec.mode === "dwell") return spec.distancePx;
1575
+ return spec.mode === "absolute" ? spec.value : 0;
1576
+ };
1577
+ const LIVE_END_ROUNDS = 6;
1578
+ const LIVE_END_TOLERANCE_PX = .5;
1494
1579
  const hasDuplicateTrigger = (list, trigger) => list.some((existing) => existing.trigger === trigger);
1580
+ const pendingDisarms = new Set();
1581
+ const pendingKeeps = new Set();
1582
+ const pendingCatchUps = new Map();
1583
+ let unbuildCount = 0;
1584
+ let refreshedInGsapRefresh = null;
1585
+ const armedInstances = new Set();
1586
+ let liveEvaluation = null;
1587
+ let layerHandlerDepth = 0;
1588
+ const scrollBackTo = (top) => {
1589
+ if (Math.abs(window.scrollY - top) >= .5) window.scrollTo({
1590
+ top,
1591
+ behavior: "instant"
1592
+ });
1593
+ };
1594
+ const holdLiveEvaluationForGsapRefresh = (cls) => {
1595
+ const evaluation = liveEvaluation;
1596
+ if (!evaluation) return;
1597
+ const resume = suspendLiveEvaluations(evaluation, false);
1598
+ const record = scrollRecord(cls, true);
1599
+ if (record && Math.abs(record.read() - evaluation.scroll) >= .5) {
1600
+ scrollBackTo(Math.round(evaluation.scroll));
1601
+ syncScrollCache(cls);
1602
+ record.write(window.scrollY);
1603
+ setGsapRefreshReturn(window.scrollY);
1604
+ }
1605
+ const depth = layerHandlerDepth - 1;
1606
+ let held = true;
1607
+ liveEvaluation = null;
1608
+ const onRefresh = () => {
1609
+ if (!held || layerHandlerDepth > depth) return;
1610
+ held = false;
1611
+ resume();
1612
+ if (!evaluation.ended) liveEvaluation = evaluation;
1613
+ };
1614
+ addGsapListener(cls, "refresh", onRefresh);
1615
+ queueMicrotask(() => removeGsapListener(cls, "refresh", onRefresh));
1616
+ };
1617
+ const REST_POLL_MS = 100;
1618
+ const runEach = (...steps) => {
1619
+ let failure = null;
1620
+ steps.forEach((step) => {
1621
+ try {
1622
+ step();
1623
+ } catch (error) {
1624
+ if (!failure) failure = { error };
1625
+ else queueMicrotask(() => {
1626
+ throw error;
1627
+ });
1628
+ }
1629
+ });
1630
+ if (failure) throw failure.error;
1631
+ };
1495
1632
  var StickyScrollTrigger = class {
1496
1633
  #rootElement;
1497
1634
  #layers = [];
1498
1635
  #builtLayers = [];
1636
+ #measuredStructure = null;
1499
1637
  #coverRestoreByLayer = new WeakMap();
1500
1638
  #built = false;
1501
1639
  #dirty = false;
1502
1640
  #outermostContainer = null;
1503
1641
  #destroyed = false;
1504
- #rebuildScheduled = false;
1642
+ #depth = 0;
1643
+ #refreshInitNestedUsed = false;
1644
+ #measureAgain = false;
1645
+ #keepContentPending = false;
1646
+ #deferredRun = null;
1647
+ #restTimer = null;
1648
+ #pendingKeep = null;
1505
1649
  #scrollTriggerClass = null;
1506
1650
  #pinLayers = [];
1507
- #scrollMarginSync;
1651
+ #scrollMarginSync = null;
1652
+ #scrollMarginTargets;
1653
+ #armed = false;
1654
+ #dispatchObserver = null;
1655
+ #readsPageHeight = false;
1508
1656
  #dormancyClient = null;
1509
1657
  constructor(root, options = {}) {
1510
1658
  this.#rootElement = resolveRoot(root);
@@ -1520,15 +1668,101 @@ var StickyScrollTrigger = class {
1520
1668
  "always",
1521
1669
  "off"
1522
1670
  ].includes(optimization)) throw new Error(`StickyScrollTrigger: nestedStickyOptimization must be 'auto', 'always' or 'off', got ${String(optimization)}.`);
1523
- this.#scrollMarginSync = createScrollMarginSync(this.#rootElement, scrollMarginTargets);
1524
- if (optimization === "always" || optimization === "auto" && isWebKit()) {
1525
- this.#dormancyClient = {
1526
- mode: optimization,
1527
- ownedElements: () => this.#ownedStickyElements()
1528
- };
1529
- registerDormancyClient(this.#dormancyClient);
1671
+ this.#scrollMarginTargets = scrollMarginTargets;
1672
+ if (optimization === "always" || optimization === "auto" && isWebKit()) this.#dormancyClient = {
1673
+ mode: optimization,
1674
+ ownedElements: () => this.#ownedStickyElements()
1675
+ };
1676
+ }
1677
+ #arm() {
1678
+ if (pendingDisarms.delete(this)) this.#keepContentPending = false;
1679
+ if (this.#armed) return;
1680
+ this.#armed = true;
1681
+ armedInstances.add(this);
1682
+ pendingKeeps.forEach((keep) => {
1683
+ if (keep.owner.#overlaps(this)) keep.cancelled = true;
1684
+ });
1685
+ this.#scrollMarginSync = createScrollMarginSync(this.#rootElement, this.#scrollMarginTargets);
1686
+ if (this.#dormancyClient) registerDormancyClient(this.#dormancyClient);
1687
+ }
1688
+ #disarmIfEmpty() {
1689
+ if (this.#armed && !this.#destroyed && !this.#layers.length && !this.#pinLayers.length) {
1690
+ if (pendingDisarms.has(this)) return;
1691
+ const cls = this.#scrollTriggerClass;
1692
+ if (!isRefreshing(cls) && isScrollingOrUpdating(cls)) {
1693
+ pendingDisarms.add(this);
1694
+ queueMicrotask(() => this.#settleWhenAtRest());
1695
+ return;
1696
+ }
1697
+ this.#disarmKeepingContent(true, true);
1530
1698
  }
1531
1699
  }
1700
+ #flushOverlappingDisarms() {
1701
+ if (this.#destroyed) return;
1702
+ pendingDisarms.forEach((other) => {
1703
+ if (other !== this && other.#overlaps(this)) other.#flushPendingDisarmForRevert();
1704
+ });
1705
+ }
1706
+ #disarmKeepingContent(keepContent, onlyAtRest = false) {
1707
+ const position = keepContent && this.#built ? this.#naturalScrollTop(this.#builtLayers) : null;
1708
+ this.#keepContentPending = false;
1709
+ this.#disarm();
1710
+ if (!position) return;
1711
+ if (scrollRecord(this.#scrollTriggerClass)) {
1712
+ this.#keepContent(position);
1713
+ return;
1714
+ }
1715
+ if (this.#pendingKeep) pendingKeeps.delete(this.#pendingKeep);
1716
+ this.#pendingKeep = {
1717
+ owner: this,
1718
+ position,
1719
+ cls: this.#scrollTriggerClass,
1720
+ onlyAtRest,
1721
+ cancelled: false
1722
+ };
1723
+ pendingKeeps.add(this.#pendingKeep);
1724
+ queueMicrotask(() => this.#applyPendingKeep());
1725
+ }
1726
+ #applyPendingKeep() {
1727
+ const keep = this.#pendingKeep;
1728
+ if (!keep) return;
1729
+ this.#pendingKeep = null;
1730
+ pendingKeeps.delete(keep);
1731
+ if (keep.cancelled || keep.onlyAtRest && isScrolling(keep.cls)) return;
1732
+ this.#keepContent(keep.position, keep.cls);
1733
+ }
1734
+ #overlaps(other) {
1735
+ return this.#rootElement.contains(other.#rootElement) || other.#rootElement.contains(this.#rootElement);
1736
+ }
1737
+ #settleWhenAtRest() {
1738
+ if (this.#destroyed || this.#restTimer !== null) return;
1739
+ if (isScrolling(this.#scrollTriggerClass)) {
1740
+ this.#restTimer = setTimeout(() => {
1741
+ this.#restTimer = null;
1742
+ this.#settleWhenAtRest();
1743
+ }, REST_POLL_MS);
1744
+ return;
1745
+ }
1746
+ const run = this.#deferredRun;
1747
+ this.#deferredRun = null;
1748
+ runEach(() => this.#flushPendingDisarm(), () => run?.());
1749
+ }
1750
+ #flushPendingDisarm(keepContent = true, onlyAtRest = false) {
1751
+ if (pendingDisarms.delete(this) && !this.#destroyed && !this.#layers.length && !this.#pinLayers.length) this.#disarmKeepingContent(keepContent, onlyAtRest);
1752
+ }
1753
+ #flushPendingDisarmForRevert() {
1754
+ this.#flushPendingDisarm(!isScrolling(this.#scrollTriggerClass), true);
1755
+ }
1756
+ #disarm() {
1757
+ this.#armed = false;
1758
+ armedInstances.delete(this);
1759
+ unregisterDormancyClient(this.#dormancyClient);
1760
+ this.#scrollMarginSync?.restore();
1761
+ this.#scrollMarginSync = null;
1762
+ this.#restoreCoverLifts();
1763
+ this.#unbuild();
1764
+ this.#builtLayers = [];
1765
+ }
1532
1766
  #ownedStickyElements() {
1533
1767
  return [...this.#builtLayers.flatMap((layer) => layer.wrapper ? [layer.wrapper] : []), ...this.#wrappedPinTriggers()];
1534
1768
  }
@@ -1538,6 +1772,8 @@ var StickyScrollTrigger = class {
1538
1772
  #unbuild() {
1539
1773
  if (!this.#built) return;
1540
1774
  unbuildStructure(this.#rootElement, this.#builtLayers, this.#outermostContainer);
1775
+ unbuildCount += 1;
1776
+ this.#measuredStructure = null;
1541
1777
  this.#outermostContainer = null;
1542
1778
  this.#built = false;
1543
1779
  }
@@ -1547,39 +1783,151 @@ var StickyScrollTrigger = class {
1547
1783
  this.#built = true;
1548
1784
  this.#dirty = false;
1549
1785
  }
1786
+ #catchUp() {
1787
+ this.#flushPendingDisarm();
1788
+ this.#runRefresh();
1789
+ this.#applyPendingKeep();
1790
+ }
1550
1791
  #scheduleRebuild() {
1551
- if (this.#rebuildScheduled || this.#destroyed) return;
1552
- this.#rebuildScheduled = true;
1792
+ if (this.#destroyed) return;
1793
+ if (this.#built) this.#keepContentPending = true;
1794
+ if (pendingCatchUps.has(this)) return;
1795
+ const cls = this.#scrollTriggerClass;
1796
+ const pending = () => pendingCatchUps.get(this) === catchUpNow;
1797
+ const catchUpNow = () => {
1798
+ if (!pending()) return false;
1799
+ pendingCatchUps.delete(this);
1800
+ if (this.#destroyed) return false;
1801
+ try {
1802
+ this.#catchUp();
1803
+ } catch (error) {
1804
+ queueMicrotask(() => {
1805
+ throw error;
1806
+ });
1807
+ }
1808
+ return true;
1809
+ };
1810
+ pendingCatchUps.set(this, catchUpNow);
1811
+ const onRefreshInit = () => {
1812
+ if (!catchUpNow()) return void 0;
1813
+ const restoreDormancy = takeGsapRefreshRestore();
1814
+ return restoreDormancy ? revertAfterMeasure(restoreDormancy) : void 0;
1815
+ };
1816
+ addGsapListener(cls, "refreshInit", onRefreshInit);
1817
+ const run = () => {
1818
+ try {
1819
+ if (pending() && !this.#destroyed) refreshAll(this.#scrollTriggerClass);
1820
+ } finally {
1821
+ removeGsapListener(cls, "refreshInit", onRefreshInit);
1822
+ catchUpNow();
1823
+ }
1824
+ };
1553
1825
  queueMicrotask(() => {
1554
- this.#rebuildScheduled = false;
1555
- if (this.#destroyed) return;
1556
- this.refresh();
1557
- if (typeof this.#scrollTriggerClass?.refresh === "function") this.#scrollTriggerClass.refresh();
1826
+ if (pending() && !this.#destroyed && isScrolling(cls)) {
1827
+ const earlier = this.#deferredRun;
1828
+ this.#deferredRun = earlier ? () => runEach(earlier, run) : run;
1829
+ this.#settleWhenAtRest();
1830
+ return;
1831
+ }
1832
+ run();
1558
1833
  });
1559
1834
  }
1560
1835
  #captureScrollTriggerClass(self) {
1561
1836
  if (this.#destroyed) return;
1562
- this.#scrollTriggerClass = self.constructor;
1837
+ this.#scrollTriggerClass = classOf(self);
1563
1838
  }
1564
1839
  #createAutoRefreshHandler(userOnRefreshInit) {
1565
- return (self) => {
1840
+ const handle = (self) => {
1566
1841
  this.#captureScrollTriggerClass(self);
1842
+ if (isRefreshing(this.#scrollTriggerClass)) holdLiveEvaluationForGsapRefresh(this.#scrollTriggerClass);
1567
1843
  const result = userOnRefreshInit?.(self);
1844
+ const inGsapRefresh = isRefreshing(this.#scrollTriggerClass);
1845
+ let caughtUp = false;
1846
+ let refreshed = false;
1847
+ if (inGsapRefresh) {
1848
+ [...pendingCatchUps].forEach(([owner, catchUpNow]) => owner !== this && catchUpNow());
1849
+ caughtUp = pendingCatchUps.get(this)?.() === true;
1850
+ if (caughtUp) this.#dispatchObserver?.takeRecords();
1851
+ }
1852
+ const unchanged = inGsapRefresh && !userOnRefreshInit && !this.#dirty && (caughtUp || this.#dispatchObserver !== null && this.#dispatchObserver.takeRecords().length === 0);
1568
1853
  try {
1569
- this.refresh();
1854
+ if (!unchanged) {
1855
+ refreshed = true;
1856
+ this.#refreshFrom(true);
1857
+ }
1570
1858
  } catch (error) {
1571
1859
  queueMicrotask(() => {
1572
1860
  throw error;
1573
1861
  });
1574
1862
  }
1863
+ if (inGsapRefresh) {
1864
+ this.#watchGsapRefresh();
1865
+ if (refreshed || caughtUp) this.#remeasureEarlierInGsapRefresh();
1866
+ }
1575
1867
  const restoreDormancy = takeGsapRefreshRestore();
1576
- if (!restoreDormancy) return result;
1577
- return { render: (time) => {
1578
- result?.render?.(time);
1579
- restoreDormancy();
1580
- } };
1868
+ return restoreDormancy ? revertAfterMeasure(restoreDormancy, result) : result;
1869
+ };
1870
+ return (self) => {
1871
+ layerHandlerDepth += 1;
1872
+ try {
1873
+ return handle(self);
1874
+ } finally {
1875
+ layerHandlerDepth -= 1;
1876
+ }
1581
1877
  };
1582
1878
  }
1879
+ #watchGsapRefresh() {
1880
+ if (this.#dispatchObserver) {
1881
+ this.#dispatchObserver.takeRecords();
1882
+ return;
1883
+ }
1884
+ const observer = new MutationObserver(() => {});
1885
+ const cls = this.#scrollTriggerClass;
1886
+ const end = () => {
1887
+ observer.disconnect();
1888
+ if (this.#dispatchObserver === observer) this.#dispatchObserver = null;
1889
+ queueMicrotask(() => removeGsapListener(cls, "refresh", end));
1890
+ };
1891
+ observer.observe(document, {
1892
+ subtree: true,
1893
+ childList: true,
1894
+ attributes: true,
1895
+ characterData: true
1896
+ });
1897
+ this.#dispatchObserver = observer;
1898
+ addGsapListener(cls, "refresh", end);
1899
+ queueMicrotask(end);
1900
+ }
1901
+ #remeasureEarlierInGsapRefresh() {
1902
+ const refreshed = refreshedInGsapRefresh ?? new Map();
1903
+ if (!refreshedInGsapRefresh) {
1904
+ refreshedInGsapRefresh = refreshed;
1905
+ queueMicrotask(() => {
1906
+ if (refreshedInGsapRefresh === refreshed) refreshedInGsapRefresh = null;
1907
+ });
1908
+ }
1909
+ refreshed.set(this, this.#outsideReads());
1910
+ refreshed.forEach((reads, other) => {
1911
+ if (other.#destroyed || reads === other.#outsideReads()) return;
1912
+ try {
1913
+ other.#refreshFrom(true);
1914
+ } catch (error) {
1915
+ queueMicrotask(() => {
1916
+ throw error;
1917
+ });
1918
+ }
1919
+ other.#dispatchObserver?.takeRecords();
1920
+ refreshed.set(other, other.#outsideReads());
1921
+ });
1922
+ }
1923
+ #outsideReads() {
1924
+ const reads = [documentTop(this.#rootElement)];
1925
+ if (this.#readsPageHeight) reads.push(measureDocumentHeightWithoutPinRanges());
1926
+ [...this.#layers, ...this.#pinLayers].forEach(({ endTrigger }) => {
1927
+ if (!this.#rootElement.contains(endTrigger)) reads.push(documentTop(endTrigger));
1928
+ });
1929
+ return reads.join(",");
1930
+ }
1583
1931
  #wrapUnwrappedPins() {
1584
1932
  this.#pinLayers.forEach((layer) => {
1585
1933
  if (layer.outer) return;
@@ -1596,16 +1944,14 @@ var StickyScrollTrigger = class {
1596
1944
  range: inner.style.height
1597
1945
  }] : []);
1598
1946
  wrapped.forEach(({ outer, inner }) => {
1599
- outer.style.height = "";
1600
- inner.style.height = "";
1947
+ clearHeightForRead(outer);
1948
+ clearHeightForRead(inner);
1601
1949
  });
1602
1950
  const reserved = wrapped.map(({ outer }) => measureUsedHeight(outer));
1603
1951
  wrapped.forEach(({ outer }, index) => {
1604
- outer.style.height = `${reserved[index]}px`;
1605
- });
1606
- wrapped.forEach(({ inner, range }) => {
1607
- inner.style.height = range;
1952
+ commitHeight(outer, `${reserved[index]}px`);
1608
1953
  });
1954
+ wrapped.forEach(({ inner, range }) => commitHeight(inner, range));
1609
1955
  }
1610
1956
  #unwrapPinLayer(layer) {
1611
1957
  if (!layer.outer) return false;
@@ -1616,10 +1962,16 @@ var StickyScrollTrigger = class {
1616
1962
  return true;
1617
1963
  }
1618
1964
  #resetSceneCoverStickyState() {
1619
- return stripStickyPositions(this.#layers.flatMap(({ wrapper }) => wrapper ? [wrapper] : []));
1965
+ return stripStickyPositions(this.#builtLayers.flatMap(({ wrapper }) => wrapper ? [wrapper] : []));
1620
1966
  }
1621
1967
  #resetPinStickyState() {
1622
- return stripStickyPositions(this.#wrappedPinTriggers());
1968
+ const restores = this.#pinLayers.filter(({ inner }) => inner).map((layer) => ({
1969
+ layer,
1970
+ restore: stripStickyPositions([layer.trigger])
1971
+ }));
1972
+ return () => restores.forEach(({ layer, restore }) => {
1973
+ if (layer.inner) restore();
1974
+ });
1623
1975
  }
1624
1976
  #resetStickyState() {
1625
1977
  const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
@@ -1629,43 +1981,63 @@ var StickyScrollTrigger = class {
1629
1981
  restoreSceneCoverStickyState();
1630
1982
  };
1631
1983
  }
1632
- #resetPinState() {
1633
- const snapshots = this.#pinLayers.map((layer) => ({
1984
+ #refreshGeometry(viewportHeight) {
1985
+ const active = this.#layers.filter((layer) => layer.wrapper !== null);
1986
+ const wrappers = active.flatMap(({ wrapper }) => wrapper ? [wrapper] : []);
1987
+ const savedWrappers = wrappers.map(captureInlinePosition);
1988
+ const pins = this.#pinLayers.map((layer) => ({
1634
1989
  layer,
1635
1990
  position: captureInlinePosition(layer.trigger),
1636
- height: layer.inner ? layer.inner.style.height : ""
1991
+ range: layer.inner ? layer.inner.style.height : ""
1637
1992
  }));
1638
- snapshots.forEach(({ layer }) => {
1639
- resetStickyPosition(layer.trigger);
1640
- if (layer.inner) layer.inner.style.height = "";
1641
- });
1642
- return () => {
1643
- snapshots.forEach(({ layer, position, height }) => {
1644
- restoreInlinePosition(layer.trigger, position);
1645
- if (layer.inner) layer.inner.style.height = height;
1993
+ wrappers.forEach(clearStickyForRead);
1994
+ pins.forEach(({ layer }) => clearStickyForRead(layer.trigger));
1995
+ let stickyTops;
1996
+ let marginTops;
1997
+ try {
1998
+ const measured = active.length ? this.#measureLayers(viewportHeight, active) : null;
1999
+ marginTops = this.#measureScrollMarginTargets(active);
2000
+ stickyTops = measured ? this.#planLayerPositions(viewportHeight, active, measured) : new Map();
2001
+ this.#readsPageHeight = pins.length > 0 || (measured?.measured.some(({ end }) => end.mode === "max") ?? false);
2002
+ } catch (error) {
2003
+ wrappers.forEach((wrapper, i) => commitPosition(wrapper, savedWrappers[i]));
2004
+ pins.forEach(({ layer, position }) => {
2005
+ if (layer.inner) commitPosition(layer.trigger, position);
1646
2006
  });
1647
- };
1648
- }
1649
- #refreshPins(viewportHeight) {
1650
- if (!this.#pinLayers.length) return;
1651
- const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
1652
- const restorePinState = this.#resetPinState();
2007
+ throw error;
2008
+ }
2009
+ let plannedPins = [];
1653
2010
  try {
1654
- this.#refreshPinLayers(viewportHeight, measureDocumentHeightWithoutPinRanges());
2011
+ if (pins.length) {
2012
+ pins.forEach(({ layer }) => {
2013
+ if (layer.inner) clearHeightForRead(layer.inner);
2014
+ });
2015
+ plannedPins = this.#planPinLayers(viewportHeight, measureDocumentHeightWithoutPinRanges());
2016
+ }
1655
2017
  } catch (error) {
1656
- restorePinState();
2018
+ stickyTops.forEach((top, wrapper) => commitSticky(wrapper, top));
2019
+ pins.forEach(({ layer, position, range }) => {
2020
+ if (!layer.inner) return;
2021
+ commitPosition(layer.trigger, position);
2022
+ commitHeight(layer.inner, range);
2023
+ });
1657
2024
  throw error;
1658
- } finally {
1659
- restoreSceneCoverStickyState();
1660
2025
  }
1661
- }
1662
- #refreshPinLayers(viewportHeight, documentHeight) {
1663
- this.#pinLayers.forEach((layer) => {
2026
+ stickyTops.forEach((top, wrapper) => commitSticky(wrapper, top));
2027
+ plannedPins.forEach(({ layer, topPx, range }) => {
1664
2028
  if (!layer.inner) return;
2029
+ commitSticky(layer.trigger, topPx);
2030
+ commitHeight(layer.inner, `${range}px`);
2031
+ });
2032
+ this.#syncScrollMargins(marginTops);
2033
+ }
2034
+ #planPinLayers(viewportHeight, documentHeight) {
2035
+ return this.#pinLayers.flatMap((layer) => {
2036
+ if (!layer.inner) return [];
1665
2037
  const resolvedStart = resolveMaybeFn(layer.start);
1666
2038
  const resolvedEnd = prefixSpacedRelativeEnd(resolvedStart, resolveMaybeFn(layer.end));
1667
2039
  const classifiedEnd = classifyPosition(resolvedEnd);
1668
- if (classifiedEnd.kind === "max") throw new Error(`StickyScrollTrigger: createStickyPin's end "${resolvedEnd}" uses GSAP's 'max' keyword, which isn't supported here: the pin's own spacer height adds to the document's max scroll position, so it would depend on itself. Use a position clause against endTrigger, such as 'top top'.`);
2040
+ if (classifiedEnd.kind === "max") throw new Error(`StickyScrollTrigger: createStickyPin's end "${resolvedEnd}" uses GSAP's 'max' keyword, which isn't supported here. Use a position clause against endTrigger, such as 'top top'.`);
1669
2041
  const triggerTop = documentTop(layer.trigger);
1670
2042
  const triggerHeight = measureUsedHeight(layer.trigger);
1671
2043
  const triggerMarginBottom = parseFloat(getComputedStyle(layer.trigger).marginBottom) || 0;
@@ -1676,38 +2048,39 @@ var StickyScrollTrigger = class {
1676
2048
  const releaseScroll = resolvePinReleaseScroll(layer.endTrigger, classifiedEnd, toScroll(layer.trigger, triggerTop - topPx), viewportHeight, toScroll);
1677
2049
  const height = releaseScroll - (this.#rootElement.contains(layer.trigger) ? dwellConsumedAt(releaseScroll, this.#engagedWindows()) : 0) - triggerTop + topPx + triggerHeight + triggerMarginBottom;
1678
2050
  const room = documentHeight > 0 ? documentHeight - triggerTop : Infinity;
1679
- applyStickyPosition(layer.trigger, topPx);
1680
- layer.inner.style.height = `${Math.max(0, Math.min(height, room))}px`;
2051
+ return [{
2052
+ layer,
2053
+ topPx,
2054
+ range: Math.max(0, Math.min(height, room))
2055
+ }];
1681
2056
  });
1682
2057
  }
1683
- #refreshScenesAndCovers(viewportHeight) {
1684
- if (!this.#layers.length) return;
1685
- const active = this.#layers.filter((layer) => layer.wrapper !== null);
1686
- if (!active.length) return;
1687
- const restoreStickyState = this.#resetSceneCoverStickyState();
1688
- const restorePinStickyState = this.#resetPinStickyState();
1689
- try {
1690
- this.#planLayerPositions(viewportHeight, active);
1691
- } catch (error) {
1692
- restoreStickyState();
1693
- throw error;
1694
- } finally {
1695
- restorePinStickyState();
1696
- }
1697
- }
1698
- #planLayerPositions(viewportHeight, active) {
2058
+ #measureLayers(viewportHeight, active) {
1699
2059
  const structureTop = this.#outermostContainer ? documentTop(this.#outermostContainer) : 0;
2060
+ this.#measuredStructure = {
2061
+ top: structureTop,
2062
+ unbuilds: unbuildCount
2063
+ };
1700
2064
  const indexByTrigger = new Map();
1701
2065
  active.forEach((layer, index) => {
1702
2066
  indexByTrigger.set(layer.trigger, index);
1703
2067
  });
1704
- const measured = active.map((layer, ownIndex) => measureLayer(this.#rootElement, viewportHeight, layer, ownIndex, indexByTrigger));
2068
+ return {
2069
+ structureTop,
2070
+ measured: active.map((layer, ownIndex) => measureLayer(this.#rootElement, viewportHeight, layer, ownIndex, indexByTrigger))
2071
+ };
2072
+ }
2073
+ #planLayerPositions(viewportHeight, active, { structureTop, measured }) {
2074
+ const needsLiveRemeasure = measured.some((measurement) => measurement.end.mode === "clause" && measurement.end.measureLive);
2075
+ const needsMaxRemeasure = measured.some((measurement) => measurement.end.mode === "max");
1705
2076
  let documentMaxScroll = 0;
2077
+ let measureLive = false;
2078
+ const stickyTops = new Map();
1706
2079
  const applyLayers = () => planLayers(measured, {
1707
2080
  viewportHeight,
1708
2081
  structureTop,
1709
2082
  documentMaxScroll,
1710
- measureLiveEndTriggerTop: (index) => documentTop(active[index].endTrigger),
2083
+ measureLiveEndTriggerTop: (index) => measureLive ? documentTop(active[index].endTrigger) : 0,
1711
2084
  onPlanned: (index, plan) => {
1712
2085
  const layer = active[index];
1713
2086
  layer.freezeStart = plan.freezeStart;
@@ -1715,23 +2088,138 @@ var StickyScrollTrigger = class {
1715
2088
  layer.engagedStart = plan.engagedStart;
1716
2089
  layer.engagedEnd = plan.engagedEnd;
1717
2090
  if (!layer.wrapper) return;
1718
- applyStickyPosition(layer.wrapper, plan.stickyTop);
1719
- if (layer.kind === "scene" && layer.padding && plan.paddingHeight !== null) layer.padding.style.height = `${plan.paddingHeight}px`;
2091
+ stickyTops.set(layer.wrapper, plan.stickyTop);
2092
+ if (layer.kind === "scene" && layer.padding && plan.paddingHeight !== null) commitHeight(layer.padding, `${plan.paddingHeight}px`);
1720
2093
  }
1721
2094
  });
2095
+ this.#reevaluateLiveEnds(active, measured, () => {
2096
+ const heights = active.map(() => 0);
2097
+ planLayers(measured, {
2098
+ viewportHeight,
2099
+ structureTop,
2100
+ documentMaxScroll,
2101
+ measureLiveEndTriggerTop: () => 0,
2102
+ onPlanned: (index, plan) => {
2103
+ heights[index] = plan.paddingHeight ?? 0;
2104
+ }
2105
+ });
2106
+ return heights;
2107
+ });
1722
2108
  applyLayers();
1723
- const needsLiveRemeasure = measured.some((measurement) => measurement.end.mode === "clause" && measurement.end.measureLive);
1724
- const needsMaxRemeasure = measured.some((measurement) => measurement.end.mode === "max");
1725
- if (needsMaxRemeasure) documentMaxScroll = measureDocumentMaxScroll(viewportHeight);
2109
+ if (needsMaxRemeasure) documentMaxScroll = Math.max(0, measureDocumentHeightWithoutPinRanges() - viewportHeight);
2110
+ measureLive = true;
1726
2111
  if (needsLiveRemeasure || needsMaxRemeasure) applyLayers();
2112
+ return stickyTops;
2113
+ }
2114
+ #reevaluateLiveEnds(active, measured, planPaddings) {
2115
+ const live = measured.flatMap(({ liveEnd }, index) => liveEnd ? [{
2116
+ index,
2117
+ liveEnd
2118
+ }] : []);
2119
+ if (!live.length) return;
2120
+ const scrollBefore = window.scrollY;
2121
+ try {
2122
+ for (let round = 0; round < LIVE_END_ROUNDS; round += 1) {
2123
+ const planned = planPaddings();
2124
+ let moved = false;
2125
+ live.forEach(({ index, liveEnd }) => {
2126
+ const next = this.#evaluateLiveEnd(active, planned, index, liveEnd, scrollBefore);
2127
+ const current = measured[index].end;
2128
+ if (!next || next.mode !== current.mode) return;
2129
+ if (Math.abs(liveEndValue(next) - liveEndValue(current)) <= LIVE_END_TOLERANCE_PX) return;
2130
+ measured[index] = {
2131
+ ...measured[index],
2132
+ end: next
2133
+ };
2134
+ moved = true;
2135
+ });
2136
+ if (!moved) break;
2137
+ }
2138
+ } finally {
2139
+ scrollBackTo(scrollBefore);
2140
+ }
2141
+ }
2142
+ #evaluateLiveEnd(active, planned, index, liveEnd, scroll) {
2143
+ const spacers = active.flatMap((layer, k) => k < index && layer.kind === "scene" && planned[k] ? [{
2144
+ after: layer.trigger,
2145
+ height: planned[k]
2146
+ }] : []);
2147
+ const setUp = () => {
2148
+ const later = [...armedInstances].filter((other) => other !== this && compareDocumentOrder(this.#rootElement, other.#rootElement) < 0);
2149
+ const paddings = [this, ...later].flatMap((instance) => instance.#layers.flatMap((layer) => layer.kind === "scene" && layer.padding ? [layer.padding] : []));
2150
+ const heights = paddings.map((padding) => padding.style.height);
2151
+ paddings.forEach((padding) => commitHeight(padding, "0px"));
2152
+ const removeSpacers = insertSpacers(spacers);
2153
+ return () => {
2154
+ removeSpacers();
2155
+ paddings.forEach((padding, k) => {
2156
+ if (padding.style.height === "0px") commitHeight(padding, heights[k]);
2157
+ });
2158
+ };
2159
+ };
2160
+ let takeDown = () => {};
2161
+ let holds = 0;
2162
+ const evaluation = {
2163
+ resolved: false,
2164
+ ended: false,
2165
+ outer: liveEvaluation,
2166
+ scroll: liveEvaluation?.scroll ?? scroll,
2167
+ suspend: (resolving) => {
2168
+ if (resolving) evaluation.resolved = true;
2169
+ holds += 1;
2170
+ if (holds === 1) {
2171
+ takeDown();
2172
+ takeDown = () => {};
2173
+ }
2174
+ return () => {
2175
+ holds -= 1;
2176
+ if (holds === 0 && !evaluation.ended) takeDown = setUp();
2177
+ };
2178
+ }
2179
+ };
2180
+ try {
2181
+ takeDown = setUp();
2182
+ liveEvaluation = evaluation;
2183
+ const next = liveEnd();
2184
+ return evaluation.resolved ? null : next;
2185
+ } finally {
2186
+ evaluation.ended = true;
2187
+ liveEvaluation = evaluation.outer;
2188
+ takeDown();
2189
+ }
1727
2190
  }
1728
2191
  refresh() {
1729
- if (this.#destroyed) return;
2192
+ this.#refreshFrom(false);
2193
+ }
2194
+ #refreshFrom(refreshInit) {
2195
+ if (this.#depth > 0 && !this.#dirty) {
2196
+ if (!refreshInit) {
2197
+ this.#measureAgain = true;
2198
+ return;
2199
+ }
2200
+ if (this.#refreshInitNestedUsed) return;
2201
+ this.#refreshInitNestedUsed = true;
2202
+ }
2203
+ this.#runRefresh();
2204
+ }
2205
+ #runRefresh() {
2206
+ if (this.#depth > 0) this.#measureAgain = true;
2207
+ if (this.#destroyed || !this.#armed || pendingDisarms.has(this)) return;
1730
2208
  let failure = null;
2209
+ const position = this.#keepContentPending ? this.#naturalScrollTop(this.#builtLayers) : null;
2210
+ this.#keepContentPending = false;
2211
+ this.#depth += 1;
1731
2212
  try {
1732
2213
  this.#refreshLayout();
2214
+ if (this.#depth === 1 && this.#measureAgain && !this.#destroyed && this.#armed && !pendingDisarms.has(this)) this.#refreshLayout();
1733
2215
  } catch (error) {
1734
2216
  failure = { error };
2217
+ } finally {
2218
+ this.#depth -= 1;
2219
+ if (this.#depth === 0) {
2220
+ this.#refreshInitNestedUsed = false;
2221
+ this.#measureAgain = false;
2222
+ }
1735
2223
  }
1736
2224
  try {
1737
2225
  rebuildDormancy(this.#scrollTriggerClass);
@@ -1741,8 +2229,50 @@ var StickyScrollTrigger = class {
1741
2229
  throw error;
1742
2230
  });
1743
2231
  }
2232
+ this.#scrollMarginSync?.applyRamps();
2233
+ if (!failure && position !== null) this.#keepContent(position);
1744
2234
  if (failure) throw failure.error;
1745
2235
  }
2236
+ #naturalScrollTop(layers) {
2237
+ const measured = this.#measuredStructure;
2238
+ const moved = measured && this.#outermostContainer && measured.unbuilds !== unbuildCount ? documentTop(this.#outermostContainer) - measured.top : 0;
2239
+ const scroll = (scrollRecord(this.#scrollTriggerClass)?.read() ?? window.scrollY) - moved;
2240
+ const consumed = new Map();
2241
+ layers.forEach((layer) => {
2242
+ if (layer.kind !== "scene") return;
2243
+ consumed.set(layer.trigger, scroll > layer.engagedEnd ? Infinity : dwellConsumedAt(scroll, this.#engagedWindows([layer])));
2244
+ });
2245
+ return {
2246
+ natural: scroll - dwellConsumedAt(scroll, this.#engagedWindows(layers)) + moved,
2247
+ consumed
2248
+ };
2249
+ }
2250
+ #keepContent(position, cls = this.#scrollTriggerClass) {
2251
+ const target = this.#keptScrollTop(position);
2252
+ const record = scrollRecord(this.#scrollTriggerClass);
2253
+ if (record) {
2254
+ record.write(target);
2255
+ return;
2256
+ }
2257
+ if (isRefreshing(cls)) return;
2258
+ if (Math.abs(window.scrollY - target) >= .5) window.scrollTo({
2259
+ top: Math.round(target),
2260
+ behavior: "instant"
2261
+ });
2262
+ syncScrollCache(cls);
2263
+ }
2264
+ #keptScrollTop({ natural, consumed }) {
2265
+ let earlierDwell = 0;
2266
+ let target = natural;
2267
+ this.#builtLayers.flatMap((layer) => layer.kind === "scene" ? [layer] : []).sort((a, b) => a.engagedStart - b.engagedStart).forEach((layer) => {
2268
+ const dwell = layer.engagedEnd - layer.engagedStart;
2269
+ const before = consumed.get(layer.trigger);
2270
+ if (before !== void 0) target += Math.min(before, dwell);
2271
+ else if (layer.engagedStart < natural + earlierDwell - .05) target += dwell;
2272
+ earlierDwell += dwell;
2273
+ });
2274
+ return target;
2275
+ }
1746
2276
  #refreshLayout() {
1747
2277
  if (this.#dirty || !this.#built || isDomOrderStale(this.#layers)) {
1748
2278
  this.#unbuild();
@@ -1756,9 +2286,7 @@ var StickyScrollTrigger = class {
1756
2286
  this.#liftCovers();
1757
2287
  }
1758
2288
  const viewportHeight = this.#layers.length || this.#pinLayers.length ? measureViewportHeight() : 0;
1759
- this.#refreshScenesAndCovers(viewportHeight);
1760
- this.#refreshPins(viewportHeight);
1761
- this.#syncScrollMargins();
2289
+ this.#refreshGeometry(viewportHeight);
1762
2290
  }
1763
2291
  #coverLayers() {
1764
2292
  return this.#layers.filter((layer) => layer.kind === "cover");
@@ -1772,15 +2300,21 @@ var StickyScrollTrigger = class {
1772
2300
  this.#coverRestoreByLayer.set(layer, liftAboveStickyWrapper(pin?.outer ?? layer.cover));
1773
2301
  });
1774
2302
  }
1775
- #syncScrollMargins() {
1776
- this.#scrollMarginSync.sync(this.#engagedWindows(), this.#outermostContainer, (targets) => {
1777
- if (!targets.length) return [];
1778
- const restoreStickyState = this.#resetStickyState();
1779
- const tops = targets.map((target) => documentTop(target));
1780
- restoreStickyState();
1781
- return tops;
2303
+ #syncScrollMargins(tops) {
2304
+ this.#scrollMarginSync?.sync(this.#engagedWindows(), this.#outermostContainer, (targets) => {
2305
+ const late = targets.filter((target) => !tops.has(target));
2306
+ if (late.length) {
2307
+ const restoreStickyState = this.#resetStickyState();
2308
+ late.forEach((target) => tops.set(target, documentTop(target)));
2309
+ restoreStickyState();
2310
+ }
2311
+ return targets.map((target) => tops.get(target));
1782
2312
  });
1783
2313
  }
2314
+ #measureScrollMarginTargets(active) {
2315
+ const targets = this.#scrollMarginSync && active.some(({ kind }) => kind === "scene") ? this.#scrollMarginSync.targets() : [];
2316
+ return new Map(targets.map((target) => [target, documentTop(target)]));
2317
+ }
1784
2318
  #assertNoExcludedVars(rest, context) {
1785
2319
  const found = EXCLUDED_VAR_KEYS.filter((key) => key in rest);
1786
2320
  if (found.length === 0) return;
@@ -1802,8 +2336,10 @@ var StickyScrollTrigger = class {
1802
2336
  if (this.#destroyed) throw new Error("StickyScrollTrigger: cannot register a new layer after destroy() has been called.");
1803
2337
  this.#assertTriggerAvailable(this.#layers, layer.trigger, `StickyScrollTrigger: ${describeElement(layer.trigger)} is already registered as a trigger for another layer. Each element can be used once per controller instance, across createStickyTrigger and createOverlapScroll: reusing one makes endTrigger resolution ambiguous.`);
1804
2338
  this.#assertTriggerAvailable(this.#pinLayers, layer.trigger, `StickyScrollTrigger: ${describeElement(layer.trigger)} is already registered as a pin trigger (createStickyPin). Using the same element as both a Scene/Cover trigger and a pin trigger wraps it twice and produces conflicting position:sticky behavior.`);
2339
+ this.#arm();
1805
2340
  this.#layers.push(layer);
1806
2341
  this.#dirty = true;
2342
+ if (this.#depth > 0) this.#measureAgain = true;
1807
2343
  return {
1808
2344
  ...rest,
1809
2345
  trigger: layer.trigger,
@@ -1812,9 +2348,14 @@ var StickyScrollTrigger = class {
1812
2348
  invalidateOnRefresh: rest.invalidateOnRefresh ?? true,
1813
2349
  onKill: (self) => {
1814
2350
  this.#captureScrollTriggerClass(self);
2351
+ if (!this.#layers.includes(layer)) {
2352
+ onKill?.(self);
2353
+ return;
2354
+ }
1815
2355
  removeItem(this.#layers, layer);
1816
2356
  this.#dirty = true;
1817
2357
  this.#scheduleRebuild();
2358
+ this.#disarmIfEmpty();
1818
2359
  onKill?.(self);
1819
2360
  },
1820
2361
  onRefreshInit: this.#createAutoRefreshHandler(rest.onRefreshInit)
@@ -1822,6 +2363,7 @@ var StickyScrollTrigger = class {
1822
2363
  }
1823
2364
  createStickyTrigger({ trigger: triggerInput, start = "0 0", end = "100% 0", endTrigger: endTriggerInput, onKill, ...rest }) {
1824
2365
  this.#assertNoExcludedVars(rest, "createStickyTrigger");
2366
+ this.#flushOverlappingDisarms();
1825
2367
  const trigger = resolveElement(triggerInput, "createStickyTrigger");
1826
2368
  this.#assertTriggerInsideRoot(trigger, "createStickyTrigger");
1827
2369
  const endTrigger = resolveEndTrigger(trigger, endTriggerInput, "createStickyTrigger");
@@ -1842,6 +2384,7 @@ var StickyScrollTrigger = class {
1842
2384
  }
1843
2385
  createOverlapScroll({ trigger: triggerInput, cover, start = "bottom bottom", end = null, endTrigger: endTriggerInput, onKill, ...rest }) {
1844
2386
  this.#assertNoExcludedVars(rest, "createOverlapScroll");
2387
+ this.#flushOverlappingDisarms();
1845
2388
  const trigger = resolveElement(triggerInput, "createOverlapScroll");
1846
2389
  this.#assertTriggerInsideRoot(trigger, "createOverlapScroll");
1847
2390
  const endTrigger = resolveEndTrigger(trigger, endTriggerInput, "createOverlapScroll");
@@ -1863,6 +2406,7 @@ var StickyScrollTrigger = class {
1863
2406
  };
1864
2407
  const vars = this.#registerLayer(layer, (self) => {
1865
2408
  this.#coverRestoreByLayer.get(layer)?.();
2409
+ unbuildCover(layer);
1866
2410
  onKill?.(self);
1867
2411
  }, rest);
1868
2412
  this.#coverRestoreByLayer.set(layer, liftAboveStickyWrapper(coverElement));
@@ -1870,6 +2414,7 @@ var StickyScrollTrigger = class {
1870
2414
  }
1871
2415
  createStickyPin({ trigger: triggerInput, start, top, endTrigger: endTriggerInput, end = "bottom top", onKill, ...rest }) {
1872
2416
  this.#assertNoExcludedVars(rest, "createStickyPin");
2417
+ this.#flushOverlappingDisarms();
1873
2418
  if (this.#destroyed) throw new Error("StickyScrollTrigger: cannot register a new pin after destroy() has been called.");
1874
2419
  if (start !== void 0 && top !== void 0) throw new Error("StickyScrollTrigger: createStickyPin accepts either start or top, not both (top: 20 is start: 'top 20px'). Use top for a plain px distance from the viewport's top edge, start for anything else.");
1875
2420
  const trigger = resolveElement(triggerInput, "createStickyPin");
@@ -1886,7 +2431,9 @@ var StickyScrollTrigger = class {
1886
2431
  endTrigger,
1887
2432
  end
1888
2433
  };
2434
+ this.#arm();
1889
2435
  this.#pinLayers.push(layer);
2436
+ if (this.#depth > 0) this.#measureAgain = true;
1890
2437
  return {
1891
2438
  ...rest,
1892
2439
  trigger,
@@ -1894,12 +2441,21 @@ var StickyScrollTrigger = class {
1894
2441
  this.#captureScrollTriggerClass(self);
1895
2442
  removeItem(this.#pinLayers, layer);
1896
2443
  if (this.#unwrapPinLayer(layer)) this.#scheduleRebuild();
2444
+ this.#disarmIfEmpty();
1897
2445
  onKill?.(self);
1898
2446
  },
1899
2447
  onRefreshInit: this.#createAutoRefreshHandler(rest.onRefreshInit)
1900
2448
  };
1901
2449
  }
1902
2450
  resolveScrollPosition(elementInput, position) {
2451
+ const resume = liveEvaluation && suspendLiveEvaluations(liveEvaluation, true);
2452
+ try {
2453
+ return this.#resolveScrollPosition(elementInput, position);
2454
+ } finally {
2455
+ resume?.();
2456
+ }
2457
+ }
2458
+ #resolveScrollPosition(elementInput, position) {
1903
2459
  const element = resolveElement(elementInput, "resolveScrollPosition");
1904
2460
  const resolved = resolveMaybeFn(position);
1905
2461
  const viewportHeight = measureViewportHeight();
@@ -1922,8 +2478,8 @@ var StickyScrollTrigger = class {
1922
2478
  if (!this.#rootElement.contains(element)) return reachedAt;
1923
2479
  return reachedAt + dwellBeforeReach(reachedAt, this.#engagedWindows());
1924
2480
  }
1925
- #engagedWindows() {
1926
- return this.#layers.flatMap((layer) => layer.kind === "scene" ? [{
2481
+ #engagedWindows(layers = this.#builtLayers) {
2482
+ return layers.flatMap((layer) => layer.kind === "scene" ? [{
1927
2483
  freezeStart: layer.engagedStart,
1928
2484
  freezeEnd: layer.engagedEnd
1929
2485
  }] : []);
@@ -1939,6 +2495,7 @@ var StickyScrollTrigger = class {
1939
2495
  }
1940
2496
  createResolvedTrigger({ trigger: triggerInput, start = "top bottom", end = "bottom top", endTrigger: endTriggerInput, ...rest }) {
1941
2497
  this.#assertNoExcludedVars(rest, "createResolvedTrigger");
2498
+ this.#flushOverlappingDisarms();
1942
2499
  const trigger = resolveElement(triggerInput, "createResolvedTrigger");
1943
2500
  const endTrigger = resolveEndTrigger(trigger, endTriggerInput, "createResolvedTrigger");
1944
2501
  return {
@@ -1955,13 +2512,17 @@ var StickyScrollTrigger = class {
1955
2512
  }
1956
2513
  destroy() {
1957
2514
  if (this.#destroyed) return;
2515
+ runEach(() => this.#flushPendingDisarmForRevert(), () => this.#tearDown());
2516
+ }
2517
+ #tearDown() {
2518
+ if (this.#restTimer !== null) clearTimeout(this.#restTimer);
2519
+ this.#restTimer = null;
1958
2520
  this.#destroyed = true;
1959
- unregisterDormancyClient(this.#dormancyClient);
1960
- this.#scrollMarginSync.restore();
1961
- this.#restoreCoverLifts();
1962
- this.#unbuild();
2521
+ const run = this.#deferredRun;
2522
+ this.#deferredRun = null;
2523
+ run?.();
2524
+ if (this.#armed) this.#disarm();
1963
2525
  this.#layers.length = 0;
1964
- this.#builtLayers = [];
1965
2526
  this.#pinLayers.forEach((layer) => this.#unwrapPinLayer(layer));
1966
2527
  this.#pinLayers.length = 0;
1967
2528
  this.#scrollTriggerClass = null;