sticky-scroll-trigger 0.12.0 → 0.13.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.13.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
@@ -1287,7 +1287,6 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
1287
1287
  if (usesJsRamp) {
1288
1288
  jsRamps = ramps;
1289
1289
  jsHost = host;
1290
- applyJsRamp();
1291
1290
  return;
1292
1291
  }
1293
1292
  if (!sheet) {
@@ -1333,6 +1332,9 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
1333
1332
  });
1334
1333
  written = next;
1335
1334
  },
1335
+ applyRamps() {
1336
+ applyJsRamp();
1337
+ },
1336
1338
  restore() {
1337
1339
  if (usesJsRamp) window.removeEventListener("scroll", applyJsRamp);
1338
1340
  release();
@@ -1362,6 +1364,11 @@ const buildStructure = (rootElement, layers) => {
1362
1364
  }
1363
1365
  return outermost;
1364
1366
  };
1367
+ const unbuildCover = (layer) => {
1368
+ if (!layer.wrapper) return;
1369
+ unwrapCover(layer.wrapper);
1370
+ layer.wrapper = null;
1371
+ };
1365
1372
  const unbuildStructure = (rootElement, layers, outermostContainer) => {
1366
1373
  if (outermostContainer) {
1367
1374
  outermostContainer.parentNode?.insertBefore(rootElement, outermostContainer);
@@ -1369,15 +1376,13 @@ const unbuildStructure = (rootElement, layers, outermostContainer) => {
1369
1376
  }
1370
1377
  for (let i = layers.length - 1; i >= 0; i -= 1) {
1371
1378
  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") {
1379
+ if (layer.kind === "cover") unbuildCover(layer);
1380
+ else {
1381
+ layer.wrapper = null;
1377
1382
  layer.container = null;
1378
1383
  layer.padding = null;
1379
1384
  }
1380
- });
1385
+ }
1381
1386
  };
