sticky-scroll-trigger 0.10.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.10.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,7 +98,12 @@ const restoreInlinePosition = (el, saved) => {
98
98
  el.style.position = saved.position;
99
99
  el.style.top = saved.top;
100
100
  };
101
- const wrapScene = (inner) => {
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
+ };
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");
104
109
  const wrapper = document.createElement("div");
@@ -109,6 +114,11 @@ const wrapScene = (inner) => {
109
114
  container.appendChild(wrapper);
110
115
  wrapper.appendChild(inner);
111
116
  container.appendChild(padding);
117
+ if (holdTrailingMargin) {
118
+ const sentinel = document.createElement("div");
119
+ sentinel.style.display = "flow-root";
120
+ wrapper.appendChild(sentinel);
121
+ }
112
122
  return {
113
123
  container,
114
124
  wrapper,
@@ -195,6 +205,438 @@ const liftAboveStickyWrapper = (cover) => {
195
205
  lifted.length = 0;
196
206
  };
197
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
+ };
198
640
  const resolveMaybeFn = (value) => typeof value === "function" ? value() : value;
199
641
  const KEYWORD_FRACTIONS = {
200
642
  top: 0,
@@ -235,19 +677,20 @@ const assertNotClamped = (trimmed) => {
235
677
  const inner = trimmed.slice(6).replace(/\)$/, "").trim();
236
678
  throw new Error(`StickyScrollTrigger: unsupported position clause "${trimmed}": GSAP's clamp() wrapper isn't supported here.` + (inner ? ` Did you mean "${inner}"?` : ""));
237
679
  };
238
- const resolveElementAnchor = (position, elementHeight) => {
680
+ const splitClause = (position) => {
239
681
  const trimmed = position.trim();
240
682
  assertNotClamped(trimmed);
241
- const elementClause = parseClauseToken(trimmed.split(/\s+/)[0], elementHeight);
242
- return elementHeight * elementClause.fraction + elementClause.offsetPx;
683
+ return trimmed.split(/\s+/);
243
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);
244
690
  const resolveElementFraction = (position) => resolveElementAnchor(position, 1) - resolveElementAnchor(position, 0);
245
691
  const resolveAnchorTop = (position, elementHeight, viewportHeight) => {
246
- const trimmed = position.trim();
247
- assertNotClamped(trimmed);
248
- const viewportToken = trimmed.split(/\s+/)[1] ?? "top";
249
- const viewportClause = parseClauseToken(viewportToken, viewportHeight);
250
- return viewportHeight * viewportClause.fraction + viewportClause.offsetPx - resolveElementAnchor(trimmed, elementHeight);
692
+ const [elementToken, viewportToken = "top"] = splitClause(position);
693
+ return anchorWithin(viewportToken, viewportHeight) - anchorWithin(elementToken, elementHeight);
251
694
  };
252
695
  const DWELL_RELATIVE_RE = /^\+=(\d+(?:\.\d*)?|\.\d+)(%|px)?$/;
253
696
  const isDwellFormat = (resolved) => typeof resolved === "string" && DWELL_RELATIVE_RE.test(resolved.trim());
@@ -257,9 +700,7 @@ const prefixSpacedRelativeEnd = (start, endResolved) => {
257
700
  if (!trimmedEnd.startsWith("+=") || !/\s/.test(trimmedEnd)) return endResolved;
258
701
  const startResolved = resolveMaybeFn(start);
259
702
  if (typeof startResolved !== "string") return endResolved;
260
- const trimmedStart = startResolved.trim();
261
- assertNotClamped(trimmedStart);
262
- const [elementToken] = trimmedStart.split(/\s+/);
703
+ const [elementToken] = splitClause(startResolved);
263
704
  try {
264
705
  parseClauseToken(elementToken, 0);
265
706
  } catch (error) {
@@ -308,16 +749,18 @@ const classifyPosition = (resolved) => {
308
749
  };
309
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));
310
751
  const nestedIn = (measurements, index) => measurements.flatMap(({ triggerEnclosedBy }, k) => k !== index && triggerEnclosedBy.includes(index) ? [k] : []);
311
- const anchorShare = (measurements, windows, index, freezeStart, box, reachedAt, enclosedBy, anchorElement, order, ownIndex) => {
752
+ const anchorShare = ({ measurements, world, order, ownIndex }, index, freezeStart, box, reachedAt) => {
753
+ const { enclosedBy, anchorElement } = box;
312
754
  const measurement = measurements[index];
313
- if (enclosedBy.includes(index)) return (measurement.start.mode === "absolute" ? freezeStart - windows.reduce((earlier, other) => other.index !== index && other.index !== ownIndex && !(order && order.isBefore(ownIndex, other.index)) && other.freezeEnd <= freezeStart + .05 ? earlier + other.freezeEnd - other.freezeStart : earlier, 0) : measurement.triggerTop - measurement.start.anchorOffset) < reachedAt - .05 ? 1 : 0;
755
+ if (enclosedBy.includes(index)) return (measurement.start.mode === "absolute" ? world.unpaddedStart(index, ownIndex, freezeStart) : measurement.triggerTop - measurement.start.anchorOffset) < reachedAt - .05 ? 1 : 0;
314
756
  if (order && isHeldIn(measurements, index, enclosedBy, anchorElement, order)) return 0;
315
757
  if (box.nests.includes(index)) return box.fraction;
316
758
  return measurement.triggerTop + measurement.triggerHeight <= box.top + .05 ? 1 : 0;
317
759
  };
318
- const gapsBeforeEndAnchor = (measurements, 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;
319
762
  if (index === ownIndex || order && order.isBefore(ownIndex, index)) return total;
320
- const weight = anchorShare(measurements, windows, index, freezeStart, box, reachedAt, enclosedBy, anchorElement, order, ownIndex);
763
+ const weight = anchorShare(context, index, freezeStart, box, reachedAt);
321
764
  if (weight === 0) return total;
322
765
  counted?.add(index);
323
766
  return total + weight * (freezeEnd - freezeStart);
@@ -352,11 +795,11 @@ const clauseFreezeStart = (measurements, index, paddingOf) => {
352
795
  }
353
796
  throw new Error("StickyScrollTrigger: internal error: clauseFreezeStart was given a layer without a clause start.");
354
797
  };
355
- const runPass = (measurements, { viewportHeight, measureLiveEndTriggerTop }, previous, order, record) => {
798
+ const runPass = (measurements, { viewportHeight, measureLiveEndTriggerTop }, previous, order, world, record, previousOnly = false) => {
356
799
  const fresh = [];
357
800
  const knownWindows = () => measurements.flatMap((measurement, k) => {
358
801
  if (measurement.kind !== "scene") return [];
359
- const plan = fresh[k];
802
+ const plan = previousOnly ? null : fresh[k];
360
803
  if (plan) return [{
361
804
  index: k,
362
805
  freezeStart: plan.freezeStart,
@@ -370,7 +813,7 @@ const runPass = (measurements, { viewportHeight, measureLiveEndTriggerTop }, pre
370
813
  freezeEnd: freezeStart + paddingHeight
371
814
  }];
372
815
  });
373
- const paddingOf = (k) => fresh[k]?.paddingHeight ?? previous?.paddings[k] ?? 0;
816
+ const paddingOf = (k) => (previousOnly ? null : fresh[k]?.paddingHeight) ?? previous?.paddings[k] ?? 0;
374
817
  const recounts = [];
375
818
  const plans = measurements.map((measurement, index) => {
376
819
  fresh[index] = null;
@@ -381,77 +824,86 @@ const runPass = (measurements, { viewportHeight, measureLiveEndTriggerTop }, pre
381
824
  runs: []
382
825
  };
383
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
+ };
384
838
  const { start } = measurement;
385
- const freezeStart = start.mode === "absolute" ? start.value : clauseFreezeStart(measurements, index, paddingOf);
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
+ };
386
885
  let freezeEnd;
387
886
  switch (measurement.end.mode) {
388
887
  case "dwell":
389
888
  freezeEnd = freezeStart + measurement.end.distancePx;
390
889
  break;
391
- case "absolute":
392
- freezeEnd = Math.max(freezeStart, measurement.end.value);
890
+ case "absolute": {
891
+ const length = world.absoluteEndLength(index);
892
+ freezeEnd = length === null ? Math.max(freezeStart, measurement.end.value) : freezeStart + length;
393
893
  break;
894
+ }
394
895
  case "auto":
395
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.`);
396
897
  case "clause": {
397
- const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTriggerHeight, viewportHeight);
398
- if (measurement.endTriggerIsSelf) {
399
- const nests = nestedIn(measurements, index);
400
- const weight = resolveElementFraction(measurement.end.clause) - (start.mode === "clause" ? start.elementFraction : 0);
401
- const dwellInside = measurements.reduce((total, other, k) => {
402
- if (weight === 0 || other.kind !== "scene" || !nests.includes(k) || order && (order.isBefore(index, k) || isHeldIn(measurements, k, measurement.triggerEnclosedBy, index, order))) return total;
403
- recount.counted.add(k);
404
- return total + weight * paddingOf(k);
405
- }, 0);
406
- if (start.mode === "clause") {
407
- freezeEnd = freezeStart + Math.max(0, start.anchorOffset - anchorOffsetEnd + dwellInside);
408
- break;
409
- }
410
- const dwellAbove = measurements.reduce((total, other, k) => {
411
- 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;
412
- recount.counted.add(k);
413
- return total + paddingOf(k);
414
- }, 0);
415
- freezeEnd = Math.max(freezeStart, measurement.triggerTop - anchorOffsetEnd + dwellAbove + dwellInside);
416
- break;
417
- }
418
- let endTop;
419
- if (measurement.end.measureLive) endTop = measureLiveEndTriggerTop(index);
420
- else {
421
- const rawTop = measurement.endTriggerIndex === null ? measurement.end.rawTop : measurements[measurement.endTriggerIndex].triggerTop;
422
- if (rawTop === null) endTop = 0;
423
- else {
424
- const box = {
425
- top: rawTop,
426
- fraction: resolveElementFraction(measurement.end.clause),
427
- nests: measurement.endTriggerNests
428
- };
429
- const gaps = (w, counted) => gapsBeforeEndAnchor(measurements, w, box, rawTop - anchorOffsetEnd, measurement.endTriggerEnclosedBy, index, measurement.endTriggerIndex, order, counted);
430
- endTop = rawTop + gaps(knownWindows());
431
- recount.runs.push((w) => gaps(w, recount.counted));
432
- }
433
- }
434
- let layoutStart;
435
- if (start.mode === "absolute") layoutStart = start.value;
436
- else {
437
- const gaps = (w, counted) => gapsBeforeEndAnchor(measurements, w, {
438
- top: measurement.triggerTop,
439
- fraction: start.elementFraction,
440
- nests: nestedIn(measurements, index)
441
- }, measurement.triggerTop - start.anchorOffset, measurement.triggerEnclosedBy, index, index, order, counted);
442
- layoutStart = measurement.triggerTop - start.anchorOffset + gaps(knownWindows());
443
- recount.runs.push((w) => gaps(w, recount.counted));
444
- }
445
- 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);
446
900
  break;
447
901
  }
448
902
  }
449
- const paddingHeight = Math.max(0, freezeEnd - freezeStart);
450
903
  const plan = {
451
904
  freezeStart,
452
905
  freezeEnd,
453
- stickyTop: 0,
454
- paddingHeight
906
+ paddingHeight: Math.max(0, freezeEnd - freezeStart)
455
907
  };
456
908
  fresh[index] = plan;
457
909
  return plan;
@@ -486,15 +938,17 @@ const planCover = (measurements, index, windows, { viewportHeight, documentMaxSc
486
938
  freezeEnd = documentMaxScroll + measurement.end.offsetPx;
487
939
  break;
488
940
  case "clause": {
489
- const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTriggerHeight, viewportHeight);
941
+ const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTrigger.height, viewportHeight);
490
942
  if (measurement.end.measureLive) freezeEnd = measureLiveEndTriggerTop(index) - anchorOffsetEnd;
491
- 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);
492
944
  break;
493
945
  }
494
946
  }
495
947
  return {
496
948
  freezeStart,
497
949
  freezeEnd: Math.max(freezeStart, freezeEnd),
950
+ engagedStart: freezeStart,
951
+ engagedEnd: Math.max(freezeStart, freezeEnd),
498
952
  stickyTop: measurement.start.anchorOffset - (measurement.triggerTop - measurement.wrapperTop),
499
953
  paddingHeight: null
500
954
  };
@@ -549,8 +1003,67 @@ const fallbackOrder = (measurements, counted) => {
549
1003
  });
550
1004
  return { isBefore: (a, b) => rank[a] < rank[b] };
551
1005
  };
1006
+ const hasCycle = (scenes, edges) => {
1007
+ const component = componentsOf(edges);
1008
+ return new Set(scenes.map((k) => component[k])).size < scenes.length;
1009
+ };
1010
+ const refreshOrderEdges = (measurements, lengths, edges) => {
1011
+ const before = measurements.map(() => []);
1012
+ edges.forEach((movers, i) => {
1013
+ const measurement = measurements[i];
1014
+ const enclosingAnchor = (measurement.end.mode === "clause" && !measurement.endTrigger.isSelf ? measurement.endTrigger.enclosedBy : measurement.triggerEnclosedBy).filter((m) => m !== measurement.endTrigger.index);
1015
+ movers.forEach((k) => {
1016
+ if (lengths[k] <= .05) return;
1017
+ before[i].push(k);
1018
+ measurements[k].triggerEnclosedBy.forEach((m) => {
1019
+ if (m !== k && m !== i && measurements[m].kind === "scene" && !enclosingAnchor.includes(m)) before[m].push(k);
1020
+ });
1021
+ });
1022
+ });
1023
+ return before;
1024
+ };
1025
+ const placeWindows = (measurements, scenes, lengths, atWrittenEnd) => {
1026
+ const rest = new Set(scenes);
1027
+ const reported = [];
1028
+ const engaged = [];
1029
+ let consumed = 0;
1030
+ let frozenUntil = -Infinity;
1031
+ while (rest.size) {
1032
+ let next = -1;
1033
+ let opensAt = 0;
1034
+ let nextIsAbsolute = false;
1035
+ let nextReach = 0;
1036
+ for (const k of rest) {
1037
+ const { start, triggerTop } = measurements[k];
1038
+ const isAbsolute = start.mode === "absolute";
1039
+ const reach = start.mode === "clause" ? triggerTop - start.anchorOffset : 0;
1040
+ const at = start.mode === "absolute" ? start.value : reach + consumed;
1041
+ const tied = Math.abs(at - opensAt) <= TIE_TOLERANCE_PX;
1042
+ if (next === -1 || at < opensAt - .05 || tied && (isAbsolute ? !nextIsAbsolute || at < opensAt : !nextIsAbsolute && reach < nextReach - .05)) {
1043
+ next = k;
1044
+ opensAt = at;
1045
+ nextIsAbsolute = isAbsolute;
1046
+ nextReach = reach;
1047
+ }
1048
+ }
1049
+ const { end } = measurements[next];
1050
+ const reportedEnd = end.mode === "absolute" && atWrittenEnd(next) ? Math.max(opensAt, end.value) : opensAt + lengths[next];
1051
+ const engagedStart = Math.max(opensAt, frozenUntil);
1052
+ const engagedEnd = Math.max(engagedStart, reportedEnd);
1053
+ rest.delete(next);
1054
+ reported[next] = [opensAt, reportedEnd];
1055
+ engaged[next] = [engagedStart, engagedEnd];
1056
+ consumed += engagedEnd - engagedStart;
1057
+ frozenUntil = Math.max(frozenUntil, engagedEnd);
1058
+ }
1059
+ return {
1060
+ reported,
1061
+ engaged
1062
+ };
1063
+ };
552
1064
  const planLayers = (measurements, deps) => {
553
- const needsConvergence = measurements.filter(({ kind }) => kind === "scene").length > 1;
1065
+ const scenes = measurements.flatMap(({ kind }, k) => kind === "scene" ? [k] : []);
1066
+ const needsConvergence = scenes.length > 1;
554
1067
  const liveTopCache = new Map();
555
1068
  const passDeps = {
556
1069
  ...deps,
@@ -562,47 +1075,153 @@ const planLayers = (measurements, deps) => {
562
1075
  return value;
563
1076
  }
564
1077
  };
565
- const stateOf = (passPlans) => ({
566
- paddings: passPlans.map((plan) => plan?.paddingHeight ?? null),
567
- freezeStarts: passPlans.map((plan) => plan?.freezeStart ?? null)
568
- });
569
1078
  const sameValues = (a, b) => a.every((value, i) => value === b[i] || value !== null && b[i] !== null && Math.abs(value - b[i]) <= .05);
570
1079
  const sameState = (a, b) => sameValues(a.paddings, b.paddings) && sameValues(a.freezeStarts, b.freezeStarts);
571
- const average = (a, b) => a.map((value, i) => value === null ? null : (value + b[i]) / 2);
572
- const settle = (order, record) => {
573
- let plans = runPass(measurements, passDeps, null, order, record);
574
- if (!needsConvergence) return plans;
575
- const budget = order === null ? Math.max(64, 2 * measurements.length + 2) : 2 * measurements.length + 2;
576
- let fed = stateOf(plans);
577
- let fedBefore = null;
578
- for (let pass = 0; pass < budget; pass += 1) {
579
- plans = runPass(measurements, passDeps, fed, order, record);
580
- const out = stateOf(plans);
581
- if (sameState(out, fed)) return plans;
582
- const flipped = fedBefore !== null && sameState(out, fedBefore);
583
- fedBefore = fed;
584
- fed = flipped ? {
585
- paddings: average(out.paddings, fed.paddings),
586
- freezeStarts: average(out.freezeStarts, fed.freezeStarts)
587
- } : out;
1080
+ const lengthsOf = (windows) => windows.map((window) => window ? Math.max(0, window.freezeEnd - window.freezeStart) : 0);
1081
+ const stateAt = (lengths, reported) => ({
1082
+ paddings: measurements.map(({ kind }, k) => kind === "scene" ? lengths[k] : null),
1083
+ freezeStarts: measurements.map(({ kind }, k) => kind === "scene" ? reported[k][0] : null)
1084
+ });
1085
+ const mix = (states, weights) => {
1086
+ const of = (pick) => pick(states[0]).map((value, k) => value === null ? null : states.reduce((sum, state, j) => sum + weights[j] * pick(state)[k], 0));
1087
+ return {
1088
+ paddings: of((state) => state.paddings),
1089
+ freezeStarts: of((state) => state.freezeStarts)
1090
+ };
1091
+ };
1092
+ let world = null;
1093
+ const place = (lengths, order, reading) => {
1094
+ const placed = placeWindows(measurements, scenes, lengths, () => reading.endsAsRefreshed);
1095
+ world = {
1096
+ lengths,
1097
+ order,
1098
+ reported: placed.reported,
1099
+ refreshTime: []
1100
+ };
1101
+ return placed;
1102
+ };
1103
+ const refreshTimeOf = (own) => {
1104
+ if (world === null) return null;
1105
+ const { lengths, order, refreshTime } = world;
1106
+ const absent = (k) => k === own || order !== null && !order.isBefore(k, own);
1107
+ refreshTime[own] ??= placeWindows(measurements, scenes, lengths.map((length, k) => absent(k) ? 0 : length), (k) => !absent(k)).reported;
1108
+ return refreshTime[own];
1109
+ };
1110
+ const passWorld = (order, reading) => ({
1111
+ unpaddedStart: (index, ownIndex, freezeStart) => {
1112
+ const windows = (reading.startsAsRefreshed ? refreshTimeOf(ownIndex) : null) ?? world?.reported ?? [];
1113
+ const spans = scenes.flatMap((k) => {
1114
+ if (k === index || k === ownIndex || !windows[k]) return [];
1115
+ if (order && !order.isBefore(k, ownIndex)) return [];
1116
+ const [from, to] = windows[k];
1117
+ return Math.min(to, freezeStart) > from ? [[from, Math.min(to, freezeStart)]] : [];
1118
+ }).sort((a, b) => a[0] - b[0]);
1119
+ let frozen = 0;
1120
+ let frozenUntil = -Infinity;
1121
+ for (const [from, to] of spans) {
1122
+ const lo = Math.max(from, frozenUntil);
1123
+ if (to > lo) frozen += to - lo;
1124
+ frozenUntil = Math.max(frozenUntil, to);
1125
+ }
1126
+ return freezeStart - frozen;
1127
+ },
1128
+ absoluteEndLength: (index) => {
1129
+ const { end } = measurements[index];
1130
+ if (!reading.endsAsRefreshed || end.mode !== "absolute" || world === null) return null;
1131
+ const windows = world.order === null ? world.reported : refreshTimeOf(index);
1132
+ return Math.max(0, end.value - windows[index][0]);
1133
+ }
1134
+ });
1135
+ const solve = (order, reading, cap, record = null, cycle = 2, damping = 1) => {
1136
+ const reads = passWorld(order, reading);
1137
+ const fed = [];
1138
+ let previous = null;
1139
+ for (let pass = 0; pass < cap; pass += 1) {
1140
+ const lengths = lengthsOf(runPass(measurements, passDeps, previous, order, reads, record));
1141
+ const placed = place(lengths, order, reading);
1142
+ const next = stateAt(lengths, placed.reported);
1143
+ if (!needsConvergence || previous !== null && sameState(next, previous)) return {
1144
+ lengths,
1145
+ ...placed
1146
+ };
1147
+ let feed = next;
1148
+ if (previous !== null) {
1149
+ fed.push(previous);
1150
+ let back = -1;
1151
+ for (let j = 0; j < cycle - 1 && back === -1; j += 1) if (fed.length > j + 1 && sameState(next, fed[fed.length - j - 2])) back = j;
1152
+ if (back !== -1) {
1153
+ const states = [...fed.slice(fed.length - back - 1), next];
1154
+ feed = mix(states, states.map(() => 1 / states.length));
1155
+ } else if (damping < 1) feed = mix([next, previous], [damping, 1 - damping]);
1156
+ }
1157
+ previous = feed;
588
1158
  }
589
1159
  return null;
590
1160
  };
1161
+ const activeEdges = (lengths, reading) => {
1162
+ const reads = passWorld(null, reading);
1163
+ const respond = (from) => {
1164
+ const { reported } = place(from, null, reading);
1165
+ return lengthsOf(runPass(measurements, passDeps, stateAt(from, reported), null, reads, null, true));
1166
+ };
1167
+ const base = respond(lengths);
1168
+ const edges = measurements.map(() => []);
1169
+ scenes.forEach((k) => {
1170
+ const nudged = lengths.slice();
1171
+ nudged[k] += 2 ** -7;
1172
+ respond(nudged).forEach((length, i) => {
1173
+ if (i !== k && Math.abs(length - base[i]) > 1e-6) edges[i].push(k);
1174
+ });
1175
+ });
1176
+ return edges;
1177
+ };
1178
+ const unsettled = (solved) => solved === null || solved.reported.some((window) => window.some((point) => !(Math.abs(point) <= 2 ** 48)));
591
1179
  const counted = measurements.map(() => new Set());
592
- let settled = settle(null, (index, layers) => layers.forEach((k) => counted[index].add(k)));
593
- if (settled === null) settled = settle(fallbackOrder(measurements, counted), null);
594
- if (settled === null) throw new Error("StickyScrollTrigger: could not resolve endTrigger positions: some endTrigger references form a circular structural dependency that never settles. Point each endTrigger at an element that doesn't depend on it.");
595
- const plans = settled;
596
- const withTops = plans.map((plan, index) => {
597
- if (plan === null) return null;
598
- const outerDwell = plans.reduce((total, outer, k) => k > index && outer !== null && outer.freezeEnd <= plan.freezeStart + .05 ? total + outer.paddingHeight : total, 0);
1180
+ const everySpacer = {
1181
+ endsAsRefreshed: true,
1182
+ startsAsRefreshed: false
1183
+ };
1184
+ let solved = solve(null, everySpacer, Math.max(64, 2 * measurements.length + 2), (index, layers) => layers.forEach((k) => counted[index].add(k)));
1185
+ const fallback = () => {
1186
+ if (unsettled(solved)) return fallbackOrder(measurements, counted);
1187
+ if (!needsConvergence) return null;
1188
+ const edges = activeEdges(solved.lengths, everySpacer);
1189
+ if (hasCycle(scenes, edges)) return fallbackOrder(measurements, counted);
1190
+ return hasCycle(scenes, refreshOrderEdges(measurements, solved.lengths, edges)) ? { isBefore: (a, b) => a < b } : null;
1191
+ };
1192
+ const order = fallback();
1193
+ if (order) {
1194
+ const asReported = {
1195
+ endsAsRefreshed: false,
1196
+ startsAsRefreshed: false
1197
+ };
1198
+ solved = solve(order, asReported, 2 * measurements.length + 2);
1199
+ if (unsettled(solved)) solved = solve(order, asReported, Math.max(64, 2 * measurements.length + 2), null, 4, .5);
1200
+ if (unsettled(solved)) solved = solve(order, {
1201
+ endsAsRefreshed: true,
1202
+ startsAsRefreshed: true
1203
+ }, 2 * measurements.length + 2);
1204
+ }
1205
+ if (unsettled(solved)) throw new Error("StickyScrollTrigger: could not resolve endTrigger positions: some endTrigger references form a circular structural dependency that never settles. Point each endTrigger at an element that doesn't depend on it.");
1206
+ const { reported, engaged } = solved;
1207
+ const scenePlans = measurements.map(({ kind }, index) => {
1208
+ if (kind !== "scene") return null;
1209
+ const [engagedStart, engagedEnd] = engaged[index];
1210
+ const outerDwell = scenes.reduce((total, k) => k > index && engaged[k][1] <= engagedStart + .05 ? total + (engaged[k][1] - engaged[k][0]) : total, 0);
599
1211
  return {
600
- ...plan,
601
- stickyTop: deps.structureTop - (plan.freezeStart - outerDwell)
1212
+ freezeStart: reported[index][0],
1213
+ freezeEnd: reported[index][1],
1214
+ engagedStart,
1215
+ engagedEnd,
1216
+ stickyTop: deps.structureTop - (engagedStart - outerDwell),
1217
+ paddingHeight: engagedEnd - engagedStart
602
1218
  };
603
1219
  });
604
- const windows = withTops.filter((plan) => plan !== null);
605
- const finalPlans = withTops.map((plan, index) => plan ?? planCover(measurements, index, windows, passDeps));
1220
+ const windows = scenes.map((k) => ({
1221
+ freezeStart: engaged[k][0],
1222
+ freezeEnd: engaged[k][1]
1223
+ }));
1224
+ const finalPlans = scenePlans.map((plan, index) => plan ?? planCover(measurements, index, windows, passDeps));
606
1225
  finalPlans.forEach((plan, index) => deps.onPlanned(index, plan));
607
1226
  return finalPlans;
608
1227
  };
@@ -649,7 +1268,7 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
649
1268
  const snapshot = snapshots.get(target);
650
1269
  target.style.scrollMarginTop = snapshot ? snapshot.inline : "";
651
1270
  };
652
- const clearAnimation = () => {
1271
+ const stopRamps = () => {
653
1272
  if (sheet) {
654
1273
  document.adoptedStyleSheets = document.adoptedStyleSheets.filter((one) => one !== sheet);
655
1274
  sheet = null;
@@ -659,31 +1278,37 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
659
1278
  jsRamps = [];
660
1279
  jsHost = null;
661
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
+ };
662
1304
  return {
663
1305
  sync(scenes, host, measureNaturalTops) {
664
1306
  const ramps = scenes.filter((scene) => scene.freezeEnd > scene.freezeStart).sort((a, b) => a.freezeStart - b.freezeStart);
665
1307
  if (targetSelector === null || !ramps.length || !host) {
666
- written.forEach(restoreTarget);
667
- written = new Set();
668
- clearAnimation();
1308
+ release();
669
1309
  return;
670
1310
  }
671
- if (animationHost !== host) {
672
- animationHost?.removeAttribute(`data-${instanceId}`);
673
- animationHost = host;
674
- animationHost.setAttribute(`data-${instanceId}`, "");
675
- }
676
- if (usesJsRamp) {
677
- jsRamps = ramps;
678
- jsHost = host;
679
- applyJsRamp();
680
- } else {
681
- if (!sheet) {
682
- sheet = new CSSStyleSheet();
683
- document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
684
- }
685
- sheet.replaceSync(buildStylesheet(instanceId, ramps));
686
- }
1311
+ startRamps(ramps, host);
687
1312
  const targets = Array.from(rootElement.querySelectorAll(targetSelector));
688
1313
  const naturalTops = measureNaturalTops(targets);
689
1314
  targets.forEach((target) => {
@@ -710,9 +1335,7 @@ const createScrollMarginSync = (rootElement, targetSelector) => {
710
1335
  },
711
1336
  restore() {
712
1337
  if (usesJsRamp) window.removeEventListener("scroll", applyJsRamp);
713
- written.forEach(restoreTarget);
714
- written = new Set();
715
- clearAnimation();
1338
+ release();
716
1339
  }
717
1340
  };
718
1341
  };
@@ -730,7 +1353,7 @@ const buildStructure = (rootElement, layers) => {
730
1353
  let outermost = null;
731
1354
  for (const layer of layers) {
732
1355
  if (layer.kind !== "scene") continue;
733
- const wrapped = wrapScene(inner);
1356
+ const wrapped = wrapScene(inner, inner === rootElement);
734
1357
  layer.container = wrapped.container;
735
1358
  layer.wrapper = wrapped.wrapper;
736
1359
  layer.padding = wrapped.padding;
@@ -811,23 +1434,27 @@ const measureLayer = (rootElement, viewportHeight, layer, ownIndex, indexByTrigg
811
1434
  const endResolved = layer.end === null ? null : prefixSpacedRelativeEnd(startResolved, resolveMaybeFn(layer.end));
812
1435
  const elementHeight = measureUsedHeight(layer.trigger);
813
1436
  const endTriggerIsSelf = layer.endTrigger === layer.trigger;
1437
+ const indicesWhere = (test) => [...indexByTrigger].filter(([trigger]) => test(trigger)).map(([, index]) => index);
814
1438
  const endTriggerIndex = indexByTrigger.get(layer.endTrigger) ?? null;
815
1439
  const end = resolveEndSpec(rootElement, viewportHeight, layer, endResolved, ownIndex, endTriggerIndex);
1440
+ const endTriggerInContainer = end.mode === "clause" && !end.measureLive && !endTriggerIsSelf;
816
1441
  const start = resolveStartSpec(layer, startResolved, elementHeight, viewportHeight);
817
1442
  return {
818
1443
  kind: layer.kind,
819
1444
  start,
820
1445
  triggerTop: documentTop(layer.trigger),
821
1446
  triggerHeight: elementHeight,
822
- triggerEnclosedBy: [...indexByTrigger].filter(([trigger]) => trigger.contains(layer.trigger)).map(([, index]) => index),
1447
+ triggerEnclosedBy: indicesWhere((trigger) => trigger.contains(layer.trigger)),
823
1448
  wrapperTop: layer.wrapper ? documentTop(layer.wrapper) : 0,
824
1449
  coverTop: layer.kind === "cover" ? documentTop(layer.cover) : 0,
825
1450
  end,
826
- endTriggerIsSelf,
827
- endTriggerIndex,
828
- endTriggerHeight: end.mode === "clause" ? measureUsedHeight(layer.endTrigger) : 0,
829
- endTriggerEnclosedBy: end.mode === "clause" && !end.measureLive && !endTriggerIsSelf ? [...indexByTrigger].filter(([trigger]) => trigger.contains(layer.endTrigger)).map(([, index]) => index) : [],
830
- 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
+ }
831
1458
  };
832
1459
  };
833
1460
  const EXCLUDED_VAR_KEYS = [
@@ -860,6 +1487,10 @@ const resolvePinReleaseScroll = (endTrigger, classifiedEnd, engageScroll, viewpo
860
1487
  case "clause": return toScroll(endTrigger, documentTop(endTrigger) - resolveAnchorTop(classifiedEnd.value, measureUsedHeight(endTrigger), viewportHeight));
861
1488
  }
862
1489
  };
1490
+ const removeItem = (list, item) => {
1491
+ const index = list.indexOf(item);
1492
+ if (index !== -1) list.splice(index, 1);
1493
+ };
863
1494
  const hasDuplicateTrigger = (list, trigger) => list.some((existing) => existing.trigger === trigger);
864
1495
  var StickyScrollTrigger = class {
865
1496
  #rootElement;
@@ -874,6 +1505,7 @@ var StickyScrollTrigger = class {
874
1505
  #scrollTriggerClass = null;
875
1506
  #pinLayers = [];
876
1507
  #scrollMarginSync;
1508
+ #dormancyClient = null;
877
1509
  constructor(root, options = {}) {
878
1510
  this.#rootElement = resolveRoot(root);
879
1511
  const scrollMarginTargets = options.scrollMarginTargets === void 0 ? "[id]" : options.scrollMarginTargets;
@@ -882,7 +1514,26 @@ var StickyScrollTrigger = class {
882
1514
  } catch {
883
1515
  throw new Error(`StickyScrollTrigger: scrollMarginTargets "${scrollMarginTargets}" is not a valid CSS selector.`);
884
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)}.`);
885
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] : []);
886
1537
  }
887
1538
  #unbuild() {
888
1539
  if (!this.#built) return;
@@ -921,7 +1572,12 @@ var StickyScrollTrigger = class {
921
1572
  throw error;
922
1573
  });
923
1574
  }
924
- return result;
1575
+ const restoreDormancy = takeGsapRefreshRestore();
1576
+ if (!restoreDormancy) return result;
1577
+ return { render: (time) => {
1578
+ result?.render?.(time);
1579
+ restoreDormancy();
1580
+ } };
925
1581
  };
926
1582
  }
