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