1382
1387
  const resolveEndSpec = (rootElement, viewportHeight, layer, endResolved, ownIndex, endTriggerIndex) => {
1383
1388
  if (endResolved === null) return { mode: "auto" };
@@ -1492,19 +1497,45 @@ const removeItem = (list, item) => {
1492
1497
  if (index !== -1) list.splice(index, 1);
1493
1498
  };
1494
1499
  const hasDuplicateTrigger = (list, trigger) => list.some((existing) => existing.trigger === trigger);
1500
+ const pendingDisarms = new Set();
1501
+ const pendingKeeps = new Set();
1502
+ let unbuildCount = 0;
1503
+ const REST_POLL_MS = 100;
1504
+ const runEach = (...steps) => {
1505
+ let failure = null;
1506
+ steps.forEach((step) => {
1507
+ try {
1508
+ step();
1509
+ } catch (error) {
1510
+ if (!failure) failure = { error };
1511
+ else queueMicrotask(() => {
1512
+ throw error;
1513
+ });
1514
+ }
1515
+ });
1516
+ if (failure) throw failure.error;
1517
+ };
1495
1518
  var StickyScrollTrigger = class {
1496
1519
  #rootElement;
1497
1520
  #layers = [];
1498
1521
  #builtLayers = [];
1522
+ #measuredStructure = null;
1499
1523
  #coverRestoreByLayer = new WeakMap();
1500
1524
  #built = false;
1501
1525
  #dirty = false;
1502
1526
  #outermostContainer = null;
1503
1527
  #destroyed = false;
1504
1528
  #rebuildScheduled = false;
1529
+ #keepContentPending = false;
1530
+ #deferredRun = null;
1531
+ #restTimer = null;
1532
+ #pendingKeep = null;
1505
1533
  #scrollTriggerClass = null;
1506
1534
  #pinLayers = [];
1507
- #scrollMarginSync;
1535
+ #scrollMarginSync = null;
1536
+ #scrollMarginTargets;
1537
+ #armed = false;
1538
+ #dispatchObserver = null;
1508
1539
  #dormancyClient = null;
1509
1540
  constructor(root, options = {}) {
1510
1541
  this.#rootElement = resolveRoot(root);
@@ -1520,14 +1551,101 @@ var StickyScrollTrigger = class {
1520
1551
  "always",
1521
1552
  "off"
1522
1553
  ].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);
1554
+ this.#scrollMarginTargets = scrollMarginTargets;
1555
+ if (optimization === "always" || optimization === "auto" && isWebKit()) this.#dormancyClient = {
1556
+ mode: optimization,
1557
+ ownedElements: () => this.#ownedStickyElements()
1558
+ };
1559
+ }
1560
+ #arm() {
1561
+ if (pendingDisarms.delete(this)) this.#keepContentPending = false;
1562
+ if (this.#armed) return;
1563
+ this.#armed = true;
1564
+ pendingKeeps.forEach((keep) => {
1565
+ if (keep.owner.#overlaps(this)) keep.cancelled = true;
1566
+ });
1567
+ this.#scrollMarginSync = createScrollMarginSync(this.#rootElement, this.#scrollMarginTargets);
1568
+ if (this.#dormancyClient) registerDormancyClient(this.#dormancyClient);
1569
+ }
1570
+ #disarmIfEmpty() {
1571
+ if (this.#armed && !this.#destroyed && !this.#layers.length && !this.#pinLayers.length) {
1572
+ if (pendingDisarms.has(this)) return;
1573
+ if (!this.#scrollTriggerClass?.isRefreshing && this.#scrolling()) {
1574
+ pendingDisarms.add(this);
1575
+ queueMicrotask(() => this.#settleWhenAtRest());
1576
+ return;
1577
+ }
1578
+ this.#disarmKeepingContent(true, true);
1579
+ }
1580
+ }
1581
+ #flushOverlappingDisarms() {
1582
+ if (this.#destroyed) return;
1583
+ pendingDisarms.forEach((other) => {
1584
+ if (other !== this && other.#overlaps(this)) other.#flushPendingDisarmForRevert();
1585
+ });
1586
+ }
1587
+ #scrolling() {
1588
+ const cls = this.#scrollTriggerClass;
1589
+ return Boolean(cls?.isScrolling?.() || cls?.isUpdating === true);
1590
+ }
1591
+ #disarmKeepingContent(keepContent, onlyAtRest = false) {
1592
+ const position = keepContent && this.#built ? this.#naturalScrollTop(this.#builtLayers) : null;
1593
+ this.#keepContentPending = false;
1594
+ this.#disarm();
1595
+ if (!position) return;
1596
+ if (this.#gsapScrollRecord()) {
1597
+ this.#keepContent(position);
1598
+ return;
1599
+ }
1600
+ if (this.#pendingKeep) pendingKeeps.delete(this.#pendingKeep);
1601
+ this.#pendingKeep = {
1602
+ owner: this,
1603
+ position,
1604
+ cls: this.#scrollTriggerClass,
1605
+ onlyAtRest,
1606
+ cancelled: false
1607
+ };
1608
+ pendingKeeps.add(this.#pendingKeep);
1609
+ queueMicrotask(() => this.#applyPendingKeep());
1610
+ }
1611
+ #applyPendingKeep() {
1612
+ const keep = this.#pendingKeep;
1613
+ if (!keep) return;
1614
+ this.#pendingKeep = null;
1615
+ pendingKeeps.delete(keep);
1616
+ if (keep.cancelled || keep.onlyAtRest && keep.cls?.isScrolling?.()) return;
1617
+ this.#keepContent(keep.position, keep.cls);
1618
+ }
1619
+ #overlaps(other) {
1620
+ return this.#rootElement.contains(other.#rootElement) || other.#rootElement.contains(this.#rootElement);
1621
+ }
1622
+ #settleWhenAtRest() {
1623
+ if (this.#destroyed || this.#restTimer !== null) return;
1624
+ if (this.#scrollTriggerClass?.isScrolling?.()) {
1625
+ this.#restTimer = setTimeout(() => {
1626
+ this.#restTimer = null;
1627
+ this.#settleWhenAtRest();
1628
+ }, REST_POLL_MS);
1629
+ return;
1530
1630
  }