927
1583
  #wrapUnwrappedPins() {
@@ -953,34 +1609,17 @@ var StickyScrollTrigger = class {
953
1609
  }
954
1610
  #unwrapPinLayer(layer) {
955
1611
  if (!layer.outer) return false;
1612
+ releaseDormant([layer.trigger]);
956
1613
  unwrapPin(layer.outer, layer.trigger, layer.savedPosition);
957
1614
  layer.outer = null;
958
1615
  layer.inner = null;
959
1616
  return true;
960
1617
  }
961
1618
  #resetSceneCoverStickyState() {
962
- const wrapperSnapshots = this.#layers.map((layer) => layer.wrapper).filter((wrapper) => wrapper !== null).map((wrapper) => ({
963
- wrapper,
964
- position: wrapper.style.position,
965
- top: wrapper.style.top
966
- }));
967
- wrapperSnapshots.forEach(({ wrapper }) => resetStickyPosition(wrapper));
968
- return () => {
969
- wrapperSnapshots.forEach(({ wrapper, position, top }) => {
970
- wrapper.style.position = position;
971
- wrapper.style.top = top;
972
- });
973
- };
1619
+ return stripStickyPositions(this.#layers.flatMap(({ wrapper }) => wrapper ? [wrapper] : []));
974
1620
  }
