sticky-scroll-trigger 0.11.0 → 0.12.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.11.0
3
+ * StickyScrollTrigger v0.12.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
@@ -98,6 +98,11 @@ const restoreInlinePosition = (el, saved) => {
98
98
  el.style.position = saved.position;
99
99
  el.style.top = saved.top;
100
100
  };
101
+ const stripStickyPositions = (elements) => {
102
+ const saved = elements.map(captureInlinePosition);
103
+ elements.forEach(resetStickyPosition);
104
+ return () => elements.forEach((el, i) => restoreInlinePosition(el, saved[i]));
105
+ };
101
106
  const wrapScene = (inner, holdTrailingMargin) => {
102
107
  if (!inner.parentNode) throw new Error(`StickyScrollTrigger: ${describeElement(inner)} is not attached to the document`);
103
108
  const container = document.createElement("div");
@@ -200,6 +205,438 @@ const liftAboveStickyWrapper = (cover) => {
200
205
  lifted.length = 0;
201
206
  };
202
207
  };
208
+ const AUTO_MIN_DEPTH = 7;
209
+ const MAX_CHAIN_IN_BAND = 4;
210
+ const BUFFER_FLOOR_PX = 325;
211
+ const BUFFER_STEP_PX = 25;
212
+ const isWebKit = () => typeof CSS !== "undefined" && typeof CSS.supports === "function" && CSS.supports("font", "-apple-system-body") || typeof navigator !== "undefined" && navigator.vendor === "Apple Computer, Inc." && !/\bjsdom\//.test(navigator.userAgent);
213
+ const mergeIntervals = (intervals) => {
214
+ const sorted = intervals.filter(([a, b]) => b > a).sort((x, y) => x[0] - y[0]);
215
+ const merged = [];
216
+ sorted.forEach(([a, b]) => {
217
+ const last = merged.at(-1);
218
+ if (last && a <= last[1]) last[1] = Math.max(last[1], b);
219
+ else merged.push([a, b]);
220
+ });
221
+ return merged;
222
+ };
223
+ const invertStuckUnion = (union, y, inclusive) => {
224
+ let scroll = y;
225
+ for (const [a, b] of union) if (inclusive ? a <= scroll : a < scroll) scroll += b - a;
226
+ else break;
227
+ return scroll;
228
+ };
229
+ const isTransformed = (style) => [
230
+ style.transform,
231
+ style.translate,
232
+ style.scale,
233
+ style.rotate
234
+ ].some((value) => value !== void 0 && value !== "" && value !== "none");
235
+ const hasTransform = (el, memo) => {
236
+ if (!el) return false;
237
+ const known = memo.get(el);
238
+ if (known !== void 0) return known;
239
+ const result = isTransformed(getComputedStyle(el)) || hasTransform(el.parentElement, memo);
240
+ memo.set(el, result);
241
+ return result;
242
+ };
243
+ const scrolls = (style) => ![style.overflowX, style.overflowY].every((v) => v === "visible" || v === "clip");
244
+ const bodyScrolls = () => scrolls(getComputedStyle(document.documentElement)) && scrolls(getComputedStyle(document.body));
245
+ const isInsideScroller = (el, memo) => {
246
+ const node = el.parentElement;
247
+ if (!node || node === document.body || node === document.documentElement) return false;
248
+ const known = memo.get(node);
249
+ if (known !== void 0) return known;
250
+ const style = getComputedStyle(node);
251
+ const result = style.position === "fixed" || scrolls(style) || isInsideScroller(node, memo);
252
+ memo.set(node, result);
253
+ return result;
254
+ };
255
+ const ownedDepth = (owned, demoted) => {
256
+ const levels = new Map();
257
+ const levelsUpFrom = (node) => {
258
+ if (!node) return 0;
259
+ const known = levels.get(node);
260
+ if (known !== void 0) return known;
261
+ const level = (demoted.has(node) || getComputedStyle(node).position === "sticky" ? 1 : 0) + levelsUpFrom(node.parentElement);
262
+ levels.set(node, level);
263
+ return level;
264
+ };
265
+ const scrollerMemo = new Map();
266
+ let depth = 0;
267
+ for (const el of owned) {
268
+ if (!el.isConnected || isInsideScroller(el, scrollerMemo)) continue;
269
+ depth = Math.max(depth, 1 + levelsUpFrom(el.parentElement));
270
+ }
271
+ return depth;
272
+ };
273
+ const SIMPLE_TOP = /^-?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?(px|%)$/i;
274
+ const clients = new Set();
275
+ let records = [];
276
+ let buffer = 0;
277
+ let listening = false;
278
+ let scrollBeforeGsapRefresh = null;
279
+ let gsapPhase = "idle";
280
+ let adoptedMidRefresh = false;
281
+ let scannedThisTask = null;
282
+ const gsapClasses = new Set();
283
+ const gsapRefreshing = () => Array.from(gsapClasses).some((cls) => cls.isRefreshing === true);
284
+ const stateAt = (record, scroll) => {
285
+ if (!record.demotable) return "in";
286
+ if (scroll < record.lo - buffer) return "before";
287
+ return scroll > record.hi + buffer && !record.holdsAfter ? "after" : "in";
288
+ };
289
+ const promote = (record, afterMeasure = false) => {
290
+ const { style } = record.el;
291
+ const demoted = record.state !== "in";
292
+ const positionOurs = afterMeasure && style.position === "static" || demoted && style.position === "relative";
293
+ if (positionOurs) style.position = record.position;
294
+ if (demoted && positionOurs && style.top === record.demotedTop) style.top = record.top;
295
+ if (demoted && record.zIndexAuto && style.zIndex === "0") style.zIndex = record.zIndex;
296
+ if (demoted && record.willChangeAuto && style.willChange === "opacity") style.willChange = record.willChange;
297
+ record.state = "in";
298
+ };
299
+ const applyState = (record, state) => {
300
+ if (record.state === state) return;
301
+ if (state === "in") {
302
+ promote(record);
303
+ return;
304
+ }
305
+ const { style } = record.el;
306
+ style.position = "relative";
307
+ style.top = `${state === "before" ? 0 : record.travel}px`;
308
+ record.demotedTop = style.top;
309
+ if (record.zIndexAuto) style.zIndex = "0";
310
+ if (record.willChangeAuto) style.willChange = "opacity";
311
+ record.state = state;
312
+ };
313
+ const update = (scroll) => {
314
+ records.forEach((record) => applyState(record, stateAt(record, scroll)));
315
+ };
316
+ const onScroll = () => update(window.scrollY);
317
+ const listen = (on) => {
318
+ if (on === listening) return;
319
+ listening = on;
320
+ if (on) window.addEventListener("scroll", onScroll, { passive: true });
321
+ else window.removeEventListener("scroll", onScroll);
322
+ };
323
+ const clearTable = () => {
324
+ records.forEach((record) => promote(record));
325
+ records = [];
326
+ listen(false);
327
+ };
328
+ const restoreAfterGsapMeasure = () => {
329
+ const scroll = scrollBeforeGsapRefresh;
330
+ if (gsapPhase !== "measuring" || scroll === null) return;
331
+ gsapPhase = "restored";
332
+ if (records.length) update(scroll);
333
+ };
334
+ const endGsapRefresh = () => {
335
+ gsapPhase = "idle";
336
+ scrollBeforeGsapRefresh = null;
337
+ adoptedMidRefresh = false;
338
+ };
339
+ const rebuildSafely = () => {
340
+ try {
341
+ rebuildDormancy(null);
342
+ } catch (error) {
343
+ clearTable();
344
+ queueMicrotask(() => {
345
+ throw error;
346
+ });
347
+ }
348
+ };
349
+ const onGsapRefreshDone = () => {
350
+ const wasRefreshing = gsapPhase !== "idle";
351
+ endGsapRefresh();
352
+ if (wasRefreshing && liveClients().length) rebuildSafely();
353
+ };
354
+ const onGsapRefreshInit = () => {
355
+ if (gsapPhase === "idle") {
356
+ gsapPhase = "measuring";
357
+ scrollBeforeGsapRefresh = window.scrollY;
358
+ queueMicrotask(onGsapRefreshDone);
359
+ if (records.length) update(0);
360
+ }
361
+ return { render: restoreAfterGsapMeasure };
362
+ };
363
+ const adoptGsapClass = (cls) => {
364
+ if (gsapClasses.has(cls)) return;
365
+ if (cls.isRefreshing === true) adoptedMidRefresh = true;
366
+ gsapClasses.add(cls);
367
+ cls.addEventListener?.("refresh", onGsapRefreshDone);
368
+ cls.addEventListener?.("refreshInit", onGsapRefreshInit);
369
+ };
370
+ const dropGsapClassesLater = () => {
371
+ if (!gsapClasses.size) return;
372
+ queueMicrotask(() => {
373
+ if (liveClients().length) return;
374
+ gsapClasses.forEach((cls) => {
375
+ cls.removeEventListener?.("refresh", onGsapRefreshDone);
376
+ cls.removeEventListener?.("refreshInit", onGsapRefreshInit);
377
+ });
378
+ gsapClasses.clear();
379
+ });
380
+ };
381
+ const scanStickyElements = (owned) => {
382
+ const scrollerMemo = new Map();
383
+ const isWindowSticky = (el) => el.isConnected && getComputedStyle(el).position === "sticky" && !isInsideScroller(el, scrollerMemo);
384
+ if (scannedThisTask) return Array.from(new Set([
385
+ ...scannedThisTask,
386
+ ...records.map((r) => r.el),
387
+ ...owned
388
+ ])).filter(isWindowSticky);
389
+ const found = Array.from(document.querySelectorAll("*")).filter(isWindowSticky);
390
+ scannedThisTask = found;
391
+ queueMicrotask(() => {
392
+ scannedThisTask = null;
393
+ });
394
+ return found;
395
+ };
396
+ const maxChainInBand = (b, maxScroll) => {
397
+ const bands = records.flatMap((r) => {
398
+ const band = r.demotable ? [Math.max(0, r.lo - b), Math.min(maxScroll, r.hi + (r.holdsAfter ? Infinity : b))] : [0, maxScroll];
399
+ return band[1] >= band[0] ? [{
400
+ record: r,
401
+ start: band[0],
402
+ end: band[1]
403
+ }] : [];
404
+ });
405
+ let max = 0;
406
+ new Set([0, ...bands.filter(({ record }) => record.demotable).map(({ start }) => start)]).forEach((scroll) => {
407
+ const inBand = new Set(bands.filter(({ start, end }) => start <= scroll && scroll <= end).map(({ record }) => record));
408
+ inBand.forEach((r) => {
409
+ max = Math.max(max, 1 + r.ancestors.filter((a) => inBand.has(a)).length);
410
+ });
411
+ });
412
+ return max;
413
+ };
414
+ const chooseBuffer = (viewportHeight, maxScroll) => {
415
+ let low = Math.ceil(BUFFER_FLOOR_PX / BUFFER_STEP_PX);
416
+ let high = Math.floor(viewportHeight / BUFFER_STEP_PX);
417
+ if (high < low || maxChainInBand(low * BUFFER_STEP_PX, maxScroll) > MAX_CHAIN_IN_BAND) return BUFFER_FLOOR_PX;
418
+ while (low < high) {
419
+ const mid = Math.ceil((low + high) / 2);
420
+ if (maxChainInBand(mid * BUFFER_STEP_PX, maxScroll) <= MAX_CHAIN_IN_BAND) low = mid;
421
+ else high = mid - 1;
422
+ }
423
+ return low * BUFFER_STEP_PX;
424
+ };
425
+ const liveClients = () => {
426
+ const live = [];
427
+ clients.forEach((ref) => {
428
+ const client = ref.deref();
429
+ if (!client) {
430
+ clients.delete(ref);
431
+ return;
432
+ }
433
+ const owned = client.ownedElements();
434
+ if (owned.some((el) => el.isConnected)) live.push({
435
+ client,
436
+ owned
437
+ });
438
+ });
439
+ return live;
440
+ };
441
+ const measureStatic = (all, owned, unmodeled) => {
442
+ const scroll = window.scrollY;
443
+ const viewportHeight = document.documentElement.clientHeight || window.innerHeight;
444
+ const transformMemo = new Map();
445
+ const documentHeight = measureDocumentHeight();
446
+ all.forEach((record) => {
447
+ const { el } = record;
448
+ const rect = el.getBoundingClientRect();
449
+ const computed = getComputedStyle(el);
450
+ const parent = el.parentElement;
451
+ let containerBottom = rect.bottom + scroll;
452
+ if (parent) {
453
+ const parentStyle = getComputedStyle(parent);
454
+ containerBottom = parent.getBoundingClientRect().bottom + scroll - parseFloat(parentStyle.borderBottomWidth) - parseFloat(parentStyle.paddingBottom);
455
+ if (parentStyle.display === "contents" || parentStyle.display === "inline") unmodeled.add(record);
456
+ }
457
+ record.naturalTop = rect.top + scroll;
458
+ record.travel = Math.max(0, containerBottom - (record.naturalTop + rect.height + parseFloat(computed.marginBottom)));
459
+ record.overflowBottom = record.naturalTop + el.clientTop + el.scrollHeight;
460
+ if (computed.position !== "static" || hasTransform(el, transformMemo)) unmodeled.add(record);
461
+ if (computed.bottom !== "auto" || computed.left !== "auto" || computed.right !== "auto") unmodeled.add(record);
462
+ if (owned.has(el) && (!computed.top.endsWith("px") || Math.abs(parseFloat(computed.top) - parseFloat(el.style.top)) > .01)) unmodeled.add(record);
463
+ if (!owned.has(el) && computed.top === "auto") {
464
+ record.stickyTop = 0;
465
+ record.travel = 0;
466
+ } else if (!owned.has(el)) {
467
+ const unit = SIMPLE_TOP.exec(computed.top)?.[1];
468
+ if (!unit) unmodeled.add(record);
469
+ else if (unit === "%") record.stickyTop = parseFloat(computed.top) * viewportHeight / 100;
470
+ else record.stickyTop = parseFloat(computed.top);
471
+ }
472
+ });
473
+ return {
474
+ scroll,
475
+ viewportHeight,
476
+ documentHeight
477
+ };
478
+ };
479
+ const teardown = () => {
480
+ clearTable();
481
+ endGsapRefresh();
482
+ dropGsapClassesLater();
483
+ };
484
+ const rebuildDormancy = (scrollTriggerClass) => {
485
+ const live = liveClients();
486
+ if (!live.length) {
487
+ teardown();
488
+ return;
489
+ }
490
+ if (scrollTriggerClass) adoptGsapClass(scrollTriggerClass);
491
+ if (!gsapRefreshing()) endGsapRefresh();
492
+ if (!gsapClasses.size || bodyScrolls()) {
493
+ clearTable();
494
+ return;
495
+ }
496
+ const owned = new Map();
497
+ live.forEach(({ client, owned: elements }) => {
498
+ elements.forEach((el) => owned.set(el, client));
499
+ });
500
+ const autoOnly = live.every(({ client }) => client.mode === "auto");
501
+ const demoted = new Set(records.filter((r) => r.state !== "in").map((r) => r.el));
502
+ if (autoOnly && ownedDepth(owned.keys(), demoted) < AUTO_MIN_DEPTH) {
503
+ clearTable();
504
+ return;
505
+ }
506
+ const sticky = scanStickyElements(owned.keys());
507
+ const stickySet = new Set(sticky);
508
+ const leftover = records.filter((r) => r.state !== "in" && !stickySet.has(r.el));
509
+ leftover.filter((r) => !r.el.isConnected).forEach((r) => promote(r));
510
+ const kept = leftover.filter((r) => r.el.isConnected);
511
+ const previous = new Map(records.map((r) => [r.el, r]));
512
+ const found = [...sticky.map((el) => {
513
+ const computed = getComputedStyle(el);
514
+ const before = previous.get(el);
515
+ if (before && before.state !== "in") return {
516
+ ...before,
517
+ demotable: false,
518
+ position: el.style.position,
519
+ top: el.style.top,
520
+ stickyTop: parseFloat(el.style.top) || 0,
521
+ ancestors: [],
522
+ state: "before"
523
+ };
524
+ return {
525
+ el,
526
+ demotable: false,
527
+ position: el.style.position,
528
+ top: el.style.top,
529
+ zIndex: el.style.zIndex,
530
+ willChange: el.style.willChange,
531
+ zIndexAuto: computed.zIndex === "auto",
532
+ willChangeAuto: computed.willChange === "auto",
533
+ stickyTop: parseFloat(el.style.top) || 0,
534
+ naturalTop: 0,
535
+ travel: 0,
536
+ ancestors: [],
537
+ lo: 0,
538
+ hi: 0,
539
+ overflowBottom: 0,
540
+ holdsAfter: false,
541
+ state: "in",
542
+ demotedTop: ""
543
+ };
544
+ }), ...kept];
545
+ found.sort((a, b) => compareDocumentOrder(a.el, b.el));
546
+ found.forEach((record, index) => {
547
+ record.ancestors = found.slice(0, index).filter((a) => a.el.contains(record.el));
548
+ });
549
+ const holdsOwned = new Set();
550
+ found.forEach((record) => {
551
+ if (owned.has(record.el)) record.ancestors.forEach((a) => holdsOwned.add(a));
552
+ });
553
+ const all = found.filter((r) => owned.has(r.el) || holdsOwned.has(r) || r.state !== "in" || r.ancestors.some((a) => owned.has(a.el)));
554
+ const inTable = new Set(all);
555
+ all.forEach((record) => {
556
+ record.ancestors = record.ancestors.filter((a) => inTable.has(a));
557
+ });
558
+ const depths = new Map();
559
+ all.forEach((record) => {
560
+ const client = owned.get(record.el);
561
+ if (client) depths.set(client, Math.max(depths.get(client) ?? 0, record.ancestors.length + 1));
562
+ });
563
+ const active = new Set(live.map(({ client }) => client).filter((client) => client.mode === "always" || (depths.get(client) ?? 0) >= AUTO_MIN_DEPTH));
564
+ all.forEach((record) => {
565
+ const client = owned.get(record.el);
566
+ record.demotable = client !== void 0 && active.has(client);
567
+ });
568
+ records = all;
569
+ if (!all.some((r) => r.demotable)) {
570
+ clearTable();
571
+ return;
572
+ }
573
+ const toMeasure = all.filter((r) => owned.has(r.el) || holdsOwned.has(r) || r.state !== "in");
574
+ const authorStyle = new Map(toMeasure.filter((r) => !owned.has(r.el) && r.state === "in").map(({ el }) => [el, el.getAttribute("style")]));
575
+ const restorePositions = () => toMeasure.forEach((record) => {
576
+ if (!authorStyle.has(record.el)) {
577
+ promote(record, true);
578
+ return;
579
+ }
580
+ const saved = authorStyle.get(record.el);
581
+ if (saved === null || saved === void 0) record.el.removeAttribute("style");
582
+ else record.el.setAttribute("style", saved);
583
+ });
584
+ toMeasure.forEach(({ el }) => {
585
+ el.style.position = "static";
586
+ });
587
+ const unmodeled = new Set();
588
+ let measured;
589
+ try {
590
+ measured = measureStatic(toMeasure, owned, unmodeled);
591
+ } finally {
592
+ restorePositions();
593
+ }
594
+ const { scroll, viewportHeight, documentHeight } = measured;
595
+ const maxScroll = Math.max(0, documentHeight - viewportHeight);
596
+ all.forEach((record) => {
597
+ const union = mergeIntervals(record.ancestors.map((a) => [a.lo, a.hi]));
598
+ const reach = record.naturalTop - record.stickyTop;
599
+ record.lo = invertStuckUnion(union, reach, true);
600
+ record.hi = invertStuckUnion(union, reach + record.travel, false);
601
+ if (unmodeled.has(record) || record.ancestors.some((a) => unmodeled.has(a))) record.demotable = false;
602
+ const carried = record.ancestors.filter((a) => a.demotable && !a.holdsAfter).reduce((sum, a) => sum + a.travel, 0);
603
+ record.holdsAfter = record.overflowBottom + record.travel + carried > documentHeight + 1;
604
+ });
605
+ buffer = chooseBuffer(viewportHeight, maxScroll);
606
+ update(gsapPhase === "measuring" ? 0 : (gsapPhase === "restored" ? scrollBeforeGsapRefresh : null) ?? scroll);
607
+ listen(true);
608
+ };
609
+ const takeGsapRefreshRestore = () => adoptedMidRefresh && gsapRefreshing() ? onGsapRefreshInit().render : null;
610
+ const clearDormancy = clearTable;
611
+ const releaseDormant = (elements) => {
612
+ const released = new Set(elements);
613
+ records = records.filter((record) => {
614
+ if (!released.has(record.el)) return true;
615
+ promote(record);
616
+ return false;
617
+ });
618
+ };
619
+ const registerDormancyClient = (client) => {
620
+ clients.add(new WeakRef(client));
621
+ };
622
+ let rebuildQueued = false;
623
+ const queueRebuild = () => {
624
+ if (rebuildQueued) return;
625
+ rebuildQueued = true;
626
+ queueMicrotask(() => {
627
+ rebuildQueued = false;
628
+ rebuildSafely();
629
+ });
630
+ };
631
+ const unregisterDormancyClient = (client) => {
632
+ clients.forEach((ref) => {
633
+ if (ref.deref() !== client) return;
634
+ clients.delete(ref);
635
+ releaseDormant(client.ownedElements());
636
+ });
637
+ if (liveClients().length) queueRebuild();
638
+ else teardown();
639
+ };
203
640
  const resolveMaybeFn = (value) => typeof value === "function" ? value() : value;