1631
+ const run = this.#deferredRun;
1632
+ this.#deferredRun = null;
1633
+ runEach(() => this.#flushPendingDisarm(), () => run?.());
1634
+ }
1635
+ #flushPendingDisarm(keepContent = true, onlyAtRest = false) {
1636
+ if (pendingDisarms.delete(this) && !this.#destroyed && !this.#layers.length && !this.#pinLayers.length) this.#disarmKeepingContent(keepContent, onlyAtRest);
1637
+ }
1638
+ #flushPendingDisarmForRevert() {
1639
+ this.#flushPendingDisarm(!this.#scrollTriggerClass?.isScrolling?.(), true);
1640
+ }
1641
+ #disarm() {
1642
+ this.#armed = false;
1643
+ unregisterDormancyClient(this.#dormancyClient);
1644
+ this.#scrollMarginSync?.restore();
1645
+ this.#scrollMarginSync = null;
1646
+ this.#restoreCoverLifts();
1647
+ this.#unbuild();
1648
+ this.#builtLayers = [];
1531
1649
  }
1532
1650
  #ownedStickyElements() {
1533
1651
  return [...this.#builtLayers.flatMap((layer) => layer.wrapper ? [layer.wrapper] : []), ...this.#wrappedPinTriggers()];
@@ -1538,6 +1656,8 @@ var StickyScrollTrigger = class {
1538
1656
  #unbuild() {
1539
1657
  if (!this.#built) return;
1540
1658
  unbuildStructure(this.#rootElement, this.#builtLayers, this.#outermostContainer);
1659
+ unbuildCount += 1;
1660
+ this.#measuredStructure = null;
1541
1661
  this.#outermostContainer = null;
1542
1662
  this.#built = false;
1543
1663
  }
@@ -1547,14 +1667,48 @@ var StickyScrollTrigger = class {
1547
1667
  this.#built = true;
1548
1668
  this.#dirty = false;
1549
1669
  }
1670
+ #catchUp() {
1671
+ this.#flushPendingDisarm();
1672
+ this.refresh();
1673
+ this.#applyPendingKeep();
1674
+ }
1550
1675
  #scheduleRebuild() {
1551
- if (this.#rebuildScheduled || this.#destroyed) return;
1676
+ if (this.#destroyed) return;
1677
+ if (this.#built) this.#keepContentPending = true;
1678
+ if (this.#rebuildScheduled) return;
1552
1679
  this.#rebuildScheduled = true;
1553
- queueMicrotask(() => {
1680
+ const cls = this.#scrollTriggerClass;
1681
+ const onRefreshInit = () => {
1682
+ if (!this.#rebuildScheduled || this.#destroyed) return void 0;
1683
+ try {
1684
+ this.#catchUp();
1685
+ } catch (error) {
1686
+ queueMicrotask(() => {
1687
+ throw error;
1688
+ });
1689
+ } finally {
1690
+ this.#rebuildScheduled = false;
1691
+ }
1692
+ const restoreDormancy = takeGsapRefreshRestore();
1693
+ return restoreDormancy ? { render: () => restoreDormancy() } : void 0;
1694
+ };
1695
+ cls?.addEventListener?.("refreshInit", onRefreshInit);
1696
+ const run = () => {
1697
+ cls?.removeEventListener?.("refreshInit", onRefreshInit);
1698
+ if (!this.#rebuildScheduled) return;
1554
1699
  this.#rebuildScheduled = false;
1555
1700
  if (this.#destroyed) return;
1556
- this.refresh();
1701
+ this.#catchUp();
1557
1702
  if (typeof this.#scrollTriggerClass?.refresh === "function") this.#scrollTriggerClass.refresh();
1703
+ };
1704
+ queueMicrotask(() => {
1705
+ if (this.#rebuildScheduled && !this.#destroyed && cls?.isScrolling?.()) {
1706
+ const earlier = this.#deferredRun;
1707
+ this.#deferredRun = earlier ? () => runEach(earlier, run) : run;
1708
+ this.#settleWhenAtRest();
1709
+ return;
1710
+ }
1711
+ run();
1558
1712
  });
1559
1713
  }
1560
1714
  #captureScrollTriggerClass(self) {
@@ -1565,13 +1719,16 @@ var StickyScrollTrigger = class {
1565
1719
  return (self) => {
1566
1720
  this.#captureScrollTriggerClass(self);
1567
1721
  const result = userOnRefreshInit?.(self);
1722
+ const inGsapRefresh = this.#scrollTriggerClass?.isRefreshing === true;
1723
+ const unchanged = inGsapRefresh && !userOnRefreshInit && this.#dispatchObserver !== null && this.#dispatchObserver.takeRecords().length === 0;
1568
1724
  try {
1569
- this.refresh();
1725
+ if (!unchanged) this.refresh();
1570
1726
  } catch (error) {
1571
1727
  queueMicrotask(() => {
1572
1728
  throw error;
1573
1729
  });
1574
1730
  }
1731
+ if (inGsapRefresh) this.#watchGsapRefresh();
1575
1732
  const restoreDormancy = takeGsapRefreshRestore();
1576
1733
  if (!restoreDormancy) return result;
1577
1734
  return { render: (time) => {
@@ -1580,6 +1737,28 @@ var StickyScrollTrigger = class {
1580
1737
  } };
1581
1738
  };
1582
1739
  }
1740
+ #watchGsapRefresh() {
1741
+ if (this.#dispatchObserver) {
1742
+ this.#dispatchObserver.takeRecords();
1743
+ return;
1744
+ }
1745
+ const observer = new MutationObserver(() => {});
1746
+ const cls = this.#scrollTriggerClass;
1747
+ const end = () => {
1748
+ observer.disconnect();
1749
+ if (this.#dispatchObserver === observer) this.#dispatchObserver = null;
1750
+ queueMicrotask(() => cls?.removeEventListener?.("refresh", end));
1751
+ };
1752
+ observer.observe(document, {
1753
+ subtree: true,
1754
+ childList: true,
1755
+ attributes: true,
1756
+ characterData: true
1757
+ });
1758
+ this.#dispatchObserver = observer;
1759
+ cls?.addEventListener?.("refresh", end);
1760
+ queueMicrotask(end);
1761
+ }
1583
1762
  #wrapUnwrappedPins() {
1584
1763
  this.#pinLayers.forEach((layer) => {
1585
1764
  if (layer.outer) return;
@@ -1616,7 +1795,7 @@ var StickyScrollTrigger = class {
1616
1795
  return true;
1617
1796
  }
1618
1797
  #resetSceneCoverStickyState() {
1619
- return stripStickyPositions(this.#layers.flatMap(({ wrapper }) => wrapper ? [wrapper] : []));
1798
+ return stripStickyPositions(this.#builtLayers.flatMap(({ wrapper }) => wrapper ? [wrapper] : []));
1620
1799
  }
1621
1800
  #resetPinStickyState() {
1622
1801
  return stripStickyPositions(this.#wrappedPinTriggers());
@@ -1665,7 +1844,7 @@ var StickyScrollTrigger = class {
1665
1844
  const resolvedStart = resolveMaybeFn(layer.start);
1666
1845
  const resolvedEnd = prefixSpacedRelativeEnd(resolvedStart, resolveMaybeFn(layer.end));
1667
1846
  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'.`);
1847
+ 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
1848
  const triggerTop = documentTop(layer.trigger);
1670
1849
  const triggerHeight = measureUsedHeight(layer.trigger);
1671
1850
  const triggerMarginBottom = parseFloat(getComputedStyle(layer.trigger).marginBottom) || 0;
@@ -1697,12 +1876,17 @@ var StickyScrollTrigger = class {
1697
1876
  }
1698
1877
  #planLayerPositions(viewportHeight, active) {
1699
1878
  const structureTop = this.#outermostContainer ? documentTop(this.#outermostContainer) : 0;
1879
+ this.#measuredStructure = {
1880
+ top: structureTop,
1881
+ unbuilds: unbuildCount
1882
+ };
1700
1883
  const indexByTrigger = new Map();
1701
1884
  active.forEach((layer, index) => {
1702
1885
  indexByTrigger.set(layer.trigger, index);
1703
1886
  });
1704
1887
  const measured = active.map((layer, ownIndex) => measureLayer(this.#rootElement, viewportHeight, layer, ownIndex, indexByTrigger));
1705
1888
  let documentMaxScroll = 0;
1889
+ const stickyTops = new Map();
1706
1890
  const applyLayers = () => planLayers(measured, {
1707
1891
  viewportHeight,
1708
1892
  structureTop,
@@ -1715,7 +1899,7 @@ var StickyScrollTrigger = class {
1715
1899
  layer.engagedStart = plan.engagedStart;
1716
1900
  layer.engagedEnd = plan.engagedEnd;
1717
1901
  if (!layer.wrapper) return;
1718
- applyStickyPosition(layer.wrapper, plan.stickyTop);
1902
+ stickyTops.set(layer.wrapper, plan.stickyTop);
1719
1903
  if (layer.kind === "scene" && layer.padding && plan.paddingHeight !== null) layer.padding.style.height = `${plan.paddingHeight}px`;
1720
1904
  }
1721
1905
  });
@@ -1724,10 +1908,13 @@ var StickyScrollTrigger = class {
1724
1908
  const needsMaxRemeasure = measured.some((measurement) => measurement.end.mode === "max");
1725
1909
  if (needsMaxRemeasure) documentMaxScroll = measureDocumentMaxScroll(viewportHeight);
1726
1910
  if (needsLiveRemeasure || needsMaxRemeasure) applyLayers();
1911
+ stickyTops.forEach((top, wrapper) => applyStickyPosition(wrapper, top));
1727
1912
  }
1728
1913
  refresh() {
1729
- if (this.#destroyed) return;
1914
+ if (this.#destroyed || !this.#armed || pendingDisarms.has(this)) return;
1730
1915
  let failure = null;
1916
+ const position = this.#keepContentPending ? this.#naturalScrollTop(this.#builtLayers) : null;
1917
+ this.#keepContentPending = false;
1731
1918
  try {
1732
1919
  this.#refreshLayout();
1733
1920
  } catch (error) {
@@ -1741,8 +1928,58 @@ var StickyScrollTrigger = class {
1741
1928
  throw error;
1742
1929
  });
1743
1930
  }
1931
+ this.#scrollMarginSync?.applyRamps();
1932
+ if (!failure && position !== null) this.#keepContent(position);
1744
1933
  if (failure) throw failure.error;
1745
1934
  }
1935
+ #gsapScrollRecord() {
1936
+ if (!this.#scrollTriggerClass?.isRefreshing) return null;
1937
+ const scrollFunc = this.#scrollTriggerClass.getScrollFunc?.(window);
1938
+ return scrollFunc && typeof scrollFunc.rec === "number" && scrollFunc.rec ? scrollFunc : null;
1939
+ }
1940
+ #naturalScrollTop(layers) {
1941
+ const measured = this.#measuredStructure;
1942
+ const moved = measured && this.#outermostContainer && measured.unbuilds !== unbuildCount ? documentTop(this.#outermostContainer) - measured.top : 0;
1943
+ const scroll = (this.#gsapScrollRecord()?.rec ?? window.scrollY) - moved;
1944
+ const consumed = new Map();
1945
+ layers.forEach((layer) => {
1946
+ if (layer.kind !== "scene") return;
1947
+ consumed.set(layer.trigger, scroll > layer.engagedEnd ? Infinity : dwellConsumedAt(scroll, this.#engagedWindows([layer])));
1948
+ });
1949
+ return {
1950
+ natural: scroll - dwellConsumedAt(scroll, this.#engagedWindows(layers)) + moved,
1951
+ consumed
1952
+ };
1953
+ }
1954
+ #keepContent(position, cls = this.#scrollTriggerClass) {
1955
+ const target = this.#keptScrollTop(position);
1956
+ const record = this.#gsapScrollRecord();
1957
+ if (record) {
1958
+ record.rec = target;
1959
+ return;
1960
+ }
1961
+ if (cls?.isRefreshing) return;
1962
+ if (Math.abs(window.scrollY - target) >= .5) window.scrollTo({
1963
+ top: Math.round(target),
1964
+ behavior: "instant"
1965
+ });
1966
+ const scrollFunc = cls?.getScrollFunc?.(window);
1967
+ if (typeof scrollFunc !== "function") return;
1968
+ const cached = scrollFunc();
1969
+ if (typeof cached !== "number" || Math.abs(cached - window.scrollY) >= .5) scrollFunc(window.scrollY);
1970
+ }
1971
+ #keptScrollTop({ natural, consumed }) {
1972
+ let earlierDwell = 0;
1973
+ let target = natural;
1974
+ this.#builtLayers.flatMap((layer) => layer.kind === "scene" ? [layer] : []).sort((a, b) => a.engagedStart - b.engagedStart).forEach((layer) => {
1975
+ const dwell = layer.engagedEnd - layer.engagedStart;
1976
+ const before = consumed.get(layer.trigger);
1977
+ if (before !== void 0) target += Math.min(before, dwell);
1978
+ else if (layer.engagedStart < natural + earlierDwell - .05) target += dwell;
1979
+ earlierDwell += dwell;
1980
+ });
1981
+ return target;
1982
+ }
1746
1983
  #refreshLayout() {
1747
1984
  if (this.#dirty || !this.#built || isDomOrderStale(this.#layers)) {
1748
1985
  this.#unbuild();
@@ -1773,7 +2010,7 @@ var StickyScrollTrigger = class {
1773
2010
  });
1774
2011
  }
1775
2012
  #syncScrollMargins() {
1776
- this.#scrollMarginSync.sync(this.#engagedWindows(), this.#outermostContainer, (targets) => {
2013
+ this.#scrollMarginSync?.sync(this.#engagedWindows(), this.#outermostContainer, (targets) => {
1777
2014
  if (!targets.length) return [];
1778
2015
  const restoreStickyState = this.#resetStickyState();
1779
2016
  const tops = targets.map((target) => documentTop(target));
@@ -1802,6 +2039,7 @@ var StickyScrollTrigger = class {
1802
2039
  if (this.#destroyed) throw new Error("StickyScrollTrigger: cannot register a new layer after destroy() has been called.");
1803
2040
  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
2041
  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.`);
2042
+ this.#arm();
1805
2043
  this.#layers.push(layer);
1806
2044
  this.#dirty = true;
1807
2045
  return {
@@ -1815,6 +2053,7 @@ var StickyScrollTrigger = class {
1815
2053
  removeItem(this.#layers, layer);
1816
2054
  this.#dirty = true;
1817
2055
  this.#scheduleRebuild();
2056
+ this.#disarmIfEmpty();
1818
2057
  onKill?.(self);
1819
2058
  },
1820
2059
  onRefreshInit: this.#createAutoRefreshHandler(rest.onRefreshInit)
@@ -1822,6 +2061,7 @@ var StickyScrollTrigger = class {
1822
2061
  }
1823
2062
  createStickyTrigger({ trigger: triggerInput, start = "0 0", end = "100% 0", endTrigger: endTriggerInput, onKill, ...rest }) {
1824
2063
  this.#assertNoExcludedVars(rest, "createStickyTrigger");
2064
+ this.#flushOverlappingDisarms();
1825
2065
  const trigger = resolveElement(triggerInput, "createStickyTrigger");
1826
2066
  this.#assertTriggerInsideRoot(trigger, "createStickyTrigger");
1827
2067
  const endTrigger = resolveEndTrigger(trigger, endTriggerInput, "createStickyTrigger");
@@ -1842,6 +2082,7 @@ var StickyScrollTrigger = class {
1842
2082
  }
1843
2083
  createOverlapScroll({ trigger: triggerInput, cover, start = "bottom bottom", end = null, endTrigger: endTriggerInput, onKill, ...rest }) {
1844
2084
  this.#assertNoExcludedVars(rest, "createOverlapScroll");
2085
+ this.#flushOverlappingDisarms();
1845
2086
  const trigger = resolveElement(triggerInput, "createOverlapScroll");
1846
2087
  this.#assertTriggerInsideRoot(trigger, "createOverlapScroll");
1847
2088
  const endTrigger = resolveEndTrigger(trigger, endTriggerInput, "createOverlapScroll");
@@ -1863,6 +2104,7 @@ var StickyScrollTrigger = class {
1863
2104
  };
1864
2105
  const vars = this.#registerLayer(layer, (self) => {
1865
2106
  this.#coverRestoreByLayer.get(layer)?.();
2107
+ unbuildCover(layer);
1866
2108
  onKill?.(self);
1867
2109
  }, rest);
1868
2110
  this.#coverRestoreByLayer.set(layer, liftAboveStickyWrapper(coverElement));
@@ -1870,6 +2112,7 @@ var StickyScrollTrigger = class {
1870
2112
  }
1871
2113
  createStickyPin({ trigger: triggerInput, start, top, endTrigger: endTriggerInput, end = "bottom top", onKill, ...rest }) {
1872
2114
  this.#assertNoExcludedVars(rest, "createStickyPin");
2115
+ this.#flushOverlappingDisarms();
1873
2116
  if (this.#destroyed) throw new Error("StickyScrollTrigger: cannot register a new pin after destroy() has been called.");
1874
2117
  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
2118
  const trigger = resolveElement(triggerInput, "createStickyPin");
@@ -1886,6 +2129,7 @@ var StickyScrollTrigger = class {
1886
2129
  endTrigger,
1887
2130
  end
1888
2131
  };
2132
+ this.#arm();
1889
2133
  this.#pinLayers.push(layer);
1890
2134
  return {
1891
2135
  ...rest,
@@ -1894,6 +2138,7 @@ var StickyScrollTrigger = class {
1894
2138
  this.#captureScrollTriggerClass(self);
1895
2139
  removeItem(this.#pinLayers, layer);
1896
2140
  if (this.#unwrapPinLayer(layer)) this.#scheduleRebuild();
2141
+ this.#disarmIfEmpty();
1897
2142
  onKill?.(self);
1898
2143
  },
1899
2144
  onRefreshInit: this.#createAutoRefreshHandler(rest.onRefreshInit)
@@ -1922,8 +2167,8 @@ var StickyScrollTrigger = class {
1922
2167
  if (!this.#rootElement.contains(element)) return reachedAt;
1923
2168
  return reachedAt + dwellBeforeReach(reachedAt, this.#engagedWindows());
1924
2169
  }
1925
- #engagedWindows() {
1926
- return this.#layers.flatMap((layer) => layer.kind === "scene" ? [{
2170
+ #engagedWindows(layers = this.#builtLayers) {
2171
+ return layers.flatMap((layer) => layer.kind === "scene" ? [{
1927
2172
  freezeStart: layer.engagedStart,
1928
2173
  freezeEnd: layer.engagedEnd
1929
2174
  }] : []);
@@ -1939,6 +2184,7 @@ var StickyScrollTrigger = class {
1939
2184
  }
1940
2185
  createResolvedTrigger({ trigger: triggerInput, start = "top bottom", end = "bottom top", endTrigger: endTriggerInput, ...rest }) {
1941
2186
  this.#assertNoExcludedVars(rest, "createResolvedTrigger");
2187
+ this.#flushOverlappingDisarms();
1942
2188
  const trigger = resolveElement(triggerInput, "createResolvedTrigger");
1943
2189
  const endTrigger = resolveEndTrigger(trigger, endTriggerInput, "createResolvedTrigger");
1944
2190
  return {
@@ -1955,13 +2201,17 @@ var StickyScrollTrigger = class {
1955
2201
  }
1956
2202
  destroy() {
1957
2203
  if (this.#destroyed) return;
2204
+ runEach(() => this.#flushPendingDisarmForRevert(), () => this.#tearDown());
2205
+ }
2206
+ #tearDown() {
2207
+ if (this.#restTimer !== null) clearTimeout(this.#restTimer);
2208
+ this.#restTimer = null;
1958
2209
  this.#destroyed = true;
1959
- unregisterDormancyClient(this.#dormancyClient);
1960
- this.#scrollMarginSync.restore();
1961
- this.#restoreCoverLifts();
1962
- this.#unbuild();
2210
+ const run = this.#deferredRun;
2211
+ this.#deferredRun = null;
2212
+ run?.();
2213
+ if (this.#armed) this.#disarm();
1963
2214
  this.#layers.length = 0;
1964
- this.#builtLayers = [];
1965
2215
  this.#pinLayers.forEach((layer) => this.#unwrapPinLayer(layer));
1966
2216
  this.#pinLayers.length = 0;
1967
2217
  this.#scrollTriggerClass = null;