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
@@ -99,7 +99,12 @@ var StickyScrollTrigger = (function() {
99
99
  el.style.position = saved.position;
100
100
  el.style.top = saved.top;
101
101
  };
102
- const wrapScene = (inner) => {
102
+ const stripStickyPositions = (elements) => {
103
+ const saved = elements.map(captureInlinePosition);
104
+ elements.forEach(resetStickyPosition);
105
+ return () => elements.forEach((el, i) => restoreInlinePosition(el, saved[i]));
106
+ };
107
+ const wrapScene = (inner, holdTrailingMargin) => {
103
108
  if (!inner.parentNode) throw new Error(`StickyScrollTrigger: ${describeElement(inner)} is not attached to the document`);
104
109
  const container = document.createElement("div");
105
110
  const wrapper = document.createElement("div");
@@ -110,6 +115,11 @@ var StickyScrollTrigger = (function() {
110
115
  container.appendChild(wrapper);
111
116
  wrapper.appendChild(inner);
112
117
  container.appendChild(padding);
118
+ if (holdTrailingMargin) {
119
+ const sentinel = document.createElement("div");
120
+ sentinel.style.display = "flow-root";
121
+ wrapper.appendChild(sentinel);
122
+ }
113
123
  return {
114
124
  container,
115
125
  wrapper,
@@ -196,6 +206,438 @@ var StickyScrollTrigger = (function() {
196
206
  lifted.length = 0;
197
207
  };
198
208
  };
209
+ const AUTO_MIN_DEPTH = 7;
210
+ const MAX_CHAIN_IN_BAND = 4;
211
+ const BUFFER_FLOOR_PX = 325;
212
+ const BUFFER_STEP_PX = 25;
213
+ 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);
214
+ const mergeIntervals = (intervals) => {
215
+ const sorted = intervals.filter(([a, b]) => b > a).sort((x, y) => x[0] - y[0]);
216
+ const merged = [];
217
+ sorted.forEach(([a, b]) => {
218
+ const last = merged.at(-1);
219
+ if (last && a <= last[1]) last[1] = Math.max(last[1], b);
220
+ else merged.push([a, b]);
221
+ });
222
+ return merged;
223
+ };
224
+ const invertStuckUnion = (union, y, inclusive) => {
225
+ let scroll = y;
226
+ for (const [a, b] of union) if (inclusive ? a <= scroll : a < scroll) scroll += b - a;
227
+ else break;
228
+ return scroll;
229
+ };
230
+ const isTransformed = (style) => [
231
+ style.transform,
232
+ style.translate,
233
+ style.scale,
234
+ style.rotate
235
+ ].some((value) => value !== void 0 && value !== "" && value !== "none");
236
+ const hasTransform = (el, memo) => {
237
+ if (!el) return false;
238
+ const known = memo.get(el);
239
+ if (known !== void 0) return known;
240
+ const result = isTransformed(getComputedStyle(el)) || hasTransform(el.parentElement, memo);
241
+ memo.set(el, result);
242
+ return result;
243
+ };
244
+ const scrolls = (style) => ![style.overflowX, style.overflowY].every((v) => v === "visible" || v === "clip");
245
+ const bodyScrolls = () => scrolls(getComputedStyle(document.documentElement)) && scrolls(getComputedStyle(document.body));
246
+ const isInsideScroller = (el, memo) => {
247
+ const node = el.parentElement;
248
+ if (!node || node === document.body || node === document.documentElement) return false;
249
+ const known = memo.get(node);
250
+ if (known !== void 0) return known;
251
+ const style = getComputedStyle(node);
252
+ const result = style.position === "fixed" || scrolls(style) || isInsideScroller(node, memo);
253
+ memo.set(node, result);
254
+ return result;
255
+ };
256
+ const ownedDepth = (owned, demoted) => {
257
+ const levels = new Map();
258
+ const levelsUpFrom = (node) => {
259
+ if (!node) return 0;
260
+ const known = levels.get(node);
261
+ if (known !== void 0) return known;
262
+ const level = (demoted.has(node) || getComputedStyle(node).position === "sticky" ? 1 : 0) + levelsUpFrom(node.parentElement);
263
+ levels.set(node, level);
264
+ return level;
265
+ };
266
+ const scrollerMemo = new Map();
267
+ let depth = 0;
268
+ for (const el of owned) {
269
+ if (!el.isConnected || isInsideScroller(el, scrollerMemo)) continue;
270
+ depth = Math.max(depth, 1 + levelsUpFrom(el.parentElement));
271
+ }
272
+ return depth;
273
+ };
274
+ const SIMPLE_TOP = /^-?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?(px|%)$/i;
275
+ const clients = new Set();
276
+ let records = [];
277
+ let buffer = 0;
278
+ let listening = false;
279
+ let scrollBeforeGsapRefresh = null;
280
+ let gsapPhase = "idle";
281
+ let adoptedMidRefresh = false;
282
+ let scannedThisTask = null;
283
+ const gsapClasses = new Set();
284
+ const gsapRefreshing = () => Array.from(gsapClasses).some((cls) => cls.isRefreshing === true);
285
+ const stateAt = (record, scroll) => {
286
+ if (!record.demotable) return "in";
287
+ if (scroll < record.lo - buffer) return "before";
288
+ return scroll > record.hi + buffer && !record.holdsAfter ? "after" : "in";
289
+ };
290
+ const promote = (record, afterMeasure = false) => {
291
+ const { style } = record.el;
292
+ const demoted = record.state !== "in";
293
+ const positionOurs = afterMeasure && style.position === "static" || demoted && style.position === "relative";
294
+ if (positionOurs) style.position = record.position;
295
+ if (demoted && positionOurs && style.top === record.demotedTop) style.top = record.top;
296
+ if (demoted && record.zIndexAuto && style.zIndex === "0") style.zIndex = record.zIndex;
297
+ if (demoted && record.willChangeAuto && style.willChange === "opacity") style.willChange = record.willChange;
298
+ record.state = "in";
299
+ };
300
+ const applyState = (record, state) => {
301
+ if (record.state === state) return;
302
+ if (state === "in") {
303
+ promote(record);
304
+ return;
305
+ }
306
+ const { style } = record.el;
307
+ style.position = "relative";
308
+ style.top = `${state === "before" ? 0 : record.travel}px`;
309
+ record.demotedTop = style.top;
310
+ if (record.zIndexAuto) style.zIndex = "0";
311
+ if (record.willChangeAuto) style.willChange = "opacity";
312
+ record.state = state;
313
+ };
314
+ const update = (scroll) => {
315
+ records.forEach((record) => applyState(record, stateAt(record, scroll)));
316
+ };
317
+ const onScroll = () => update(window.scrollY);
318
+ const listen = (on) => {
319
+ if (on === listening) return;
320
+ listening = on;
321
+ if (on) window.addEventListener("scroll", onScroll, { passive: true });
322
+ else window.removeEventListener("scroll", onScroll);
323
+ };
324
+ const clearTable = () => {
325
+ records.forEach((record) => promote(record));
326
+ records = [];
327
+ listen(false);
328
+ };
329
+ const restoreAfterGsapMeasure = () => {
330
+ const scroll = scrollBeforeGsapRefresh;
331
+ if (gsapPhase !== "measuring" || scroll === null) return;
332
+ gsapPhase = "restored";
333
+ if (records.length) update(scroll);
334
+ };
335
+ const endGsapRefresh = () => {
336
+ gsapPhase = "idle";
337
+ scrollBeforeGsapRefresh = null;
338
+ adoptedMidRefresh = false;
339
+ };
340
+ const rebuildSafely = () => {
341
+ try {
342
+ rebuildDormancy(null);
343
+ } catch (error) {
344
+ clearTable();
345
+ queueMicrotask(() => {
346
+ throw error;
347
+ });
348
+ }
349
+ };
350
+ const onGsapRefreshDone = () => {
351
+ const wasRefreshing = gsapPhase !== "idle";
352
+ endGsapRefresh();
353
+ if (wasRefreshing && liveClients().length) rebuildSafely();
354
+ };
355
+ const onGsapRefreshInit = () => {
356
+ if (gsapPhase === "idle") {
357
+ gsapPhase = "measuring";
358
+ scrollBeforeGsapRefresh = window.scrollY;
359
+ queueMicrotask(onGsapRefreshDone);
360
+ if (records.length) update(0);
361
+ }
362
+ return { render: restoreAfterGsapMeasure };
363
+ };
364
+ const adoptGsapClass = (cls) => {
365
+ if (gsapClasses.has(cls)) return;
366
+ if (cls.isRefreshing === true) adoptedMidRefresh = true;
367
+ gsapClasses.add(cls);
368
+ cls.addEventListener?.("refresh", onGsapRefreshDone);
369
+ cls.addEventListener?.("refreshInit", onGsapRefreshInit);
370
+ };
371
+ const dropGsapClassesLater = () => {
372
+ if (!gsapClasses.size) return;
373
+ queueMicrotask(() => {
374
+ if (liveClients().length) return;
375
+ gsapClasses.forEach((cls) => {
376
+ cls.removeEventListener?.("refresh", onGsapRefreshDone);
377
+ cls.removeEventListener?.("refreshInit", onGsapRefreshInit);
378
+ });
379
+ gsapClasses.clear();
380
+ });
381
+ };
382
+ const scanStickyElements = (owned) => {
383
+ const scrollerMemo = new Map();
384
+ const isWindowSticky = (el) => el.isConnected && getComputedStyle(el).position === "sticky" && !isInsideScroller(el, scrollerMemo);
385
+ if (scannedThisTask) return Array.from(new Set([
386
+ ...scannedThisTask,
387
+ ...records.map((r) => r.el),
388
+ ...owned
389
+ ])).filter(isWindowSticky);
390
+ const found = Array.from(document.querySelectorAll("*")).filter(isWindowSticky);
391
+ scannedThisTask = found;
392
+ queueMicrotask(() => {
393
+ scannedThisTask = null;
394
+ });
395
+ return found;
396
+ };
397
+ const maxChainInBand = (b, maxScroll) => {
398
+ const bands = records.flatMap((r) => {
399
+ const band = r.demotable ? [Math.max(0, r.lo - b), Math.min(maxScroll, r.hi + (r.holdsAfter ? Infinity : b))] : [0, maxScroll];
400
+ return band[1] >= band[0] ? [{
401
+ record: r,
402
+ start: band[0],
403
+ end: band[1]
404
+ }] : [];
405
+ });
406
+ let max = 0;
407
+ new Set([0, ...bands.filter(({ record }) => record.demotable).map(({ start }) => start)]).forEach((scroll) => {
408
+ const inBand = new Set(bands.filter(({ start, end }) => start <= scroll && scroll <= end).map(({ record }) => record));
409
+ inBand.forEach((r) => {
410
+ max = Math.max(max, 1 + r.ancestors.filter((a) => inBand.has(a)).length);
411
+ });
412
+ });
413
+ return max;
414
+ };
415
+ const chooseBuffer = (viewportHeight, maxScroll) => {
416
+ let low = Math.ceil(BUFFER_FLOOR_PX / BUFFER_STEP_PX);
417
+ let high = Math.floor(viewportHeight / BUFFER_STEP_PX);
418
+ if (high < low || maxChainInBand(low * BUFFER_STEP_PX, maxScroll) > MAX_CHAIN_IN_BAND) return BUFFER_FLOOR_PX;
419
+ while (low < high) {
420
+ const mid = Math.ceil((low + high) / 2);
421
+ if (maxChainInBand(mid * BUFFER_STEP_PX, maxScroll) <= MAX_CHAIN_IN_BAND) low = mid;
422
+ else high = mid - 1;
423
+ }
424
+ return low * BUFFER_STEP_PX;
425
+ };
426
+ const liveClients = () => {
427
+ const live = [];
428
+ clients.forEach((ref) => {
429
+ const client = ref.deref();
430
+ if (!client) {
431
+ clients.delete(ref);
432
+ return;
433
+ }
434
+ const owned = client.ownedElements();
435
+ if (owned.some((el) => el.isConnected)) live.push({
436
+ client,
437
+ owned
438
+ });
439
+ });
440
+ return live;
441
+ };
442
+ const measureStatic = (all, owned, unmodeled) => {
443
+ const scroll = window.scrollY;
444
+ const viewportHeight = document.documentElement.clientHeight || window.innerHeight;
445
+ const transformMemo = new Map();
446
+ const documentHeight = measureDocumentHeight();
447
+ all.forEach((record) => {
448
+ const { el } = record;
449
+ const rect = el.getBoundingClientRect();
450
+ const computed = getComputedStyle(el);
451
+ const parent = el.parentElement;
452
+ let containerBottom = rect.bottom + scroll;
453
+ if (parent) {
454
+ const parentStyle = getComputedStyle(parent);
455
+ containerBottom = parent.getBoundingClientRect().bottom + scroll - parseFloat(parentStyle.borderBottomWidth) - parseFloat(parentStyle.paddingBottom);
456
+ if (parentStyle.display === "contents" || parentStyle.display === "inline") unmodeled.add(record);
457
+ }
458
+ record.naturalTop = rect.top + scroll;
459
+ record.travel = Math.max(0, containerBottom - (record.naturalTop + rect.height + parseFloat(computed.marginBottom)));
460
+ record.overflowBottom = record.naturalTop + el.clientTop + el.scrollHeight;
461
+ if (computed.position !== "static" || hasTransform(el, transformMemo)) unmodeled.add(record);
462
+ if (computed.bottom !== "auto" || computed.left !== "auto" || computed.right !== "auto") unmodeled.add(record);
463
+ if (owned.has(el) && (!computed.top.endsWith("px") || Math.abs(parseFloat(computed.top) - parseFloat(el.style.top)) > .01)) unmodeled.add(record);
464
+ if (!owned.has(el) && computed.top === "auto") {
465
+ record.stickyTop = 0;
466
+ record.travel = 0;
467
+ } else if (!owned.has(el)) {
468
+ const unit = SIMPLE_TOP.exec(computed.top)?.[1];
469
+ if (!unit) unmodeled.add(record);
470
+ else if (unit === "%") record.stickyTop = parseFloat(computed.top) * viewportHeight / 100;
471
+ else record.stickyTop = parseFloat(computed.top);
472
+ }
473
+ });
474
+ return {
475
+ scroll,
476
+ viewportHeight,
477
+ documentHeight
478
+ };
479
+ };
480
+ const teardown = () => {
481
+ clearTable();
482
+ endGsapRefresh();
483
+ dropGsapClassesLater();
484
+ };
485
+ const rebuildDormancy = (scrollTriggerClass) => {
486
+ const live = liveClients();
487
+ if (!live.length) {
488
+ teardown();
489
+ return;
490
+ }
491
+ if (scrollTriggerClass) adoptGsapClass(scrollTriggerClass);
492
+ if (!gsapRefreshing()) endGsapRefresh();
493
+ if (!gsapClasses.size || bodyScrolls()) {
494
+ clearTable();
495
+ return;
496
+ }
497
+ const owned = new Map();
498
+ live.forEach(({ client, owned: elements }) => {
499
+ elements.forEach((el) => owned.set(el, client));
500
+ });
501
+ const autoOnly = live.every(({ client }) => client.mode === "auto");
502
+ const demoted = new Set(records.filter((r) => r.state !== "in").map((r) => r.el));
503
+ if (autoOnly && ownedDepth(owned.keys(), demoted) < AUTO_MIN_DEPTH) {
504
+ clearTable();
505
+ return;
506
+ }
507
+ const sticky = scanStickyElements(owned.keys());
508
+ const stickySet = new Set(sticky);
509
+ const leftover = records.filter((r) => r.state !== "in" && !stickySet.has(r.el));
510
+ leftover.filter((r) => !r.el.isConnected).forEach((r) => promote(r));
511
+ const kept = leftover.filter((r) => r.el.isConnected);
512
+ const previous = new Map(records.map((r) => [r.el, r]));
513
+ const found = [...sticky.map((el) => {
514
+ const computed = getComputedStyle(el);
515
+ const before = previous.get(el);
516
+ if (before && before.state !== "in") return {
517
+ ...before,
518
+ demotable: false,
519
+ position: el.style.position,
520
+ top: el.style.top,
521
+ stickyTop: parseFloat(el.style.top) || 0,
522
+ ancestors: [],
523
+ state: "before"
524
+ };
525
+ return {
526
+ el,
527
+ demotable: false,
528
+ position: el.style.position,
529
+ top: el.style.top,
530
+ zIndex: el.style.zIndex,
531
+ willChange: el.style.willChange,
532
+ zIndexAuto: computed.zIndex === "auto",
533
+ willChangeAuto: computed.willChange === "auto",
534
+ stickyTop: parseFloat(el.style.top) || 0,
535
+ naturalTop: 0,
536
+ travel: 0,
537
+ ancestors: [],
538
+ lo: 0,
539
+ hi: 0,
540
+ overflowBottom: 0,
541
+ holdsAfter: false,
542
+ state: "in",
543
+ demotedTop: ""
544
+ };
545
+ }), ...kept];
546
+ found.sort((a, b) => compareDocumentOrder(a.el, b.el));
547
+ found.forEach((record, index) => {
548
+ record.ancestors = found.slice(0, index).filter((a) => a.el.contains(record.el));
549
+ });
550
+ const holdsOwned = new Set();
551
+ found.forEach((record) => {
552
+ if (owned.has(record.el)) record.ancestors.forEach((a) => holdsOwned.add(a));
553
+ });
554
+ const all = found.filter((r) => owned.has(r.el) || holdsOwned.has(r) || r.state !== "in" || r.ancestors.some((a) => owned.has(a.el)));
555
+ const inTable = new Set(all);
556
+ all.forEach((record) => {
557
+ record.ancestors = record.ancestors.filter((a) => inTable.has(a));
558
+ });
559
+ const depths = new Map();
560
+ all.forEach((record) => {
561
+ const client = owned.get(record.el);
562
+ if (client) depths.set(client, Math.max(depths.get(client) ?? 0, record.ancestors.length + 1));
563
+ });
564
+ const active = new Set(live.map(({ client }) => client).filter((client) => client.mode === "always" || (depths.get(client) ?? 0) >= AUTO_MIN_DEPTH));
565
+ all.forEach((record) => {
566
+ const client = owned.get(record.el);
567
+ record.demotable = client !== void 0 && active.has(client);
568
+ });
569
+ records = all;
570
+ if (!all.some((r) => r.demotable)) {
571
+ clearTable();
572
+ return;
573
+ }
574
+ const toMeasure = all.filter((r) => owned.has(r.el) || holdsOwned.has(r) || r.state !== "in");
575
+ const authorStyle = new Map(toMeasure.filter((r) => !owned.has(r.el) && r.state === "in").map(({ el }) => [el, el.getAttribute("style")]));
576
+ const restorePositions = () => toMeasure.forEach((record) => {
577
+ if (!authorStyle.has(record.el)) {
578
+ promote(record, true);
579
+ return;
580
+ }
581
+ const saved = authorStyle.get(record.el);
582
+ if (saved === null || saved === void 0) record.el.removeAttribute("style");
583
+ else record.el.setAttribute("style", saved);
584
+ });
585
+ toMeasure.forEach(({ el }) => {
586
+ el.style.position = "static";
587
+ });
588
+ const unmodeled = new Set();
589
+ let measured;
590
+ try {
591
+ measured = measureStatic(toMeasure, owned, unmodeled);
592
+ } finally {
593
+ restorePositions();
594
+ }
595
+ const { scroll, viewportHeight, documentHeight } = measured;
596
+ const maxScroll = Math.max(0, documentHeight - viewportHeight);
597
+ all.forEach((record) => {
598
+ const union = mergeIntervals(record.ancestors.map((a) => [a.lo, a.hi]));
599
+ const reach = record.naturalTop - record.stickyTop;
600
+ record.lo = invertStuckUnion(union, reach, true);
601
+ record.hi = invertStuckUnion(union, reach + record.travel, false);
602
+ if (unmodeled.has(record) || record.ancestors.some((a) => unmodeled.has(a))) record.demotable = false;
603
+ const carried = record.ancestors.filter((a) => a.demotable && !a.holdsAfter).reduce((sum, a) => sum + a.travel, 0);
604
+ record.holdsAfter = record.overflowBottom + record.travel + carried > documentHeight + 1;
605
+ });
606
+ buffer = chooseBuffer(viewportHeight, maxScroll);
607
+ update(gsapPhase === "measuring" ? 0 : (gsapPhase === "restored" ? scrollBeforeGsapRefresh : null) ?? scroll);
608
+ listen(true);
609
+ };
610
+ const takeGsapRefreshRestore = () => adoptedMidRefresh && gsapRefreshing() ? onGsapRefreshInit().render : null;
611
+ const clearDormancy = clearTable;
612
+ const releaseDormant = (elements) => {
613
+ const released = new Set(elements);
614
+ records = records.filter((record) => {
615
+ if (!released.has(record.el)) return true;
616
+ promote(record);
617
+ return false;
618
+ });
619
+ };
620
+ const registerDormancyClient = (client) => {
621
+ clients.add(new WeakRef(client));
622
+ };
623
+ let rebuildQueued = false;
624
+ const queueRebuild = () => {
625
+ if (rebuildQueued) return;
626
+ rebuildQueued = true;
627
+ queueMicrotask(() => {
628
+ rebuildQueued = false;
629
+ rebuildSafely();
630
+ });
631
+ };
632
+ const unregisterDormancyClient = (client) => {
633
+ clients.forEach((ref) => {
634
+ if (ref.deref() !== client) return;
635
+ clients.delete(ref);
636
+ releaseDormant(client.ownedElements());
637
+ });
638
+ if (liveClients().length) queueRebuild();
639
+ else teardown();
640
+ };
199
641
  const resolveMaybeFn = (value) => typeof value === "function" ? value() : value;
200
642
  const KEYWORD_FRACTIONS = {
201
643
  top: 0,
@@ -236,19 +678,20 @@ var StickyScrollTrigger = (function() {
236
678
  const inner = trimmed.slice(6).replace(/\)$/, "").trim();
237
679
  throw new Error(`StickyScrollTrigger: unsupported position clause "${trimmed}": GSAP's clamp() wrapper isn't supported here.` + (inner ? ` Did you mean "${inner}"?` : ""));
238
680
  };
239
- const resolveElementAnchor = (position, elementHeight) => {
681
+ const splitClause = (position) => {
240
682
  const trimmed = position.trim();
241
683
  assertNotClamped(trimmed);
242
- const elementClause = parseClauseToken(trimmed.split(/\s+/)[0], elementHeight);
243
- return elementHeight * elementClause.fraction + elementClause.offsetPx;
684
+ return trimmed.split(/\s+/);
244
685
  };
686
+ const anchorWithin = (token, size) => {
687
+ const { fraction, offsetPx } = parseClauseToken(token, size);
688
+ return size * fraction + offsetPx;
689
+ };
690
+ const resolveElementAnchor = (position, elementHeight) => anchorWithin(splitClause(position)[0], elementHeight);
245
691
  const resolveElementFraction = (position) => resolveElementAnchor(position, 1) - resolveElementAnchor(position, 0);
246
692
  const resolveAnchorTop = (position, elementHeight, viewportHeight) => {
247
- const trimmed = position.trim();
248
- assertNotClamped(trimmed);
249
- const viewportToken = trimmed.split(/\s+/)[1] ?? "top";
250
- const viewportClause = parseClauseToken(viewportToken, viewportHeight);
251
- return viewportHeight * viewportClause.fraction + viewportClause.offsetPx - resolveElementAnchor(trimmed, elementHeight);
693
+ const [elementToken, viewportToken = "top"] = splitClause(position);
694
+ return anchorWithin(viewportToken, viewportHeight) - anchorWithin(elementToken, elementHeight);
252
695
  };
253
696
  const DWELL_RELATIVE_RE = /^\+=(\d+(?:\.\d*)?|\.\d+)(%|px)?$/;
254
697
  const isDwellFormat = (resolved) => typeof resolved === "string" && DWELL_RELATIVE_RE.test(resolved.trim());
@@ -258,9 +701,7 @@ var StickyScrollTrigger = (function() {
258
701
  if (!trimmedEnd.startsWith("+=") || !/\s/.test(trimmedEnd)) return endResolved;
259
702
  const startResolved = resolveMaybeFn(start);
260
703
  if (typeof startResolved !== "string") return endResolved;
261
- const trimmedStart = startResolved.trim();
262
- assertNotClamped(trimmedStart);
263
- const [elementToken] = trimmedStart.split(/\s+/);
704
+ const [elementToken] = splitClause(startResolved);
264
705
  try {
265
706
  parseClauseToken(elementToken, 0);
266
707
  } catch (error) {
@@ -309,16 +750,18 @@ var StickyScrollTrigger = (function() {
309
750
  };
310
751
  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));
311
752
  const nestedIn = (measurements, index) => measurements.flatMap(({ triggerEnclosedBy }, k) => k !== index && triggerEnclosedBy.includes(index) ? [k] : []);
312
- const anchorShare = (measurements, windows, index, freezeStart, box, reachedAt, enclosedBy, anchorElement, order, ownIndex) => {
753
+ const anchorShare = ({ measurements, world, order, ownIndex }, index, freezeStart, box, reachedAt) => {
754
+ const { enclosedBy, anchorElement } = box;
313
755
  const measurement = measurements[index];
314
- 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;
756
+ if (enclosedBy.includes(index)) return (measurement.start.mode === "absolute" ? world.unpaddedStart(index, ownIndex, freezeStart) : measurement.triggerTop - measurement.start.anchorOffset) < reachedAt - .05 ? 1 : 0;
315
757
  if (order && isHeldIn(measurements, index, enclosedBy, anchorElement, order)) return 0;
316
758
  if (box.nests.includes(index)) return box.fraction;
317
759
  return measurement.triggerTop + measurement.triggerHeight <= box.top + .05 ? 1 : 0;
318
760
  };
319
- const gapsBeforeEndAnchor = (measurements, windows, box, reachedAt, enclosedBy, ownIndex, anchorElement, order, counted) => windows.reduce((total, { index, freezeStart, freezeEnd }) => {
761
+ const gapsBeforeEndAnchor = (context, windows, box, reachedAt, counted) => windows.reduce((total, { index, freezeStart, freezeEnd }) => {
762
+ const { ownIndex, order } = context;
320
763
  if (index === ownIndex || order && order.isBefore(ownIndex, index)) return total;
321
- const weight = anchorShare(measurements, windows, index, freezeStart, box, reachedAt, enclosedBy, anchorElement, order, ownIndex);
764
+ const weight = anchorShare(context, index, freezeStart, box, reachedAt);
322
765
  if (weight === 0) return total;
323
766
  counted?.add(index);
324
767
  return total + weight * (freezeEnd - freezeStart);
@@ -353,11 +796,11 @@ var StickyScrollTrigger = (function() {
353
796
  }
354
797
  throw new Error("StickyScrollTrigger: internal error: clauseFreezeStart was given a layer without a clause start.");
355
798
  };
356
- const runPass = (measurements, { viewportHeight, measureLiveEndTriggerTop }, previous, order, record) => {
799
+ const runPass = (measurements, { viewportHeight, measureLiveEndTriggerTop }, previous, order, world, record, previousOnly = false) => {
357
800
  const fresh = [];
358
801
  const knownWindows = () => measurements.flatMap((measurement, k) => {
359
802
  if (measurement.kind !== "scene") return [];
360
- const plan = fresh[k];
803
+ const plan = previousOnly ? null : fresh[k];
361
804
  if (plan) return [{
362
805
  index: k,
363
806
  freezeStart: plan.freezeStart,
@@ -371,7 +814,7 @@ var StickyScrollTrigger = (function() {
371
814
  freezeEnd: freezeStart + paddingHeight
372
815
  }];
373
816
  });
374
- const paddingOf = (k) => fresh[k]?.paddingHeight ?? previous?.paddings[k] ?? 0;
817
+ const paddingOf = (k) => (previousOnly ? null : fresh[k]?.paddingHeight) ?? previous?.paddings[k] ?? 0;
375
818
  const recounts = [];
376
819
  const plans = measurements.map((measurement, index) => {
377
820
  fresh[index] = null;
@@ -382,77 +825,86 @@ var StickyScrollTrigger = (function() {
382
825
  runs: []
383
826
  };
384
827
  recounts.push(recount);
828
+ const context = {
829
+ measurements,
830
+ world,
831
+ order,
832
+ ownIndex: index
833
+ };
834
+ const gapsOf = (box, reachedAt) => {
835
+ const gaps = (w, counted) => gapsBeforeEndAnchor(context, w, box, reachedAt, counted);
836
+ recount.runs.push((w) => gaps(w, recount.counted));
837
+ return gaps(knownWindows());
838
+ };
385
839
  const { start } = measurement;
386
- const freezeStart = start.mode === "absolute" ? start.value : clauseFreezeStart(measurements, index, paddingOf);
840
+ const freezeStart = start.mode === "absolute" ? start.value : previous?.freezeStarts[index] ?? clauseFreezeStart(measurements, index, paddingOf);
841
+ const heldBack = (k) => order !== null && (order.isBefore(index, k) || isHeldIn(measurements, k, measurement.triggerEnclosedBy, index, order));
842
+ const selfClauseEnd = (end, anchorOffsetEnd) => {
843
+ const nests = nestedIn(measurements, index);
844
+ const weight = resolveElementFraction(end.clause) - (start.mode === "clause" ? start.elementFraction : 0);
845
+ const dwellInside = measurements.reduce((total, other, k) => {
846
+ if (weight === 0 || other.kind !== "scene" || !nests.includes(k) || heldBack(k)) return total;
847
+ recount.counted.add(k);
848
+ return total + weight * paddingOf(k);
849
+ }, 0);
850
+ if (start.mode === "clause") return freezeStart + Math.max(0, start.anchorOffset - anchorOffsetEnd + dwellInside);
851
+ const dwellAbove = measurements.reduce((total, other, k) => {
852
+ if (k === index || other.kind !== "scene" || nests.includes(k) || other.triggerTop + other.triggerHeight > measurement.triggerTop + .05 || heldBack(k)) return total;
853
+ recount.counted.add(k);
854
+ return total + paddingOf(k);
855
+ }, 0);
856
+ return Math.max(freezeStart, measurement.triggerTop - anchorOffsetEnd + dwellAbove + dwellInside);
857
+ };
858
+ const elementClauseEnd = (end, anchorOffsetEnd) => {
859
+ let endTop;
860
+ if (end.measureLive) endTop = measureLiveEndTriggerTop(index);
861
+ else {
862
+ const rawTop = measurement.endTrigger.index === null ? end.rawTop : measurements[measurement.endTrigger.index].triggerTop;
863
+ if (rawTop === null) endTop = 0;
864
+ else {
865
+ const box = {
866
+ top: rawTop,
867
+ fraction: resolveElementFraction(end.clause),
868
+ nests: measurement.endTrigger.nests,
869
+ enclosedBy: measurement.endTrigger.enclosedBy,
870
+ anchorElement: measurement.endTrigger.index
871
+ };
872
+ endTop = rawTop + gapsOf(box, rawTop - anchorOffsetEnd);
873
+ }
874
+ }
875
+ let layoutStart;
876
+ if (start.mode === "absolute") layoutStart = start.value;
877
+ else layoutStart = measurement.triggerTop - start.anchorOffset + gapsOf({
878
+ top: measurement.triggerTop,
879
+ fraction: start.elementFraction,
880
+ nests: nestedIn(measurements, index),
881
+ enclosedBy: measurement.triggerEnclosedBy,
882
+ anchorElement: index
883
+ }, measurement.triggerTop - start.anchorOffset);
884
+ return freezeStart + Math.max(0, endTop - anchorOffsetEnd - layoutStart);
885
+ };
387
886
  let freezeEnd;
388
887
  switch (measurement.end.mode) {
389
888
  case "dwell":
390
889
  freezeEnd = freezeStart + measurement.end.distancePx;
391
890
  break;
392
- case "absolute":
393
- freezeEnd = Math.max(freezeStart, measurement.end.value);
891
+ case "absolute": {
892
+ const length = world.absoluteEndLength(index);
893
+ freezeEnd = length === null ? Math.max(freezeStart, measurement.end.value) : freezeStart + length;
394
894
  break;
895
+ }
395
896
  case "auto":
396
897
  case "max": throw new Error(`StickyScrollTrigger: internal error: a Scene layer reached '${measurement.end.mode}' end mode, which only a cover layer can have.`);
397
898
  case "clause": {
398
- const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTriggerHeight, viewportHeight);
399
- if (measurement.endTriggerIsSelf) {
400
- const nests = nestedIn(measurements, index);
401
- const weight = resolveElementFraction(measurement.end.clause) - (start.mode === "clause" ? start.elementFraction : 0);
402
- const dwellInside = measurements.reduce((total, other, k) => {
403
- if (weight === 0 || other.kind !== "scene" || !nests.includes(k) || order && (order.isBefore(index, k) || isHeldIn(measurements, k, measurement.triggerEnclosedBy, index, order))) return total;
404
- recount.counted.add(k);
405
- return total + weight * paddingOf(k);
406
- }, 0);
407
- if (start.mode === "clause") {
408
- freezeEnd = freezeStart + Math.max(0, start.anchorOffset - anchorOffsetEnd + dwellInside);
409
- break;
410
- }
411
- const dwellAbove = measurements.reduce((total, other, k) => {
412
- 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;
413
- recount.counted.add(k);
414
- return total + paddingOf(k);
415
- }, 0);
416
- freezeEnd = Math.max(freezeStart, measurement.triggerTop - anchorOffsetEnd + dwellAbove + dwellInside);
417
- break;
418
- }
419
- let endTop;
420
- if (measurement.end.measureLive) endTop = measureLiveEndTriggerTop(index);
421
- else {
422
- const rawTop = measurement.endTriggerIndex === null ? measurement.end.rawTop : measurements[measurement.endTriggerIndex].triggerTop;
423
- if (rawTop === null) endTop = 0;
424
- else {
425
- const box = {
426
- top: rawTop,
427
- fraction: resolveElementFraction(measurement.end.clause),
428
- nests: measurement.endTriggerNests
429
- };
430
- const gaps = (w, counted) => gapsBeforeEndAnchor(measurements, w, box, rawTop - anchorOffsetEnd, measurement.endTriggerEnclosedBy, index, measurement.endTriggerIndex, order, counted);
431
- endTop = rawTop + gaps(knownWindows());
432
- recount.runs.push((w) => gaps(w, recount.counted));
433
- }
434
- }
435
- let layoutStart;
436
- if (start.mode === "absolute") layoutStart = start.value;
437
- else {
438
- const gaps = (w, counted) => gapsBeforeEndAnchor(measurements, w, {
439
- top: measurement.triggerTop,
440
- fraction: start.elementFraction,
441
- nests: nestedIn(measurements, index)
442
- }, measurement.triggerTop - start.anchorOffset, measurement.triggerEnclosedBy, index, index, order, counted);
443
- layoutStart = measurement.triggerTop - start.anchorOffset + gaps(knownWindows());
444
- recount.runs.push((w) => gaps(w, recount.counted));
445
- }
446
- freezeEnd = freezeStart + Math.max(0, endTop - anchorOffsetEnd - layoutStart);
899
+ const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTrigger.height, viewportHeight);
900
+ freezeEnd = measurement.endTrigger.isSelf ? selfClauseEnd(measurement.end, anchorOffsetEnd) : elementClauseEnd(measurement.end, anchorOffsetEnd);
447
901
  break;
448
902
  }
449
903
  }
450
- const paddingHeight = Math.max(0, freezeEnd - freezeStart);
451
904
  const plan = {
452
905
  freezeStart,
453
906
  freezeEnd,
454
- stickyTop: 0,
455
- paddingHeight
907
+ paddingHeight: Math.max(0, freezeEnd - freezeStart)
456
908
  };
457
909
  fresh[index] = plan;
458
910
  return plan;
@@ -487,15 +939,17 @@ var StickyScrollTrigger = (function() {
487
939
  freezeEnd = documentMaxScroll + measurement.end.offsetPx;
488
940
  break;
489
941
  case "clause": {
490
- const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTriggerHeight, viewportHeight);
942
+ const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTrigger.height, viewportHeight);
491
943
  if (measurement.end.measureLive) freezeEnd = measureLiveEndTriggerTop(index) - anchorOffsetEnd;
492
- else freezeEnd = reached((measurement.endTriggerIsSelf ? measurement.triggerTop : measurement.endTriggerIndex === null ? measurement.end.rawTop ?? 0 : measurements[measurement.endTriggerIndex].triggerTop) - anchorOffsetEnd);
944
+ else freezeEnd = reached((measurement.endTrigger.isSelf ? measurement.triggerTop : measurement.endTrigger.index === null ? measurement.end.rawTop ?? 0 : measurements[measurement.endTrigger.index].triggerTop) - anchorOffsetEnd);
493
945
  break;
494
946
  }
495
947
  }
496
948
  return {
497
949
  freezeStart,
498
950
  freezeEnd: Math.max(freezeStart, freezeEnd),
951
+ engagedStart: freezeStart,
952
+ engagedEnd: Math.max(freezeStart, freezeEnd),
499
953
  stickyTop: measurement.start.anchorOffset - (measurement.triggerTop - measurement.wrapperTop),
500
954
  paddingHeight: null
501
955
  };
@@ -550,8 +1004,67 @@ var StickyScrollTrigger = (function() {
550
1004
  });
551
1005
  return { isBefore: (a, b) => rank[a] < rank[b] };
552
1006
  };
1007
+ const hasCycle = (scenes, edges) => {
1008
+ const component = componentsOf(edges);
1009
+ return new Set(scenes.map((k) => component[k])).size < scenes.length;
1010
+ };
1011
+ const refreshOrderEdges = (measurements, lengths, edges) => {
1012
+ const before = measurements.map(() => []);
1013
+ edges.forEach((movers, i) => {
1014
+ const measurement = measurements[i];
1015
+ const enclosingAnchor = (measurement.end.mode === "clause" && !measurement.endTrigger.isSelf ? measurement.endTrigger.enclosedBy : measurement.triggerEnclosedBy).filter((m) => m !== measurement.endTrigger.index);
1016
+ movers.forEach((k) => {
1017
+ if (lengths[k] <= .05) return;
1018
+ before[i].push(k);
1019
+ measurements[k].triggerEnclosedBy.forEach((m) => {
1020
+ if (m !== k && m !== i && measurements[m].kind === "scene" && !enclosingAnchor.includes(m)) before[m].push(k);
1021
+ });
1022
+ });
1023
+ });
1024
+ return before;
1025
+ };
1026
+ const placeWindows = (measurements, scenes, lengths, atWrittenEnd) => {
1027
+ const rest = new Set(scenes);
1028
+ const reported = [];
1029
+ const engaged = [];
1030
+ let consumed = 0;
1031
+ let frozenUntil = -Infinity;
1032
+ while (rest.size) {
1033
+ let next = -1;
1034
+ let opensAt = 0;
1035
+ let nextIsAbsolute = false;
1036
+ let nextReach = 0;
1037
+ for (const k of rest) {
1038
+ const { start, triggerTop } = measurements[k];
1039
+ const isAbsolute = start.mode === "absolute";
1040
+ const reach = start.mode === "clause" ? triggerTop - start.anchorOffset : 0;
1041
+ const at = start.mode === "absolute" ? start.value : reach + consumed;
1042
+ const tied = Math.abs(at - opensAt) <= TIE_TOLERANCE_PX;
1043
+ if (next === -1 || at < opensAt - .05 || tied && (isAbsolute ? !nextIsAbsolute || at < opensAt : !nextIsAbsolute && reach < nextReach - .05)) {
1044
+ next = k;
1045
+ opensAt = at;
1046
+ nextIsAbsolute = isAbsolute;
1047
+ nextReach = reach;
1048
+ }
1049
+ }
1050
+ const { end } = measurements[next];
1051
+ const reportedEnd = end.mode === "absolute" && atWrittenEnd(next) ? Math.max(opensAt, end.value) : opensAt + lengths[next];
1052
+ const engagedStart = Math.max(opensAt, frozenUntil);
1053
+ const engagedEnd = Math.max(engagedStart, reportedEnd);
1054
+ rest.delete(next);
1055
+ reported[next] = [opensAt, reportedEnd];
1056
+ engaged[next] = [engagedStart, engagedEnd];
1057
+ consumed += engagedEnd - engagedStart;
1058
+ frozenUntil = Math.max(frozenUntil, engagedEnd);
1059
+ }
1060
+ return {
1061
+ reported,
1062
+ engaged
1063
+ };
1064
+ };
553
1065
  const planLayers = (measurements, deps) => {
554
- const needsConvergence = measurements.filter(({ kind }) => kind === "scene").length > 1;
1066
+ const scenes = measurements.flatMap(({ kind }, k) => kind === "scene" ? [k] : []);
1067
+ const needsConvergence = scenes.length > 1;
555
1068
  const liveTopCache = new Map();
556
1069
  const passDeps = {
557
1070
  ...deps,
@@ -563,47 +1076,153 @@ var StickyScrollTrigger = (function() {
563
1076
  return value;
564
1077
  }
565
1078
  };
566
- const stateOf = (passPlans) => ({
567
- paddings: passPlans.map((plan) => plan?.paddingHeight ?? null),
568
- freezeStarts: passPlans.map((plan) => plan?.freezeStart ?? null)
569
- });
570
1079
  const sameValues = (a, b) => a.every((value, i) => value === b[i] || value !== null && b[i] !== null && Math.abs(value - b[i]) <= .05);
571
1080
  const sameState = (a, b) => sameValues(a.paddings, b.paddings) && sameValues(a.freezeStarts, b.freezeStarts);
572
- const average = (a, b) => a.map((value, i) => value === null ? null : (value + b[i]) / 2);
573
- const settle = (order, record) => {
574
- let plans = runPass(measurements, passDeps, null, order, record);
575
- if (!needsConvergence) return plans;
576
- const budget = order === null ? Math.max(64, 2 * measurements.length + 2) : 2 * measurements.length + 2;
577
- let fed = stateOf(plans);
578
- let fedBefore = null;
579
- for (let pass = 0; pass < budget; pass += 1) {
580
- plans = runPass(measurements, passDeps, fed, order, record);
581
- const out = stateOf(plans);
582
- if (sameState(out, fed)) return plans;
583
- const flipped = fedBefore !== null && sameState(out, fedBefore);
584
- fedBefore = fed;
585
- fed = flipped ? {
586
- paddings: average(out.paddings, fed.paddings),
587
- freezeStarts: average(out.freezeStarts, fed.freezeStarts)
588
- } : out;
1081
+ const lengthsOf = (windows) => windows.map((window) => window ? Math.max(0, window.freezeEnd - window.freezeStart) : 0);
1082
+ const stateAt = (lengths, reported) => ({
1083
+ paddings: measurements.map(({ kind }, k) => kind === "scene" ? lengths[k] : null),
1084
+ freezeStarts: measurements.map(({ kind }, k) => kind === "scene" ? reported[k][0] : null)
1085
+ });
1086
+ const mix = (states, weights) => {
1087
+ const of = (pick) => pick(states[0]).map((value, k) => value === null ? null : states.reduce((sum, state, j) => sum + weights[j] * pick(state)[k], 0));
1088
+ return {
1089
+ paddings: of((state) => state.paddings),
1090
+ freezeStarts: of((state) => state.freezeStarts)
1091
+ };
1092
+ };
1093
+ let world = null;
1094
+ const place = (lengths, order, reading) => {
1095
+ const placed = placeWindows(measurements, scenes, lengths, () => reading.endsAsRefreshed);
1096
+ world = {
1097
+ lengths,
1098
+ order,
1099
+ reported: placed.reported,
1100
+ refreshTime: []
1101
+ };
1102
+ return placed;
1103
+ };
1104
+ const refreshTimeOf = (own) => {
1105
+ if (world === null) return null;
1106
+ const { lengths, order, refreshTime } = world;
1107
+ const absent = (k) => k === own || order !== null && !order.isBefore(k, own);
1108
+ refreshTime[own] ??= placeWindows(measurements, scenes, lengths.map((length, k) => absent(k) ? 0 : length), (k) => !absent(k)).reported;
1109
+ return refreshTime[own];
1110
+ };
1111
+ const passWorld = (order, reading) => ({
1112
+ unpaddedStart: (index, ownIndex, freezeStart) => {
1113
+ const windows = (reading.startsAsRefreshed ? refreshTimeOf(ownIndex) : null) ?? world?.reported ?? [];
1114
+ const spans = scenes.flatMap((k) => {
1115
+ if (k === index || k === ownIndex || !windows[k]) return [];
1116
+ if (order && !order.isBefore(k, ownIndex)) return [];
1117
+ const [from, to] = windows[k];
1118
+ return Math.min(to, freezeStart) > from ? [[from, Math.min(to, freezeStart)]] : [];
1119
+ }).sort((a, b) => a[0] - b[0]);
1120
+ let frozen = 0;
1121
+ let frozenUntil = -Infinity;
1122
+ for (const [from, to] of spans) {
1123
+ const lo = Math.max(from, frozenUntil);
1124
+ if (to > lo) frozen += to - lo;
1125
+ frozenUntil = Math.max(frozenUntil, to);
1126
+ }
1127
+ return freezeStart - frozen;
1128
+ },
1129
+ absoluteEndLength: (index) => {
1130
+ const { end } = measurements[index];
1131
+ if (!reading.endsAsRefreshed || end.mode !== "absolute" || world === null) return null;
1132
+ const windows = world.order === null ? world.reported : refreshTimeOf(index);
1133
+ return Math.max(0, end.value - windows[index][0]);
1134
+ }
1135
+ });
1136
+ const solve = (order, reading, cap, record = null, cycle = 2, damping = 1) => {
1137
+ const reads = passWorld(order, reading);
1138
+ const fed = [];
1139
+ let previous = null;
1140
+ for (let pass = 0; pass < cap; pass += 1) {
1141
+ const lengths = lengthsOf(runPass(measurements, passDeps, previous, order, reads, record));
1142
+ const placed = place(lengths, order, reading);
1143
+ const next = stateAt(lengths, placed.reported);
1144
+ if (!needsConvergence || previous !== null && sameState(next, previous)) return {
1145
+ lengths,
1146
+ ...placed
1147
+ };
1148
+ let feed = next;
1149
+ if (previous !== null) {
1150
+ fed.push(previous);
1151
+ let back = -1;
1152
+ 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;
1153
+ if (back !== -1) {
1154
+ const states = [...fed.slice(fed.length - back - 1), next];
1155
+ feed = mix(states, states.map(() => 1 / states.length));
1156
+ } else if (damping < 1) feed = mix([next, previous], [damping, 1 - damping]);
1157
+ }
1158
+ previous = feed;
589
1159
  }
590
1160
  return null;
591
1161
  };
1162
+ const activeEdges = (lengths, reading) => {
1163
+ const reads = passWorld(null, reading);
1164
+ const respond = (from) => {
1165
+ const { reported } = place(from, null, reading);
1166
+ return lengthsOf(runPass(measurements, passDeps, stateAt(from, reported), null, reads, null, true));
1167
+ };
1168
+ const base = respond(lengths);
1169
+ const edges = measurements.map(() => []);
1170
+ scenes.forEach((k) => {
1171
+ const nudged = lengths.slice();
1172
+ nudged[k] += 2 ** -7;
1173
+ respond(nudged).forEach((length, i) => {
1174
+ if (i !== k && Math.abs(length - base[i]) > 1e-6) edges[i].push(k);
1175
+ });
1176
+ });
1177
+ return edges;
1178
+ };
1179
+ const unsettled = (solved) => solved === null || solved.reported.some((window) => window.some((point) => !(Math.abs(point) <= 2 ** 48)));
592
1180
  const counted = measurements.map(() => new Set());
593
- let settled = settle(null, (index, layers) => layers.forEach((k) => counted[index].add(k)));
594
- if (settled === null) settled = settle(fallbackOrder(measurements, counted), null);
595
- 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.");
596
- const plans = settled;
597
- const withTops = plans.map((plan, index) => {
598
- if (plan === null) return null;
599
- const outerDwell = plans.reduce((total, outer, k) => k > index && outer !== null && outer.freezeEnd <= plan.freezeStart + .05 ? total + outer.paddingHeight : total, 0);
1181
+ const everySpacer = {
1182
+ endsAsRefreshed: true,
1183
+ startsAsRefreshed: false
1184
+ };
1185
+ let solved = solve(null, everySpacer, Math.max(64, 2 * measurements.length + 2), (index, layers) => layers.forEach((k) => counted[index].add(k)));
1186
+ const fallback = () => {
1187
+ if (unsettled(solved)) return fallbackOrder(measurements, counted);
1188
+ if (!needsConvergence) return null;
1189
+ const edges = activeEdges(solved.lengths, everySpacer);
1190
+ if (hasCycle(scenes, edges)) return fallbackOrder(measurements, counted);
1191
+ return hasCycle(scenes, refreshOrderEdges(measurements, solved.lengths, edges)) ? { isBefore: (a, b) => a < b } : null;
1192
+ };
1193
+ const order = fallback();
1194
+ if (order) {
1195
+ const asReported = {
1196
+ endsAsRefreshed: false,
1197
+ startsAsRefreshed: false
1198
+ };
1199
+ solved = solve(order, asReported, 2 * measurements.length + 2);
1200
+ if (unsettled(solved)) solved = solve(order, asReported, Math.max(64, 2 * measurements.length + 2), null, 4, .5);
1201
+ if (unsettled(solved)) solved = solve(order, {
1202
+ endsAsRefreshed: true,
1203
+ startsAsRefreshed: true
1204
+ }, 2 * measurements.length + 2);
1205
+ }
1206
+ 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.");
1207
+ const { reported, engaged } = solved;
1208
+ const scenePlans = measurements.map(({ kind }, index) => {
1209
+ if (kind !== "scene") return null;
1210
+ const [engagedStart, engagedEnd] = engaged[index];
1211
+ const outerDwell = scenes.reduce((total, k) => k > index && engaged[k][1] <= engagedStart + .05 ? total + (engaged[k][1] - engaged[k][0]) : total, 0);
600
1212
  return {
601
- ...plan,
602
- stickyTop: deps.structureTop - (plan.freezeStart - outerDwell)
1213
+ freezeStart: reported[index][0],
1214
+ freezeEnd: reported[index][1],
1215
+ engagedStart,
1216
+ engagedEnd,
1217
+ stickyTop: deps.structureTop - (engagedStart - outerDwell),
1218
+ paddingHeight: engagedEnd - engagedStart
603
1219
  };
604
1220
  });
605
- const windows = withTops.filter((plan) => plan !== null);
606
- const finalPlans = withTops.map((plan, index) => plan ?? planCover(measurements, index, windows, passDeps));
1221
+ const windows = scenes.map((k) => ({
1222
+ freezeStart: engaged[k][0],
1223
+ freezeEnd: engaged[k][1]
1224
+ }));
1225
+ const finalPlans = scenePlans.map((plan, index) => plan ?? planCover(measurements, index, windows, passDeps));
607
1226
  finalPlans.forEach((plan, index) => deps.onPlanned(index, plan));
608
1227
  return finalPlans;
609
1228
  };
@@ -650,7 +1269,7 @@ var StickyScrollTrigger = (function() {
650
1269
  const snapshot = snapshots.get(target);
651
1270
  target.style.scrollMarginTop = snapshot ? snapshot.inline : "";
652
1271
  };
653
- const clearAnimation = () => {
1272
+ const stopRamps = () => {
654
1273
  if (sheet) {
655
1274
  document.adoptedStyleSheets = document.adoptedStyleSheets.filter((one) => one !== sheet);
656
1275
  sheet = null;
@@ -660,31 +1279,37 @@ var StickyScrollTrigger = (function() {
660
1279
  jsRamps = [];
661
1280
  jsHost = null;
662
1281
  };
1282
+ const startRamps = (ramps, host) => {
1283
+ if (animationHost !== host) {
1284
+ animationHost?.removeAttribute(`data-${instanceId}`);
1285
+ animationHost = host;
1286
+ animationHost.setAttribute(`data-${instanceId}`, "");
1287
+ }
1288
+ if (usesJsRamp) {
1289
+ jsRamps = ramps;
1290
+ jsHost = host;
1291
+ applyJsRamp();
1292
+ return;
1293
+ }
1294
+ if (!sheet) {
1295
+ sheet = new CSSStyleSheet();
1296
+ document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
1297
+ }
1298
+ sheet.replaceSync(buildStylesheet(instanceId, ramps));
1299
+ };
1300
+ const release = () => {
1301
+ written.forEach(restoreTarget);
1302
+ written = new Set();
1303
+ stopRamps();
1304
+ };
663
1305
  return {
664
1306
  sync(scenes, host, measureNaturalTops) {
665
1307
  const ramps = scenes.filter((scene) => scene.freezeEnd > scene.freezeStart).sort((a, b) => a.freezeStart - b.freezeStart);
666
1308
  if (targetSelector === null || !ramps.length || !host) {
667
- written.forEach(restoreTarget);
668
- written = new Set();
669
- clearAnimation();
1309
+ release();
670
1310
  return;
671
1311
  }
672
- if (animationHost !== host) {
673
- animationHost?.removeAttribute(`data-${instanceId}`);
674
- animationHost = host;
675
- animationHost.setAttribute(`data-${instanceId}`, "");
676
- }
677
- if (usesJsRamp) {
678
- jsRamps = ramps;
679
- jsHost = host;
680
- applyJsRamp();
681
- } else {
682
- if (!sheet) {
683
- sheet = new CSSStyleSheet();
684
- document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
685
- }
686
- sheet.replaceSync(buildStylesheet(instanceId, ramps));
687
- }
1312
+ startRamps(ramps, host);
688
1313
  const targets = Array.from(rootElement.querySelectorAll(targetSelector));
689
1314
  const naturalTops = measureNaturalTops(targets);
690
1315
  targets.forEach((target) => {
@@ -711,9 +1336,7 @@ var StickyScrollTrigger = (function() {
711
1336
  },
712
1337
  restore() {
713
1338
  if (usesJsRamp) window.removeEventListener("scroll", applyJsRamp);
714
- written.forEach(restoreTarget);
715
- written = new Set();
716
- clearAnimation();
1339
+ release();
717
1340
  }
718
1341
  };
719
1342
  };
@@ -731,7 +1354,7 @@ var StickyScrollTrigger = (function() {
731
1354
  let outermost = null;
732
1355
  for (const layer of layers) {
733
1356
  if (layer.kind !== "scene") continue;
734
- const wrapped = wrapScene(inner);
1357
+ const wrapped = wrapScene(inner, inner === rootElement);
735
1358
  layer.container = wrapped.container;
736
1359
  layer.wrapper = wrapped.wrapper;
737
1360
  layer.padding = wrapped.padding;
@@ -812,23 +1435,27 @@ var StickyScrollTrigger = (function() {
812
1435
  const endResolved = layer.end === null ? null : prefixSpacedRelativeEnd(startResolved, resolveMaybeFn(layer.end));
813
1436
  const elementHeight = measureUsedHeight(layer.trigger);
814
1437
  const endTriggerIsSelf = layer.endTrigger === layer.trigger;
1438
+ const indicesWhere = (test) => [...indexByTrigger].filter(([trigger]) => test(trigger)).map(([, index]) => index);
815
1439
  const endTriggerIndex = indexByTrigger.get(layer.endTrigger) ?? null;
816
1440
  const end = resolveEndSpec(rootElement, viewportHeight, layer, endResolved, ownIndex, endTriggerIndex);
1441
+ const endTriggerInContainer = end.mode === "clause" && !end.measureLive && !endTriggerIsSelf;
817
1442
  const start = resolveStartSpec(layer, startResolved, elementHeight, viewportHeight);
818
1443
  return {
819
1444
  kind: layer.kind,
820
1445
  start,
821
1446
  triggerTop: documentTop(layer.trigger),
822
1447
  triggerHeight: elementHeight,
823
- triggerEnclosedBy: [...indexByTrigger].filter(([trigger]) => trigger.contains(layer.trigger)).map(([, index]) => index),
1448
+ triggerEnclosedBy: indicesWhere((trigger) => trigger.contains(layer.trigger)),
824
1449
  wrapperTop: layer.wrapper ? documentTop(layer.wrapper) : 0,
825
1450
  coverTop: layer.kind === "cover" ? documentTop(layer.cover) : 0,
826
1451
  end,
827
- endTriggerIsSelf,
828
- endTriggerIndex,
829
- endTriggerHeight: end.mode === "clause" ? measureUsedHeight(layer.endTrigger) : 0,
830
- endTriggerEnclosedBy: end.mode === "clause" && !end.measureLive && !endTriggerIsSelf ? [...indexByTrigger].filter(([trigger]) => trigger.contains(layer.endTrigger)).map(([, index]) => index) : [],
831
- endTriggerNests: end.mode === "clause" && !end.measureLive && !endTriggerIsSelf ? [...indexByTrigger].filter(([trigger]) => trigger !== layer.endTrigger && layer.endTrigger.contains(trigger)).map(([, index]) => index) : []
1452
+ endTrigger: {
1453
+ isSelf: endTriggerIsSelf,
1454
+ index: endTriggerIndex,
1455
+ height: end.mode === "clause" ? measureUsedHeight(layer.endTrigger) : 0,
1456
+ enclosedBy: endTriggerInContainer ? indicesWhere((trigger) => trigger.contains(layer.endTrigger)) : [],
1457
+ nests: endTriggerInContainer ? indicesWhere((other) => other !== layer.endTrigger && layer.endTrigger.contains(other)) : []
1458
+ }
832
1459
  };
833
1460
  };
834
1461
  const EXCLUDED_VAR_KEYS = [
@@ -861,6 +1488,10 @@ var StickyScrollTrigger = (function() {
861
1488
  case "clause": return toScroll(endTrigger, documentTop(endTrigger) - resolveAnchorTop(classifiedEnd.value, measureUsedHeight(endTrigger), viewportHeight));
862
1489
  }
863
1490
  };
1491
+ const removeItem = (list, item) => {
1492
+ const index = list.indexOf(item);
1493
+ if (index !== -1) list.splice(index, 1);
1494
+ };
864
1495
  const hasDuplicateTrigger = (list, trigger) => list.some((existing) => existing.trigger === trigger);
865
1496
  var StickyScrollTrigger = class {
866
1497
  #rootElement;
@@ -875,6 +1506,7 @@ var StickyScrollTrigger = (function() {
875
1506
  #scrollTriggerClass = null;
876
1507
  #pinLayers = [];
877
1508
  #scrollMarginSync;
1509
+ #dormancyClient = null;
878
1510
  constructor(root, options = {}) {
879
1511
  this.#rootElement = resolveRoot(root);
880
1512
  const scrollMarginTargets = options.scrollMarginTargets === void 0 ? "[id]" : options.scrollMarginTargets;
@@ -883,7 +1515,26 @@ var StickyScrollTrigger = (function() {
883
1515
  } catch {
884
1516
  throw new Error(`StickyScrollTrigger: scrollMarginTargets "${scrollMarginTargets}" is not a valid CSS selector.`);
885
1517
  }
1518
+ const optimization = options.nestedStickyOptimization === void 0 ? "auto" : options.nestedStickyOptimization;
1519
+ if (![
1520
+ "auto",
1521
+ "always",
1522
+ "off"
1523
+ ].includes(optimization)) throw new Error(`StickyScrollTrigger: nestedStickyOptimization must be 'auto', 'always' or 'off', got ${String(optimization)}.`);
886
1524
  this.#scrollMarginSync = createScrollMarginSync(this.#rootElement, scrollMarginTargets);
1525
+ if (optimization === "always" || optimization === "auto" && isWebKit()) {
1526
+ this.#dormancyClient = {
1527
+ mode: optimization,
1528
+ ownedElements: () => this.#ownedStickyElements()
1529
+ };
1530
+ registerDormancyClient(this.#dormancyClient);
1531
+ }
1532
+ }
1533
+ #ownedStickyElements() {
1534
+ return [...this.#builtLayers.flatMap((layer) => layer.wrapper ? [layer.wrapper] : []), ...this.#wrappedPinTriggers()];
1535
+ }
1536
+ #wrappedPinTriggers() {
1537
+ return this.#pinLayers.flatMap(({ trigger, inner }) => inner ? [trigger] : []);
887
1538
  }
888
1539
  #unbuild() {
889
1540
  if (!this.#built) return;
@@ -922,7 +1573,12 @@ var StickyScrollTrigger = (function() {
922
1573
  throw error;
923
1574
  });
924
1575
  }
925
- return result;
1576
+ const restoreDormancy = takeGsapRefreshRestore();
1577
+ if (!restoreDormancy) return result;
1578
+ return { render: (time) => {
1579
+ result?.render?.(time);
1580
+ restoreDormancy();
1581
+ } };
926
1582
  };
927
1583
  }
928
1584
  #wrapUnwrappedPins() {
@@ -954,34 +1610,17 @@ var StickyScrollTrigger = (function() {
954
1610
  }
955
1611
  #unwrapPinLayer(layer) {
956
1612
  if (!layer.outer) return false;
1613
+ releaseDormant([layer.trigger]);
957
1614
  unwrapPin(layer.outer, layer.trigger, layer.savedPosition);
958
1615
  layer.outer = null;
959
1616
  layer.inner = null;
960
1617
  return true;
961
1618
  }
962
1619
  #resetSceneCoverStickyState() {
963
- const wrapperSnapshots = this.#layers.map((layer) => layer.wrapper).filter((wrapper) => wrapper !== null).map((wrapper) => ({
964
- wrapper,
965
- position: wrapper.style.position,
966
- top: wrapper.style.top
967
- }));
968
- wrapperSnapshots.forEach(({ wrapper }) => resetStickyPosition(wrapper));
969
- return () => {
970
- wrapperSnapshots.forEach(({ wrapper, position, top }) => {
971
- wrapper.style.position = position;
972
- wrapper.style.top = top;
973
- });
974
- };
1620
+ return stripStickyPositions(this.#layers.flatMap(({ wrapper }) => wrapper ? [wrapper] : []));
975
1621
  }
976
1622
  #resetPinStickyState() {
977
- const snapshots = this.#pinLayers.filter((layer) => layer.inner).map(({ trigger }) => ({
978
- trigger,
979
- position: captureInlinePosition(trigger)
980
- }));
981
- snapshots.forEach(({ trigger }) => resetStickyPosition(trigger));
982
- return () => {
983
- snapshots.forEach(({ trigger, position }) => restoreInlinePosition(trigger, position));
984
- };
1623
+ return stripStickyPositions(this.#wrappedPinTriggers());
985
1624
  }
986
1625
  #resetStickyState() {
987
1626
  const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
@@ -1036,7 +1675,7 @@ var StickyScrollTrigger = (function() {
1036
1675
  const topPx = resolveAnchorTop(classifiedStart.value, triggerHeight, viewportHeight);
1037
1676
  const toScroll = (element, reachedAt) => this.#addDwellBeforeReach(element, reachedAt);
1038
1677
  const releaseScroll = resolvePinReleaseScroll(layer.endTrigger, classifiedEnd, toScroll(layer.trigger, triggerTop - topPx), viewportHeight, toScroll);
1039
- const height = releaseScroll - (this.#rootElement.contains(layer.trigger) ? dwellConsumedAt(releaseScroll, this.#sceneLayers()) : 0) - triggerTop + topPx + triggerHeight + triggerMarginBottom;
1678
+ const height = releaseScroll - (this.#rootElement.contains(layer.trigger) ? dwellConsumedAt(releaseScroll, this.#engagedWindows()) : 0) - triggerTop + topPx + triggerHeight + triggerMarginBottom;
1040
1679
  const room = documentHeight > 0 ? documentHeight - triggerTop : Infinity;
1041
1680
  applyStickyPosition(layer.trigger, topPx);
1042
1681
  layer.inner.style.height = `${Math.max(0, Math.min(height, room))}px`;
@@ -1074,6 +1713,8 @@ var StickyScrollTrigger = (function() {
1074
1713
  const layer = active[index];
1075
1714
  layer.freezeStart = plan.freezeStart;
1076
1715
  layer.freezeEnd = plan.freezeEnd;
1716
+ layer.engagedStart = plan.engagedStart;
1717
+ layer.engagedEnd = plan.engagedEnd;
1077
1718
  if (!layer.wrapper) return;
1078
1719
  applyStickyPosition(layer.wrapper, plan.stickyTop);
1079
1720
  if (layer.kind === "scene" && layer.padding && plan.paddingHeight !== null) layer.padding.style.height = `${plan.paddingHeight}px`;
@@ -1087,6 +1728,23 @@ var StickyScrollTrigger = (function() {
1087
1728
  }
1088
1729
  refresh() {
1089
1730
  if (this.#destroyed) return;
1731
+ let failure = null;
1732
+ try {
1733
+ this.#refreshLayout();
1734
+ } catch (error) {
1735
+ failure = { error };
1736
+ }
1737
+ try {
1738
+ rebuildDormancy(this.#scrollTriggerClass);
1739
+ } catch (error) {
1740
+ clearDormancy();
1741
+ queueMicrotask(() => {
1742
+ throw error;
1743
+ });
1744
+ }
1745
+ if (failure) throw failure.error;
1746
+ }
1747
+ #refreshLayout() {
1090
1748
  if (this.#dirty || !this.#built || isDomOrderStale(this.#layers)) {
1091
1749
  this.#unbuild();
1092
1750
  this.#build();
@@ -1116,10 +1774,7 @@ var StickyScrollTrigger = (function() {
1116
1774
  });
1117
1775
  }
1118
1776
  #syncScrollMargins() {
1119
- this.#scrollMarginSync.sync(this.#sceneLayers().map(({ freezeStart, freezeEnd }) => ({
1120
- freezeStart,
1121
- freezeEnd
1122
- })), this.#outermostContainer, (targets) => {
1777
+ this.#scrollMarginSync.sync(this.#engagedWindows(), this.#outermostContainer, (targets) => {
1123
1778
  if (!targets.length) return [];
1124
1779
  const restoreStickyState = this.#resetStickyState();
1125
1780
  const tops = targets.map((target) => documentTop(target));
@@ -1158,8 +1813,7 @@ var StickyScrollTrigger = (function() {
1158
1813
  invalidateOnRefresh: rest.invalidateOnRefresh ?? true,
1159
1814
  onKill: (self) => {
1160
1815
  this.#captureScrollTriggerClass(self);
1161
- const index = this.#layers.indexOf(layer);
1162
- if (index !== -1) this.#layers.splice(index, 1);
1816
+ removeItem(this.#layers, layer);
1163
1817
  this.#dirty = true;
1164
1818
  this.#scheduleRebuild();
1165
1819
  onKill?.(self);
@@ -1182,7 +1836,9 @@ var StickyScrollTrigger = (function() {
1182
1836
  start,
1183
1837
  end,
1184
1838
  freezeStart: 0,
1185
- freezeEnd: 0
1839
+ freezeEnd: 0,
1840
+ engagedStart: 0,
1841
+ engagedEnd: 0
1186
1842
  }, onKill, rest);
1187
1843
  }
1188
1844
  createOverlapScroll({ trigger: triggerInput, cover, start = "bottom bottom", end = null, endTrigger: endTriggerInput, onKill, ...rest }) {
@@ -1202,7 +1858,9 @@ var StickyScrollTrigger = (function() {
1202
1858
  start,
1203
1859
  end,
1204
1860
  freezeStart: 0,
1205
- freezeEnd: 0
1861
+ freezeEnd: 0,
1862
+ engagedStart: 0,
1863
+ engagedEnd: 0
1206
1864
  };
1207
1865
  const vars = this.#registerLayer(layer, (self) => {
1208
1866
  this.#coverRestoreByLayer.get(layer)?.();
@@ -1235,8 +1893,7 @@ var StickyScrollTrigger = (function() {
1235
1893
  trigger,
1236
1894
  onKill: (self) => {
1237
1895
  this.#captureScrollTriggerClass(self);
1238
- const index = this.#pinLayers.indexOf(layer);
1239
- if (index !== -1) this.#pinLayers.splice(index, 1);
1896
+ removeItem(this.#pinLayers, layer);
1240
1897
  if (this.#unwrapPinLayer(layer)) this.#scheduleRebuild();
1241
1898
  onKill?.(self);
1242
1899
  },
@@ -1264,10 +1921,13 @@ var StickyScrollTrigger = (function() {
1264
1921
  }
1265
1922
  #addDwellBeforeReach(element, reachedAt) {
1266
1923
  if (!this.#rootElement.contains(element)) return reachedAt;
1267
- return reachedAt + dwellBeforeReach(reachedAt, this.#sceneLayers());
1924
+ return reachedAt + dwellBeforeReach(reachedAt, this.#engagedWindows());
1268
1925
  }
1269
- #sceneLayers() {
1270
- return this.#layers.filter((layer) => layer.kind === "scene");
1926
+ #engagedWindows() {
1927
+ return this.#layers.flatMap((layer) => layer.kind === "scene" ? [{
1928
+ freezeStart: layer.engagedStart,
1929
+ freezeEnd: layer.engagedEnd
1930
+ }] : []);
1271
1931
  }
1272
1932
  static getScrollTop(elementInput, instances) {
1273
1933
  const element = resolveElement(elementInput, "StickyScrollTrigger.getScrollTop");
@@ -1297,6 +1957,7 @@ var StickyScrollTrigger = (function() {
1297
1957
  destroy() {
1298
1958
  if (this.#destroyed) return;
1299
1959
  this.#destroyed = true;
1960
+ unregisterDormancyClient(this.#dormancyClient);
1300
1961
  this.#scrollMarginSync.restore();
1301
1962
  this.#restoreCoverLifts();
1302
1963
  this.#unbuild();