204
641
  const KEYWORD_FRACTIONS = {
205
642
  top: 0,
@@ -240,19 +677,20 @@ const assertNotClamped = (trimmed) => {
240
677
  const inner = trimmed.slice(6).replace(/\)$/, "").trim();
241
678
  throw new Error(`StickyScrollTrigger: unsupported position clause "${trimmed}": GSAP's clamp() wrapper isn't supported here.` + (inner ? ` Did you mean "${inner}"?` : ""));
242
679
  };
243
- const resolveElementAnchor = (position, elementHeight) => {
680
+ const splitClause = (position) => {
244
681
  const trimmed = position.trim();
245
682
  assertNotClamped(trimmed);
246
- const elementClause = parseClauseToken(trimmed.split(/\s+/)[0], elementHeight);
247
- return elementHeight * elementClause.fraction + elementClause.offsetPx;
683
+ return trimmed.split(/\s+/);
248
684
  };
685
+ const anchorWithin = (token, size) => {
686
+ const { fraction, offsetPx } = parseClauseToken(token, size);
687
+ return size * fraction + offsetPx;
688
+ };
689
+ const resolveElementAnchor = (position, elementHeight) => anchorWithin(splitClause(position)[0], elementHeight);
249
690
  const resolveElementFraction = (position) => resolveElementAnchor(position, 1) - resolveElementAnchor(position, 0);
250
691
  const resolveAnchorTop = (position, elementHeight, viewportHeight) => {
251
- const trimmed = position.trim();
252
- assertNotClamped(trimmed);
253
- const viewportToken = trimmed.split(/\s+/)[1] ?? "top";
254
- const viewportClause = parseClauseToken(viewportToken, viewportHeight);
255
- return viewportHeight * viewportClause.fraction + viewportClause.offsetPx - resolveElementAnchor(trimmed, elementHeight);
692
+ const [elementToken, viewportToken = "top"] = splitClause(position);
693
+ return anchorWithin(viewportToken, viewportHeight) - anchorWithin(elementToken, elementHeight);
256
694
  };
257
695
  const DWELL_RELATIVE_RE = /^\+=(\d+(?:\.\d*)?|\.\d+)(%|px)?$/;
258
696
  const isDwellFormat = (resolved) => typeof resolved === "string" && DWELL_RELATIVE_RE.test(resolved.trim());
@@ -262,9 +700,7 @@ const prefixSpacedRelativeEnd = (start, endResolved) => {
262
700
  if (!trimmedEnd.startsWith("+=") || !/\s/.test(trimmedEnd)) return endResolved;
263
701
  const startResolved = resolveMaybeFn(start);
264
702
  if (typeof startResolved !== "string") return endResolved;
265
- const trimmedStart = startResolved.trim();
266
- assertNotClamped(trimmedStart);
267
- const [elementToken] = trimmedStart.split(/\s+/);
703
+ const [elementToken] = splitClause(startResolved);
268
704
  try {
269
705
  parseClauseToken(elementToken, 0);
270
706
  } catch (error) {
@@ -313,16 +749,18 @@ const classifyPosition = (resolved) => {
313
749
  };
314
750
  const isHeldIn = (measurements, index, enclosedBy, anchorElement, order) => measurements[index].triggerEnclosedBy.some((m) => m !== index && measurements[m].kind === "scene" && order.isBefore(m, index) && !(enclosedBy.includes(m) && m !== anchorElement));
315
751
  const nestedIn = (measurements, index) => measurements.flatMap(({ triggerEnclosedBy }, k) => k !== index && triggerEnclosedBy.includes(index) ? [k] : []);
316
- const anchorShare = (measurements, world, index, freezeStart, box, reachedAt, enclosedBy, anchorElement, order, ownIndex) => {
752
+ const anchorShare = ({ measurements, world, order, ownIndex }, index, freezeStart, box, reachedAt) => {
753
+ const { enclosedBy, anchorElement } = box;
317
754
  const measurement = measurements[index];
318
755
  if (enclosedBy.includes(index)) return (measurement.start.mode === "absolute" ? world.unpaddedStart(index, ownIndex, freezeStart) : measurement.triggerTop - measurement.start.anchorOffset) < reachedAt - .05 ? 1 : 0;
319
756
  if (order && isHeldIn(measurements, index, enclosedBy, anchorElement, order)) return 0;
320
757
  if (box.nests.includes(index)) return box.fraction;
321
758
  return measurement.triggerTop + measurement.triggerHeight <= box.top + .05 ? 1 : 0;
322
759
  };
323
- const gapsBeforeEndAnchor = (measurements, world, windows, box, reachedAt, enclosedBy, ownIndex, anchorElement, order, counted) => windows.reduce((total, { index, freezeStart, freezeEnd }) => {
760
+ const gapsBeforeEndAnchor = (context, windows, box, reachedAt, counted) => windows.reduce((total, { index, freezeStart, freezeEnd }) => {
761
+ const { ownIndex, order } = context;
324
762
  if (index === ownIndex || order && order.isBefore(ownIndex, index)) return total;
325
- const weight = anchorShare(measurements, world, index, freezeStart, box, reachedAt, enclosedBy, anchorElement, order, ownIndex);
763
+ const weight = anchorShare(context, index, freezeStart, box, reachedAt);
326
764
  if (weight === 0) return total;
327
765
  counted?.add(index);
328
766
  return total + weight * (freezeEnd - freezeStart);
@@ -386,8 +824,64 @@ const runPass = (measurements, { viewportHeight, measureLiveEndTriggerTop }, pre
386
824
  runs: []
387
825
  };
388
826
  recounts.push(recount);
827
+ const context = {
828
+ measurements,
829
+ world,
830
+ order,
831
+ ownIndex: index
832
+ };
833
+ const gapsOf = (box, reachedAt) => {
834
+ const gaps = (w, counted) => gapsBeforeEndAnchor(context, w, box, reachedAt, counted);
835
+ recount.runs.push((w) => gaps(w, recount.counted));
836
+ return gaps(knownWindows());
837
+ };
389
838
  const { start } = measurement;
390
839
  const freezeStart = start.mode === "absolute" ? start.value : previous?.freezeStarts[index] ?? clauseFreezeStart(measurements, index, paddingOf);
840
+ const heldBack = (k) => order !== null && (order.isBefore(index, k) || isHeldIn(measurements, k, measurement.triggerEnclosedBy, index, order));
841
+ const selfClauseEnd = (end, anchorOffsetEnd) => {
842
+ const nests = nestedIn(measurements, index);
843
+ const weight = resolveElementFraction(end.clause) - (start.mode === "clause" ? start.elementFraction : 0);
844
+ const dwellInside = measurements.reduce((total, other, k) => {
845
+ if (weight === 0 || other.kind !== "scene" || !nests.includes(k) || heldBack(k)) return total;
846
+ recount.counted.add(k);
847
+ return total + weight * paddingOf(k);
848
+ }, 0);
849
+ if (start.mode === "clause") return freezeStart + Math.max(0, start.anchorOffset - anchorOffsetEnd + dwellInside);
850
+ const dwellAbove = measurements.reduce((total, other, k) => {
851
+ if (k === index || other.kind !== "scene" || nests.includes(k) || other.triggerTop + other.triggerHeight > measurement.triggerTop + .05 || heldBack(k)) return total;
852
+ recount.counted.add(k);
853
+ return total + paddingOf(k);
854
+ }, 0);
855
+ return Math.max(freezeStart, measurement.triggerTop - anchorOffsetEnd + dwellAbove + dwellInside);
856
+ };
857
+ const elementClauseEnd = (end, anchorOffsetEnd) => {
858
+ let endTop;
859
+ if (end.measureLive) endTop = measureLiveEndTriggerTop(index);
860
+ else {
861
+ const rawTop = measurement.endTrigger.index === null ? end.rawTop : measurements[measurement.endTrigger.index].triggerTop;
862
+ if (rawTop === null) endTop = 0;
863
+ else {
864
+ const box = {
865
+ top: rawTop,
866
+ fraction: resolveElementFraction(end.clause),
867
+ nests: measurement.endTrigger.nests,
868
+ enclosedBy: measurement.endTrigger.enclosedBy,
869
+ anchorElement: measurement.endTrigger.index
870
+ };
871
+ endTop = rawTop + gapsOf(box, rawTop - anchorOffsetEnd);
872
+ }
873
+ }
874
+ let layoutStart;
875
+ if (start.mode === "absolute") layoutStart = start.value;
876
+ else layoutStart = measurement.triggerTop - start.anchorOffset + gapsOf({
877
+ top: measurement.triggerTop,
878
+ fraction: start.elementFraction,
879
+ nests: nestedIn(measurements, index),
880
+ enclosedBy: measurement.triggerEnclosedBy,
881
+ anchorElement: index
882
+ }, measurement.triggerTop - start.anchorOffset);
883
+ return freezeStart + Math.max(0, endTop - anchorOffsetEnd - layoutStart);
884
+ };
391
885
  let freezeEnd;
392
886
  switch (measurement.end.mode) {
393
887
  case "dwell":
@@ -401,55 +895,8 @@ const runPass = (measurements, { viewportHeight, measureLiveEndTriggerTop }, pre
401
895
  case "auto":
402
896
  case "max": throw new Error(`StickyScrollTrigger: internal error: a Scene layer reached '${measurement.end.mode}' end mode, which only a cover layer can have.`);
403
897
  case "clause": {
404
- const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTriggerHeight, viewportHeight);
405
- if (measurement.endTriggerIsSelf) {
406
- const nests = nestedIn(measurements, index);
407
- const weight = resolveElementFraction(measurement.end.clause) - (start.mode === "clause" ? start.elementFraction : 0);
408
- const dwellInside = measurements.reduce((total, other, k) => {
409
- if (weight === 0 || other.kind !== "scene" || !nests.includes(k) || order && (order.isBefore(index, k) || isHeldIn(measurements, k, measurement.triggerEnclosedBy, index, order))) return total;
410
- recount.counted.add(k);
411
- return total + weight * paddingOf(k);
412
- }, 0);
413
- if (start.mode === "clause") {
414
- freezeEnd = freezeStart + Math.max(0, start.anchorOffset - anchorOffsetEnd + dwellInside);
415
- break;
416
- }
417
- const dwellAbove = measurements.reduce((total, other, k) => {
418
- if (k === index || other.kind !== "scene" || nests.includes(k) || other.triggerTop + other.triggerHeight > measurement.triggerTop + .05 || order && (order.isBefore(index, k) || isHeldIn(measurements, k, measurement.triggerEnclosedBy, index, order))) return total;
419
- recount.counted.add(k);
420
- return total + paddingOf(k);
421
- }, 0);
422
- freezeEnd = Math.max(freezeStart, measurement.triggerTop - anchorOffsetEnd + dwellAbove + dwellInside);
423
- break;
424
- }
425
- let endTop;
426
- if (measurement.end.measureLive) endTop = measureLiveEndTriggerTop(index);
427
- else {
428
- const rawTop = measurement.endTriggerIndex === null ? measurement.end.rawTop : measurements[measurement.endTriggerIndex].triggerTop;
429
- if (rawTop === null) endTop = 0;
430
- else {
431
- const box = {
432
- top: rawTop,
433
- fraction: resolveElementFraction(measurement.end.clause),
434
- nests: measurement.endTriggerNests
435
- };
436
- const gaps = (w, counted) => gapsBeforeEndAnchor(measurements, world, w, box, rawTop - anchorOffsetEnd, measurement.endTriggerEnclosedBy, index, measurement.endTriggerIndex, order, counted);
437
- endTop = rawTop + gaps(knownWindows());
438
- recount.runs.push((w) => gaps(w, recount.counted));
439
- }
440
- }
441
- let layoutStart;
442
- if (start.mode === "absolute") layoutStart = start.value;
443
- else {
444
- const gaps = (w, counted) => gapsBeforeEndAnchor(measurements, world, w, {
445
- top: measurement.triggerTop,
446
- fraction: start.elementFraction,
447
- nests: nestedIn(measurements, index)
448
- }, measurement.triggerTop - start.anchorOffset, measurement.triggerEnclosedBy, index, index, order, counted);
449
- layoutStart = measurement.triggerTop - start.anchorOffset + gaps(knownWindows());
450
- recount.runs.push((w) => gaps(w, recount.counted));
451
- }
452
- freezeEnd = freezeStart + Math.max(0, endTop - anchorOffsetEnd - layoutStart);
898
+ const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTrigger.height, viewportHeight);
899
+ freezeEnd = measurement.endTrigger.isSelf ? selfClauseEnd(measurement.end, anchorOffsetEnd) : elementClauseEnd(measurement.end, anchorOffsetEnd);
453
900
  break;
454
901
  }
455
902
  }
@@ -491,9 +938,9 @@ const planCover = (measurements, index, windows, { viewportHeight, documentMaxSc
491
938
  freezeEnd = documentMaxScroll + measurement.end.offsetPx;
492
939
  break;
493
940
  case "clause": {
494
- const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTriggerHeight, viewportHeight);
941
+ const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTrigger.height, viewportHeight);
495
942
  if (measurement.end.measureLive) freezeEnd = measureLiveEndTriggerTop(index) - anchorOffsetEnd;
496
- else freezeEnd = reached((measurement.endTriggerIsSelf ? measurement.triggerTop : measurement.endTriggerIndex === null ? measurement.end.rawTop ?? 0 : measurements[measurement.endTriggerIndex].triggerTop) - anchorOffsetEnd);
943
+ else freezeEnd = reached((measurement.endTrigger.isSelf ? measurement.triggerTop : measurement.endTrigger.index === null ? measurement.end.rawTop ?? 0 : measurements[measurement.endTrigger.index].triggerTop) - anchorOffsetEnd);
497
944
  break;
498
945
  }
499
946
  }
@@ -564,7 +1011,7 @@ const refreshOrderEdges = (measurements, lengths, edges) => {
564
1011
  const before = measurements.map(() => []);
565
1012
  edges.forEach((movers, i) => {
566
1013
  const measurement = measurements[i];
567
- const enclosingAnchor = (measurement.end.mode === "clause" && !measurement.endTriggerIsSelf ? measurement.endTriggerEnclosedBy : measurement.triggerEnclosedBy).filter((m) => m !== measurement.endTriggerIndex);
1014
+ const enclosingAnchor = (measurement.end.mode === "clause" && !measurement.endTrigger.isSelf ? measurement.endTrigger.enclosedBy : measurement.triggerEnclosedBy).filter((m) => m !== measurement.endTrigger.index);
568
1015
  movers.forEach((k) => {
569
1016
  if (lengths[k] <= .05) return;
570
1017
  before[i].push(k);
@@ -821,7 +1268,7 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
821
1268
  const snapshot = snapshots.get(target);
822
1269
  target.style.scrollMarginTop = snapshot ? snapshot.inline : "";
823
1270
  };
824
- const clearAnimation = () => {
1271
+ const stopRamps = () => {
825
1272
  if (sheet) {
826
1273
  document.adoptedStyleSheets = document.adoptedStyleSheets.filter((one) => one !== sheet);
827
1274
  sheet = null;
@@ -831,31 +1278,37 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
831
1278
  jsRamps = [];
832
1279
  jsHost = null;
833
1280
  };
1281
+ const startRamps = (ramps, host) => {
1282
+ if (animationHost !== host) {
1283
+ animationHost?.removeAttribute(`data-${instanceId}`);
1284
+ animationHost = host;
1285
+ animationHost.setAttribute(`data-${instanceId}`, "");
1286
+ }
1287
+ if (usesJsRamp) {
1288
+ jsRamps = ramps;
1289
+ jsHost = host;
1290
+ applyJsRamp();
1291
+ return;
1292
+ }
1293
+ if (!sheet) {
1294
+ sheet = new CSSStyleSheet();
1295
+ document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
1296
+ }
1297
+ sheet.replaceSync(buildStylesheet(instanceId, ramps));
1298
+ };
1299
+ const release = () => {
1300
+ written.forEach(restoreTarget);
1301
+ written = new Set();
1302
+ stopRamps();
1303
+ };
834
1304
  return {
835
1305
  sync(scenes, host, measureNaturalTops) {
836
1306
  const ramps = scenes.filter((scene) => scene.freezeEnd > scene.freezeStart).sort((a, b) => a.freezeStart - b.freezeStart);
837
1307
  if (targetSelector === null || !ramps.length || !host) {
838
- written.forEach(restoreTarget);
839
- written = new Set();
840
- clearAnimation();
1308
+ release();
841
1309
  return;
842
1310
  }
843
- if (animationHost !== host) {
844
- animationHost?.removeAttribute(`data-${instanceId}`);
845
- animationHost = host;
846
- animationHost.setAttribute(`data-${instanceId}`, "");
847
- }
848
- if (usesJsRamp) {
849
- jsRamps = ramps;
850
- jsHost = host;
851
- applyJsRamp();
852
- } else {
853
- if (!sheet) {
854
- sheet = new CSSStyleSheet();
855
- document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
856
- }
857
- sheet.replaceSync(buildStylesheet(instanceId, ramps));
858
- }
1311
+ startRamps(ramps, host);
859
1312
  const targets = Array.from(rootElement.querySelectorAll(targetSelector));
860
1313
  const naturalTops = measureNaturalTops(targets);
861
1314
  targets.forEach((target) => {
@@ -882,9 +1335,7 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
882
1335
  },
883
1336
  restore() {
884
1337
  if (usesJsRamp) window.removeEventListener("scroll", applyJsRamp);
885
- written.forEach(restoreTarget);
886
- written = new Set();
887
- clearAnimation();
1338
+ release();
888
1339
  }
889
1340
  };
890
1341
  };
@@ -983,23 +1434,27 @@ const measureLayer = (rootElement, viewportHeight, layer, ownIndex, indexByTrigg
983
1434
  const endResolved = layer.end === null ? null : prefixSpacedRelativeEnd(startResolved, resolveMaybeFn(layer.end));
984
1435
  const elementHeight = measureUsedHeight(layer.trigger);
985
1436
  const endTriggerIsSelf = layer.endTrigger === layer.trigger;
1437
+ const indicesWhere = (test) => [...indexByTrigger].filter(([trigger]) => test(trigger)).map(([, index]) => index);
986
1438
  const endTriggerIndex = indexByTrigger.get(layer.endTrigger) ?? null;
987
1439
  const end = resolveEndSpec(rootElement, viewportHeight, layer, endResolved, ownIndex, endTriggerIndex);
1440
+ const endTriggerInContainer = end.mode === "clause" && !end.measureLive && !endTriggerIsSelf;
988
1441
  const start = resolveStartSpec(layer, startResolved, elementHeight, viewportHeight);
989
1442
  return {
990
1443
  kind: layer.kind,
991
1444
  start,
992
1445
  triggerTop: documentTop(layer.trigger),
993
1446
  triggerHeight: elementHeight,
994
- triggerEnclosedBy: [...indexByTrigger].filter(([trigger]) => trigger.contains(layer.trigger)).map(([, index]) => index),
1447
+ triggerEnclosedBy: indicesWhere((trigger) => trigger.contains(layer.trigger)),
995
1448
  wrapperTop: layer.wrapper ? documentTop(layer.wrapper) : 0,
996
1449
  coverTop: layer.kind === "cover" ? documentTop(layer.cover) : 0,
997
1450
  end,
998
- endTriggerIsSelf,
999
- endTriggerIndex,
1000
- endTriggerHeight: end.mode === "clause" ? measureUsedHeight(layer.endTrigger) : 0,
1001
- endTriggerEnclosedBy: end.mode === "clause" && !end.measureLive && !endTriggerIsSelf ? [...indexByTrigger].filter(([trigger]) => trigger.contains(layer.endTrigger)).map(([, index]) => index) : [],
1002
- endTriggerNests: end.mode === "clause" && !end.measureLive && !endTriggerIsSelf ? [...indexByTrigger].filter(([trigger]) => trigger !== layer.endTrigger && layer.endTrigger.contains(trigger)).map(([, index]) => index) : []
1451
+ endTrigger: {
1452
+ isSelf: endTriggerIsSelf,
1453
+ index: endTriggerIndex,
1454
+ height: end.mode === "clause" ? measureUsedHeight(layer.endTrigger) : 0,
1455
+ enclosedBy: endTriggerInContainer ? indicesWhere((trigger) => trigger.contains(layer.endTrigger)) : [],
1456
+ nests: endTriggerInContainer ? indicesWhere((other) => other !== layer.endTrigger && layer.endTrigger.contains(other)) : []
1457
+ }
1003
1458
  };
1004
1459
  };
1005
1460
  const EXCLUDED_VAR_KEYS = [
@@ -1032,6 +1487,10 @@ const resolvePinReleaseScroll = (endTrigger, classifiedEnd, engageScroll, viewpo
1032
1487
  case "clause": return toScroll(endTrigger, documentTop(endTrigger) - resolveAnchorTop(classifiedEnd.value, measureUsedHeight(endTrigger), viewportHeight));
1033
1488
  }
1034
1489
  };
1490
+ const removeItem = (list, item) => {
1491
+ const index = list.indexOf(item);
1492
+ if (index !== -1) list.splice(index, 1);
1493
+ };
1035
1494
  const hasDuplicateTrigger = (list, trigger) => list.some((existing) => existing.trigger === trigger);
1036
1495
  var StickyScrollTrigger = class {
1037
1496
  #rootElement;
@@ -1046,6 +1505,7 @@ var StickyScrollTrigger = class {
1046
1505
  #scrollTriggerClass = null;
1047
1506
  #pinLayers = [];
1048
1507
  #scrollMarginSync;
1508
+ #dormancyClient = null;
1049
1509
  constructor(root, options = {}) {
1050
1510
  this.#rootElement = resolveRoot(root);
1051
1511
  const scrollMarginTargets = options.scrollMarginTargets === void 0 ? "[id]" : options.scrollMarginTargets;
@@ -1054,7 +1514,26 @@ var StickyScrollTrigger = class {
1054
1514
  } catch {
1055
1515
  throw new Error(`StickyScrollTrigger: scrollMarginTargets "${scrollMarginTargets}" is not a valid CSS selector.`);
1056
1516
  }
1517
+ const optimization = options.nestedStickyOptimization === void 0 ? "auto" : options.nestedStickyOptimization;
1518
+ if (![
1519
+ "auto",
1520
+ "always",
1521
+ "off"
1522
+ ].includes(optimization)) throw new Error(`StickyScrollTrigger: nestedStickyOptimization must be 'auto', 'always' or 'off', got ${String(optimization)}.`);
1057
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);
1530
+ }
1531
+ }
1532
+ #ownedStickyElements() {
1533
+ return [...this.#builtLayers.flatMap((layer) => layer.wrapper ? [layer.wrapper] : []), ...this.#wrappedPinTriggers()];
1534
+ }
1535
+ #wrappedPinTriggers() {
1536
+ return this.#pinLayers.flatMap(({ trigger, inner }) => inner ? [trigger] : []);
1058
1537
  }
1059
1538
  #unbuild() {
1060
1539
  if (!this.#built) return;
@@ -1093,7 +1572,12 @@ var StickyScrollTrigger = class {
1093
1572
  throw error;
1094
1573
  });
1095
1574
  }
1096
- return result;
1575
+ const restoreDormancy = takeGsapRefreshRestore();
1576
+ if (!restoreDormancy) return result;
1577
+ return { render: (time) => {
1578
+ result?.render?.(time);
1579
+ restoreDormancy();
1580
+ } };
1097
1581
  };
1098
1582
  }
1099
1583
  #wrapUnwrappedPins() {
@@ -1125,34 +1609,17 @@ var StickyScrollTrigger = class {
1125
1609
  }
1126
1610
  #unwrapPinLayer(layer) {
1127
1611
  if (!layer.outer) return false;
1612
+ releaseDormant([layer.trigger]);
1128
1613
  unwrapPin(layer.outer, layer.trigger, layer.savedPosition);
1129
1614
  layer.outer = null;
1130
1615
  layer.inner = null;
1131
1616
  return true;
1132
1617
  }
1133
1618
  #resetSceneCoverStickyState() {
1134
- const wrapperSnapshots = this.#layers.map((layer) => layer.wrapper).filter((wrapper) => wrapper !== null).map((wrapper) => ({
1135
- wrapper,
1136
- position: wrapper.style.position,
1137
- top: wrapper.style.top
1138
- }));
1139
- wrapperSnapshots.forEach(({ wrapper }) => resetStickyPosition(wrapper));
1140
- return () => {
1141
- wrapperSnapshots.forEach(({ wrapper, position, top }) => {
1142
- wrapper.style.position = position;
1143
- wrapper.style.top = top;
1144
- });
1145
- };
1619
+ return stripStickyPositions(this.#layers.flatMap(({ wrapper }) => wrapper ? [wrapper] : []));
1146
1620
  }
1147
1621
  #resetPinStickyState() {
1148
- const snapshots = this.#pinLayers.filter((layer) => layer.inner).map(({ trigger }) => ({
1149
- trigger,
1150
- position: captureInlinePosition(trigger)
1151
- }));
1152
- snapshots.forEach(({ trigger }) => resetStickyPosition(trigger));
1153
- return () => {
1154
- snapshots.forEach(({ trigger, position }) => restoreInlinePosition(trigger, position));
1155
- };
1622
+ return stripStickyPositions(this.#wrappedPinTriggers());
1156
1623
  }
1157
1624
  #resetStickyState() {
1158
1625
  const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
@@ -1260,6 +1727,23 @@ var StickyScrollTrigger = class {
1260
1727
  }
1261
1728
  refresh() {
1262
1729
  if (this.#destroyed) return;
1730
+ let failure = null;
1731
+ try {
1732
+ this.#refreshLayout();
1733
+ } catch (error) {
1734
+ failure = { error };
1735
+ }
1736
+ try {
1737
+ rebuildDormancy(this.#scrollTriggerClass);
1738
+ } catch (error) {
1739
+ clearDormancy();
1740
+ queueMicrotask(() => {
1741
+ throw error;
1742
+ });
1743
+ }
1744
+ if (failure) throw failure.error;
1745
+ }
1746
+ #refreshLayout() {
1263
1747
  if (this.#dirty || !this.#built || isDomOrderStale(this.#layers)) {
1264
1748
  this.#unbuild();
1265
1749
  this.#build();
@@ -1328,8 +1812,7 @@ var StickyScrollTrigger = class {
1328
1812
  invalidateOnRefresh: rest.invalidateOnRefresh ?? true,
1329
1813
  onKill: (self) => {
1330
1814
  this.#captureScrollTriggerClass(self);
1331
- const index = this.#layers.indexOf(layer);
1332
- if (index !== -1) this.#layers.splice(index, 1);
1815
+ removeItem(this.#layers, layer);
1333
1816
  this.#dirty = true;
1334
1817
  this.#scheduleRebuild();
1335
1818
  onKill?.(self);
@@ -1409,8 +1892,7 @@ var StickyScrollTrigger = class {
1409
1892
  trigger,
1410
1893
  onKill: (self) => {
1411
1894
  this.#captureScrollTriggerClass(self);
1412
- const index = this.#pinLayers.indexOf(layer);
1413
- if (index !== -1) this.#pinLayers.splice(index, 1);
1895
+ removeItem(this.#pinLayers, layer);
1414
1896
  if (this.#unwrapPinLayer(layer)) this.#scheduleRebuild();
1415
1897
  onKill?.(self);
1416
1898
  },
@@ -1474,6 +1956,7 @@ var StickyScrollTrigger = class {
1474
1956
  destroy() {
1475
1957
  if (this.#destroyed) return;
1476
1958
  this.#destroyed = true;
1959
+ unregisterDormancyClient(this.#dormancyClient);
1477
1960
  this.#scrollMarginSync.restore();
1478
1961
  this.#restoreCoverLifts();
1479
1962
  this.#unbuild();