975
1621
  #resetPinStickyState() {
976
- const snapshots = this.#pinLayers.filter((layer) => layer.inner).map(({ trigger }) => ({
977
- trigger,
978
- position: captureInlinePosition(trigger)
979
- }));
980
- snapshots.forEach(({ trigger }) => resetStickyPosition(trigger));
981
- return () => {
982
- snapshots.forEach(({ trigger, position }) => restoreInlinePosition(trigger, position));
983
- };
1622
+ return stripStickyPositions(this.#wrappedPinTriggers());
984
1623
  }
985
1624
  #resetStickyState() {
986
1625
  const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
@@ -1035,7 +1674,7 @@ var StickyScrollTrigger = class {
1035
1674
  const topPx = resolveAnchorTop(classifiedStart.value, triggerHeight, viewportHeight);
1036
1675
  const toScroll = (element, reachedAt) => this.#addDwellBeforeReach(element, reachedAt);
1037
1676
  const releaseScroll = resolvePinReleaseScroll(layer.endTrigger, classifiedEnd, toScroll(layer.trigger, triggerTop - topPx), viewportHeight, toScroll);
1038
- const height = releaseScroll - (this.#rootElement.contains(layer.trigger) ? dwellConsumedAt(releaseScroll, this.#sceneLayers()) : 0) - triggerTop + topPx + triggerHeight + triggerMarginBottom;
1677
+ const height = releaseScroll - (this.#rootElement.contains(layer.trigger) ? dwellConsumedAt(releaseScroll, this.#engagedWindows()) : 0) - triggerTop + topPx + triggerHeight + triggerMarginBottom;
1039
1678
  const room = documentHeight > 0 ? documentHeight - triggerTop : Infinity;
1040
1679
  applyStickyPosition(layer.trigger, topPx);
1041
1680
  layer.inner.style.height = `${Math.max(0, Math.min(height, room))}px`;
@@ -1073,6 +1712,8 @@ var StickyScrollTrigger = class {
1073
1712
  const layer = active[index];
1074
1713
  layer.freezeStart = plan.freezeStart;
1075
1714
  layer.freezeEnd = plan.freezeEnd;
1715
+ layer.engagedStart = plan.engagedStart;
1716
+ layer.engagedEnd = plan.engagedEnd;
1076
1717
  if (!layer.wrapper) return;
1077
1718
  applyStickyPosition(layer.wrapper, plan.stickyTop);
1078
1719
  if (layer.kind === "scene" && layer.padding && plan.paddingHeight !== null) layer.padding.style.height = `${plan.paddingHeight}px`;
@@ -1086,6 +1727,23 @@ var StickyScrollTrigger = class {
1086
1727
  }
1087
1728
  refresh() {
1088
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() {
1089
1747
  if (this.#dirty || !this.#built || isDomOrderStale(this.#layers)) {
1090
1748
  this.#unbuild();
1091
1749
  this.#build();
@@ -1115,10 +1773,7 @@ var StickyScrollTrigger = class {
1115
1773
  });
1116
1774
  }
1117
1775
  #syncScrollMargins() {
1118
- this.#scrollMarginSync.sync(this.#sceneLayers().map(({ freezeStart, freezeEnd }) => ({
1119
- freezeStart,
1120
- freezeEnd
1121
- })), this.#outermostContainer, (targets) => {
1776
+ this.#scrollMarginSync.sync(this.#engagedWindows(), this.#outermostContainer, (targets) => {
1122
1777
  if (!targets.length) return [];
1123
1778
  const restoreStickyState = this.#resetStickyState();
1124
1779
  const tops = targets.map((target) => documentTop(target));
@@ -1157,8 +1812,7 @@ var StickyScrollTrigger = class {
1157
1812
  invalidateOnRefresh: rest.invalidateOnRefresh ?? true,
1158
1813
  onKill: (self) => {
1159
1814
  this.#captureScrollTriggerClass(self);
1160
- const index = this.#layers.indexOf(layer);
1161
- if (index !== -1) this.#layers.splice(index, 1);
1815
+ removeItem(this.#layers, layer);
1162
1816
  this.#dirty = true;
1163
1817
  this.#scheduleRebuild();
1164
1818
  onKill?.(self);
@@ -1181,7 +1835,9 @@ var StickyScrollTrigger = class {
1181
1835
  start,
1182
1836
  end,
1183
1837
  freezeStart: 0,
1184
- freezeEnd: 0
1838
+ freezeEnd: 0,
1839
+ engagedStart: 0,
1840
+ engagedEnd: 0
1185
1841
  }, onKill, rest);
1186
1842
  }
1187
1843
  createOverlapScroll({ trigger: triggerInput, cover, start = "bottom bottom", end = null, endTrigger: endTriggerInput, onKill, ...rest }) {
@@ -1201,7 +1857,9 @@ var StickyScrollTrigger = class {
1201
1857
  start,
1202
1858
  end,
1203
1859
  freezeStart: 0,
1204
- freezeEnd: 0
1860
+ freezeEnd: 0,
1861
+ engagedStart: 0,
1862
+ engagedEnd: 0
1205
1863
  };
1206
1864
  const vars = this.#registerLayer(layer, (self) => {
1207
1865
  this.#coverRestoreByLayer.get(layer)?.();
@@ -1234,8 +1892,7 @@ var StickyScrollTrigger = class {
1234
1892
  trigger,
1235
1893
  onKill: (self) => {
1236
1894
  this.#captureScrollTriggerClass(self);
1237
- const index = this.#pinLayers.indexOf(layer);
1238
- if (index !== -1) this.#pinLayers.splice(index, 1);
1895
+ removeItem(this.#pinLayers, layer);
1239
1896
  if (this.#unwrapPinLayer(layer)) this.#scheduleRebuild();
1240
1897
  onKill?.(self);
1241
1898
  },
@@ -1263,10 +1920,13 @@ var StickyScrollTrigger = class {
1263
1920
  }
1264
1921
  #addDwellBeforeReach(element, reachedAt) {
1265
1922
  if (!this.#rootElement.contains(element)) return reachedAt;
1266
- return reachedAt + dwellBeforeReach(reachedAt, this.#sceneLayers());
1923
+ return reachedAt + dwellBeforeReach(reachedAt, this.#engagedWindows());
1267
1924
  }
1268
- #sceneLayers() {
1269
- return this.#layers.filter((layer) => layer.kind === "scene");
1925
+ #engagedWindows() {
1926
+ return this.#layers.flatMap((layer) => layer.kind === "scene" ? [{
1927
+ freezeStart: layer.engagedStart,
1928
+ freezeEnd: layer.engagedEnd
1929
+ }] : []);
1270
1930
  }
1271
1931
  static getScrollTop(elementInput, instances) {
1272
1932
  const element = resolveElement(elementInput, "StickyScrollTrigger.getScrollTop");
@@ -1296,6 +1956,7 @@ var StickyScrollTrigger = class {
1296
1956
  destroy() {
1297
1957
  if (this.#destroyed) return;
1298
1958
  this.#destroyed = true;
1959
+ unregisterDormancyClient(this.#dormancyClient);
1299
1960
  this.#scrollMarginSync.restore();
1300
1961
  this.#restoreCoverLifts();
1301
1962
  this.#unbuild();