sticky-scroll-trigger 0.9.0 → 0.11.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.9.0
3
+ * StickyScrollTrigger v0.11.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
@@ -48,10 +48,26 @@ var StickyScrollTrigger = (function() {
48
48
  probe.remove();
49
49
  return height;
50
50
  };
51
- const measureDocumentMaxScroll = (viewportHeight) => {
52
- const doc = document.documentElement;
53
- return Math.max(0, (doc.scrollHeight || document.body.scrollHeight) - viewportHeight);
51
+ const measureDocumentHeight = () => document.documentElement.scrollHeight || document.body.scrollHeight;
52
+ const pinRanges = new Set();
53
+ const measureDocumentHeightWithoutPinRanges = () => {
54
+ pinRanges.forEach((inner) => {
55
+ if (!inner.isConnected) pinRanges.delete(inner);
56
+ });
57
+ const saved = [...pinRanges].map((inner) => ({
58
+ inner,
59
+ height: inner.style.height
60
+ }));
61
+ saved.forEach(({ inner }) => {
62
+ inner.style.height = "";
63
+ });
64
+ const height = measureDocumentHeight();
65
+ saved.forEach(({ inner, height: range }) => {
66
+ inner.style.height = range;
67
+ });
68
+ return height;
54
69
  };
70
+ const measureDocumentMaxScroll = (viewportHeight) => Math.max(0, measureDocumentHeight() - viewportHeight);
55
71
  const measureBorderWidth = (borderStyle, width) => borderStyle === "none" || borderStyle === "hidden" ? 0 : parseFloat(width);
56
72
  const measureUsedHeight = (el) => {
57
73
  const rounded = el.offsetHeight;
@@ -83,7 +99,7 @@ var StickyScrollTrigger = (function() {
83
99
  el.style.position = saved.position;
84
100
  el.style.top = saved.top;
85
101
  };
86
- const wrapScene = (inner) => {
102
+ const wrapScene = (inner, holdTrailingMargin) => {
87
103
  if (!inner.parentNode) throw new Error(`StickyScrollTrigger: ${describeElement(inner)} is not attached to the document`);
88
104
  const container = document.createElement("div");
89
105
  const wrapper = document.createElement("div");
@@ -94,6 +110,11 @@ var StickyScrollTrigger = (function() {
94
110
  container.appendChild(wrapper);
95
111
  wrapper.appendChild(inner);
96
112
  container.appendChild(padding);
113
+ if (holdTrailingMargin) {
114
+ const sentinel = document.createElement("div");
115
+ sentinel.style.display = "flow-root";
116
+ wrapper.appendChild(sentinel);
117
+ }
97
118
  return {
98
119
  container,
99
120
  wrapper,
@@ -122,10 +143,11 @@ var StickyScrollTrigger = (function() {
122
143
  if (!trigger.parentNode) throw new Error(`createStickyPin: trigger ${describeElement(trigger)} is not attached to the document`);
123
144
  const outer = document.createElement("div");
124
145
  const inner = document.createElement("div");
125
- outer.style.contain = "layout";
146
+ outer.style.display = "flow-root";
126
147
  trigger.parentNode.insertBefore(outer, trigger);
127
148
  outer.appendChild(inner);
128
149
  inner.appendChild(trigger);
150
+ pinRanges.add(inner);
129
151
  return {
130
152
  outer,
131
153
  inner
@@ -135,6 +157,7 @@ var StickyScrollTrigger = (function() {
135
157
  const parent = outer.parentNode;
136
158
  restoreInlinePosition(trigger, saved);
137
159
  if (parent) parent.insertBefore(trigger, outer);
160
+ if (outer.firstElementChild instanceof HTMLElement) pinRanges.delete(outer.firstElementChild);
138
161
  outer.remove();
139
162
  };
140
163
  const LIFT_VALUES = {
@@ -178,6 +201,584 @@ var StickyScrollTrigger = (function() {
178
201
  lifted.length = 0;
179
202
  };
180
203
  };
204
+ const resolveMaybeFn = (value) => typeof value === "function" ? value() : value;
205
+ const KEYWORD_FRACTIONS = {
206
+ top: 0,
207
+ center: .5,
208
+ bottom: 1
209
+ };
210
+ const signedPx = (sign, value, unit, refSize) => {
211
+ const magnitude = unit === "%" ? parseFloat(value) / 100 * refSize : parseFloat(value);
212
+ return sign?.startsWith("-") ? -magnitude : magnitude;
213
+ };
214
+ const CLAUSE_TOKEN_RE = /^(top|center|bottom|[+-]?(?:\d+(?:\.\d*)?|\.\d+))?(%|px)?(?:([+-]=?)(\d+(?:\.\d*)?|\.\d+)(%|px)?)?$/;
215
+ const parseClauseToken = (token, refSize) => {
216
+ const match = CLAUSE_TOKEN_RE.exec(token);
217
+ if (!match || !match[1] && !match[3]) {
218
+ if (MAX_TOKEN_RE.test(token)) throw new Error(`StickyScrollTrigger: unsupported position clause "${token}": 'max' is GSAP's end-only keyword for the scroller's maximum scroll position.`);
219
+ throw new Error(`StickyScrollTrigger: unsupported position clause "${token}"`);
220
+ }
221
+ const [, base, baseUnit, sign, offsetValue, offsetUnit] = match;
222
+ if (base !== void 0 && sign && !sign.includes("=")) {
223
+ const suggestion = `${base}${baseUnit ?? ""}${sign}=${offsetValue}${offsetUnit ?? ""}`;
224
+ throw new Error(`StickyScrollTrigger: unsupported position clause "${token}": a signed offset needs an explicit '=' when it follows a keyword or number (GSAP needs it to tell "${base}" from the offset). Did you mean "${suggestion}"?`);
225
+ }
226
+ const isKeyword = base !== void 0 && base in KEYWORD_FRACTIONS;
227
+ const basePercent = baseUnit === "%";
228
+ return {
229
+ fraction: isKeyword ? KEYWORD_FRACTIONS[base] : basePercent ? parseFloat(base) / 100 : 0,
230
+ offsetPx: (!isKeyword && !basePercent && base !== void 0 ? parseFloat(base) : 0) + (sign ? signedPx(sign, offsetValue, offsetUnit, refSize) : 0)
231
+ };
232
+ };
233
+ const isAbsoluteFormat = (resolved) => {
234
+ if (typeof resolved === "number") return true;
235
+ return resolved.trim() !== "" && !Number.isNaN(Number(resolved));
236
+ };
237
+ const resolveAbsolute = (resolved) => typeof resolved === "number" ? resolved : Number(resolved);
238
+ const CLAMP_PREFIX = "clamp(";
239
+ const assertNotClamped = (trimmed) => {
240
+ if (!trimmed.startsWith(CLAMP_PREFIX)) return;
241
+ const inner = trimmed.slice(6).replace(/\)$/, "").trim();
242
+ throw new Error(`StickyScrollTrigger: unsupported position clause "${trimmed}": GSAP's clamp() wrapper isn't supported here.` + (inner ? ` Did you mean "${inner}"?` : ""));
243
+ };
244
+ const resolveElementAnchor = (position, elementHeight) => {
245
+ const trimmed = position.trim();
246
+ assertNotClamped(trimmed);
247
+ const elementClause = parseClauseToken(trimmed.split(/\s+/)[0], elementHeight);
248
+ return elementHeight * elementClause.fraction + elementClause.offsetPx;
249
+ };
250
+ const resolveElementFraction = (position) => resolveElementAnchor(position, 1) - resolveElementAnchor(position, 0);
251
+ const resolveAnchorTop = (position, elementHeight, viewportHeight) => {
252
+ const trimmed = position.trim();
253
+ assertNotClamped(trimmed);
254
+ const viewportToken = trimmed.split(/\s+/)[1] ?? "top";
255
+ const viewportClause = parseClauseToken(viewportToken, viewportHeight);
256
+ return viewportHeight * viewportClause.fraction + viewportClause.offsetPx - resolveElementAnchor(trimmed, elementHeight);
257
+ };
258
+ const DWELL_RELATIVE_RE = /^\+=(\d+(?:\.\d*)?|\.\d+)(%|px)?$/;
259
+ const isDwellFormat = (resolved) => typeof resolved === "string" && DWELL_RELATIVE_RE.test(resolved.trim());
260
+ const prefixSpacedRelativeEnd = (start, endResolved) => {
261
+ if (typeof endResolved !== "string") return endResolved;
262
+ const trimmedEnd = endResolved.trim();
263
+ if (!trimmedEnd.startsWith("+=") || !/\s/.test(trimmedEnd)) return endResolved;
264
+ const startResolved = resolveMaybeFn(start);
265
+ if (typeof startResolved !== "string") return endResolved;
266
+ const trimmedStart = startResolved.trim();
267
+ assertNotClamped(trimmedStart);
268
+ const [elementToken] = trimmedStart.split(/\s+/);
269
+ try {
270
+ parseClauseToken(elementToken, 0);
271
+ } catch (error) {
272
+ if (!isAbsoluteFormat(startResolved)) throw error;
273
+ return endResolved;
274
+ }
275
+ parseClauseToken(trimmedEnd.split(/\s+/)[0], 0);
276
+ if (elementToken.includes("=")) throw new Error(`StickyScrollTrigger: end "${endResolved}" can't be resolved against start "${startResolved}": GSAP reads an end that starts with '+=' and holds a space by prefixing it with the start clause's element token, and "${elementToken}" carries an offset of its own, which GSAP resolves by discarding the end's. Give end a complete position clause instead, such as 'top+=100 bottom'.`);
277
+ return elementToken + trimmedEnd;
278
+ };
279
+ const resolveDwell = (resolved, viewportHeight) => {
280
+ const match = DWELL_RELATIVE_RE.exec(String(resolved).trim());
281
+ if (!match) throw new Error(`StickyScrollTrigger: unsupported end format "${resolved}"`);
282
+ const [, value, unit] = match;
283
+ return signedPx(void 0, value, unit, viewportHeight);
284
+ };
285
+ const MAX_TOKEN_RE = /^max(?:([+-]=)(\d+(?:\.\d*)?|\.\d+)(%|px)?)?$/;
286
+ const isMaxFormat = (resolved) => typeof resolved === "string" && MAX_TOKEN_RE.test(resolved.trim());
287
+ const resolveMaxOffset = (resolved, viewportHeight) => {
288
+ const match = MAX_TOKEN_RE.exec(resolved.trim());
289
+ if (!match) throw new Error(`StickyScrollTrigger: unsupported max-position format "${resolved}"`);
290
+ const [, sign, value, unit] = match;
291
+ return sign ? signedPx(sign, value, unit, viewportHeight) : 0;
292
+ };
293
+ const classifyPosition = (resolved) => {
294
+ if (typeof resolved === "number") return {
295
+ kind: "absolute",
296
+ value: resolved
297
+ };
298
+ if (isDwellFormat(resolved)) return {
299
+ kind: "dwell",
300
+ value: resolved
301
+ };
302
+ if (isMaxFormat(resolved)) return {
303
+ kind: "max",
304
+ value: resolved
305
+ };
306
+ if (isAbsoluteFormat(resolved)) return {
307
+ kind: "absolute",
308
+ value: resolveAbsolute(resolved)
309
+ };
310
+ return {
311
+ kind: "clause",
312
+ value: resolved
313
+ };
314
+ };
315
+ 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));
316
+ const nestedIn = (measurements, index) => measurements.flatMap(({ triggerEnclosedBy }, k) => k !== index && triggerEnclosedBy.includes(index) ? [k] : []);
317
+ const anchorShare = (measurements, world, index, freezeStart, box, reachedAt, enclosedBy, anchorElement, order, ownIndex) => {
318
+ const measurement = measurements[index];
319
+ if (enclosedBy.includes(index)) return (measurement.start.mode === "absolute" ? world.unpaddedStart(index, ownIndex, freezeStart) : measurement.triggerTop - measurement.start.anchorOffset) < reachedAt - .05 ? 1 : 0;
320
+ if (order && isHeldIn(measurements, index, enclosedBy, anchorElement, order)) return 0;
321
+ if (box.nests.includes(index)) return box.fraction;
322
+ return measurement.triggerTop + measurement.triggerHeight <= box.top + .05 ? 1 : 0;
323
+ };
324
+ const gapsBeforeEndAnchor = (measurements, world, windows, box, reachedAt, enclosedBy, ownIndex, anchorElement, order, counted) => windows.reduce((total, { index, freezeStart, freezeEnd }) => {
325
+ if (index === ownIndex || order && order.isBefore(ownIndex, index)) return total;
326
+ const weight = anchorShare(measurements, world, index, freezeStart, box, reachedAt, enclosedBy, anchorElement, order, ownIndex);
327
+ if (weight === 0) return total;
328
+ counted?.add(index);
329
+ return total + weight * (freezeEnd - freezeStart);
330
+ }, 0);
331
+ const clauseFreezeStart = (measurements, index, paddingOf) => {
332
+ const reachOf = (k) => {
333
+ const { start, triggerTop } = measurements[k];
334
+ return start.mode === "clause" ? triggerTop - start.anchorOffset : null;
335
+ };
336
+ const scenes = measurements.flatMap(({ kind }, k) => kind === "scene" ? [k] : []);
337
+ const clauses = scenes.filter((k) => reachOf(k) !== null).sort((a, b) => {
338
+ const gap = reachOf(a) - reachOf(b);
339
+ return Math.abs(gap) <= .05 ? a - b : gap;
340
+ });
341
+ const absolutes = scenes.flatMap((k) => {
342
+ const { start } = measurements[k];
343
+ return start.mode === "absolute" ? [{
344
+ k,
345
+ value: start.value
346
+ }] : [];
347
+ }).sort((a, b) => a.value - b.value);
348
+ let dwell = 0;
349
+ let nextAbsolute = 0;
350
+ for (const k of clauses) {
351
+ const reachedAt = reachOf(k);
352
+ while (nextAbsolute < absolutes.length && absolutes[nextAbsolute].value < reachedAt + dwell + .05) {
353
+ dwell += paddingOf(absolutes[nextAbsolute].k);
354
+ nextAbsolute += 1;
355
+ }
356
+ if (k === index) return reachedAt + dwell;
357
+ dwell += paddingOf(k);
358
+ }
359
+ throw new Error("StickyScrollTrigger: internal error: clauseFreezeStart was given a layer without a clause start.");
360
+ };
361
+ const runPass = (measurements, { viewportHeight, measureLiveEndTriggerTop }, previous, order, world, record, previousOnly = false) => {
362
+ const fresh = [];
363
+ const knownWindows = () => measurements.flatMap((measurement, k) => {
364
+ if (measurement.kind !== "scene") return [];
365
+ const plan = previousOnly ? null : fresh[k];
366
+ if (plan) return [{
367
+ index: k,
368
+ freezeStart: plan.freezeStart,
369
+ freezeEnd: plan.freezeEnd
370
+ }];
371
+ const freezeStart = previous?.freezeStarts[k] ?? null;
372
+ const paddingHeight = previous?.paddings[k] ?? null;
373
+ return freezeStart === null || paddingHeight === null ? [] : [{
374
+ index: k,
375
+ freezeStart,
376
+ freezeEnd: freezeStart + paddingHeight
377
+ }];
378
+ });
379
+ const paddingOf = (k) => (previousOnly ? null : fresh[k]?.paddingHeight) ?? previous?.paddings[k] ?? 0;
380
+ const recounts = [];
381
+ const plans = measurements.map((measurement, index) => {
382
+ fresh[index] = null;
383
+ if (measurement.kind === "cover") return null;
384
+ const recount = {
385
+ index,
386
+ counted: new Set(),
387
+ runs: []
388
+ };
389
+ recounts.push(recount);
390
+ const { start } = measurement;
391
+ const freezeStart = start.mode === "absolute" ? start.value : previous?.freezeStarts[index] ?? clauseFreezeStart(measurements, index, paddingOf);
392
+ let freezeEnd;
393
+ switch (measurement.end.mode) {
394
+ case "dwell":
395
+ freezeEnd = freezeStart + measurement.end.distancePx;
396
+ break;
397
+ case "absolute": {
398
+ const length = world.absoluteEndLength(index);
399
+ freezeEnd = length === null ? Math.max(freezeStart, measurement.end.value) : freezeStart + length;
400
+ break;
401
+ }
402
+ case "auto":
403
+ case "max": throw new Error(`StickyScrollTrigger: internal error: a Scene layer reached '${measurement.end.mode}' end mode, which only a cover layer can have.`);
404
+ case "clause": {
405
+ const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTriggerHeight, viewportHeight);
406
+ if (measurement.endTriggerIsSelf) {
407
+ const nests = nestedIn(measurements, index);
408
+ const weight = resolveElementFraction(measurement.end.clause) - (start.mode === "clause" ? start.elementFraction : 0);
409
+ const dwellInside = measurements.reduce((total, other, k) => {
410
+ if (weight === 0 || other.kind !== "scene" || !nests.includes(k) || order && (order.isBefore(index, k) || isHeldIn(measurements, k, measurement.triggerEnclosedBy, index, order))) return total;
411
+ recount.counted.add(k);
412
+ return total + weight * paddingOf(k);
413
+ }, 0);
414
+ if (start.mode === "clause") {
415
+ freezeEnd = freezeStart + Math.max(0, start.anchorOffset - anchorOffsetEnd + dwellInside);
416
+ break;
417
+ }
418
+ const dwellAbove = measurements.reduce((total, other, k) => {
419
+ 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;
420
+ recount.counted.add(k);
421
+ return total + paddingOf(k);
422
+ }, 0);
423
+ freezeEnd = Math.max(freezeStart, measurement.triggerTop - anchorOffsetEnd + dwellAbove + dwellInside);
424
+ break;
425
+ }
426
+ let endTop;
427
+ if (measurement.end.measureLive) endTop = measureLiveEndTriggerTop(index);
428
+ else {
429
+ const rawTop = measurement.endTriggerIndex === null ? measurement.end.rawTop : measurements[measurement.endTriggerIndex].triggerTop;
430
+ if (rawTop === null) endTop = 0;
431
+ else {
432
+ const box = {
433
+ top: rawTop,
434
+ fraction: resolveElementFraction(measurement.end.clause),
435
+ nests: measurement.endTriggerNests
436
+ };
437
+ const gaps = (w, counted) => gapsBeforeEndAnchor(measurements, world, w, box, rawTop - anchorOffsetEnd, measurement.endTriggerEnclosedBy, index, measurement.endTriggerIndex, order, counted);
438
+ endTop = rawTop + gaps(knownWindows());
439
+ recount.runs.push((w) => gaps(w, recount.counted));
440
+ }
441
+ }
442
+ let layoutStart;
443
+ if (start.mode === "absolute") layoutStart = start.value;
444
+ else {
445
+ const gaps = (w, counted) => gapsBeforeEndAnchor(measurements, world, w, {
446
+ top: measurement.triggerTop,
447
+ fraction: start.elementFraction,
448
+ nests: nestedIn(measurements, index)
449
+ }, measurement.triggerTop - start.anchorOffset, measurement.triggerEnclosedBy, index, index, order, counted);
450
+ layoutStart = measurement.triggerTop - start.anchorOffset + gaps(knownWindows());
451
+ recount.runs.push((w) => gaps(w, recount.counted));
452
+ }
453
+ freezeEnd = freezeStart + Math.max(0, endTop - anchorOffsetEnd - layoutStart);
454
+ break;
455
+ }
456
+ }
457
+ const plan = {
458
+ freezeStart,
459
+ freezeEnd,
460
+ paddingHeight: Math.max(0, freezeEnd - freezeStart)
461
+ };
462
+ fresh[index] = plan;
463
+ return plan;
464
+ });
465
+ if (record) {
466
+ const windows = knownWindows();
467
+ recounts.forEach(({ index, counted, runs }) => {
468
+ runs.forEach((run) => run(windows));
469
+ record(index, counted);
470
+ });
471
+ }
472
+ return plans;
473
+ };
474
+ const planCover = (measurements, index, windows, { viewportHeight, documentMaxScroll, measureLiveEndTriggerTop }) => {
475
+ const measurement = measurements[index];
476
+ if (measurement.start.mode !== "clause") throw new Error("StickyScrollTrigger: internal error: a cover layer measurement carries an absolute start, which resolveStartSpec should have already rejected.");
477
+ const reached = (reachedAt) => reachedAt + dwellBeforeReach(reachedAt, windows);
478
+ const startReachedAt = measurement.triggerTop - measurement.start.anchorOffset;
479
+ const freezeStart = startReachedAt + dwellBeforeReach(startReachedAt, windows, { countTies: true });
480
+ let freezeEnd;
481
+ switch (measurement.end.mode) {
482
+ case "auto":
483
+ freezeEnd = reached(measurement.coverTop);
484
+ break;
485
+ case "dwell":
486
+ freezeEnd = freezeStart + measurement.end.distancePx;
487
+ break;
488
+ case "absolute":
489
+ freezeEnd = measurement.end.value;
490
+ break;
491
+ case "max":
492
+ freezeEnd = documentMaxScroll + measurement.end.offsetPx;
493
+ break;
494
+ case "clause": {
495
+ const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTriggerHeight, viewportHeight);
496
+ if (measurement.end.measureLive) freezeEnd = measureLiveEndTriggerTop(index) - anchorOffsetEnd;
497
+ else freezeEnd = reached((measurement.endTriggerIsSelf ? measurement.triggerTop : measurement.endTriggerIndex === null ? measurement.end.rawTop ?? 0 : measurements[measurement.endTriggerIndex].triggerTop) - anchorOffsetEnd);
498
+ break;
499
+ }
500
+ }
501
+ return {
502
+ freezeStart,
503
+ freezeEnd: Math.max(freezeStart, freezeEnd),
504
+ engagedStart: freezeStart,
505
+ engagedEnd: Math.max(freezeStart, freezeEnd),
506
+ stickyTop: measurement.start.anchorOffset - (measurement.triggerTop - measurement.wrapperTop),
507
+ paddingHeight: null
508
+ };
509
+ };
510
+ const TIE_TOLERANCE_PX = .05;
511
+ const dwellBeforeReach = (reachedAt, windows, { countTies = false } = {}) => {
512
+ const tolerance = countTies ? -.05 : TIE_TOLERANCE_PX;
513
+ let earlierDwell = 0;
514
+ let counted = 0;
515
+ [...windows].sort((a, b) => a.freezeStart - b.freezeStart).forEach(({ freezeStart, freezeEnd }) => {
516
+ if (freezeStart < reachedAt + earlierDwell - tolerance) counted += freezeEnd - freezeStart;
517
+ earlierDwell += freezeEnd - freezeStart;
518
+ });
519
+ return counted;
520
+ };
521
+ const dwellConsumedAt = (scroll, windows) => windows.reduce((consumed, { freezeStart, freezeEnd }) => consumed + Math.min(Math.max(scroll - freezeStart, 0), freezeEnd - freezeStart), 0);
522
+ const componentsOf = (edges) => {
523
+ const visitOrder = edges.map(() => -1);
524
+ const lowLink = edges.map(() => 0);
525
+ const component = edges.map(() => -1);
526
+ const stack = [];
527
+ let visited = 0;
528
+ let components = 0;
529
+ const visit = (v) => {
530
+ visitOrder[v] = visited;
531
+ lowLink[v] = visited;
532
+ visited += 1;
533
+ stack.push(v);
534
+ for (const w of edges[v]) if (visitOrder[w] === -1) {
535
+ visit(w);
536
+ lowLink[v] = Math.min(lowLink[v], lowLink[w]);
537
+ } else if (component[w] === -1) lowLink[v] = Math.min(lowLink[v], visitOrder[w]);
538
+ if (lowLink[v] === visitOrder[v]) {
539
+ let w;
540
+ do {
541
+ w = stack.pop();
542
+ component[w] = components;
543
+ } while (w !== v);
544
+ components += 1;
545
+ }
546
+ };
547
+ edges.forEach((_, v) => {
548
+ if (visitOrder[v] === -1) visit(v);
549
+ });
550
+ return component;
551
+ };
552
+ const fallbackOrder = (measurements, counted) => {
553
+ const component = componentsOf(measurements.map(({ triggerEnclosedBy }, i) => [...counted[i], ...triggerEnclosedBy.filter((m) => m !== i && measurements[m].kind === "scene")]));
554
+ const rank = [];
555
+ measurements.map((_, i) => i).sort((a, b) => component[a] - component[b] || a - b).forEach((layer, position) => {
556
+ rank[layer] = position;
557
+ });
558
+ return { isBefore: (a, b) => rank[a] < rank[b] };
559
+ };
560
+ const hasCycle = (scenes, edges) => {
561
+ const component = componentsOf(edges);
562
+ return new Set(scenes.map((k) => component[k])).size < scenes.length;
563
+ };
564
+ const refreshOrderEdges = (measurements, lengths, edges) => {
565
+ const before = measurements.map(() => []);
566
+ edges.forEach((movers, i) => {
567
+ const measurement = measurements[i];
568
+ const enclosingAnchor = (measurement.end.mode === "clause" && !measurement.endTriggerIsSelf ? measurement.endTriggerEnclosedBy : measurement.triggerEnclosedBy).filter((m) => m !== measurement.endTriggerIndex);
569
+ movers.forEach((k) => {
570
+ if (lengths[k] <= .05) return;
571
+ before[i].push(k);
572
+ measurements[k].triggerEnclosedBy.forEach((m) => {
573
+ if (m !== k && m !== i && measurements[m].kind === "scene" && !enclosingAnchor.includes(m)) before[m].push(k);
574
+ });
575
+ });
576
+ });
577
+ return before;
578
+ };
579
+ const placeWindows = (measurements, scenes, lengths, atWrittenEnd) => {
580
+ const rest = new Set(scenes);
581
+ const reported = [];
582
+ const engaged = [];
583
+ let consumed = 0;
584
+ let frozenUntil = -Infinity;
585
+ while (rest.size) {
586
+ let next = -1;
587
+ let opensAt = 0;
588
+ let nextIsAbsolute = false;
589
+ let nextReach = 0;
590
+ for (const k of rest) {
591
+ const { start, triggerTop } = measurements[k];
592
+ const isAbsolute = start.mode === "absolute";
593
+ const reach = start.mode === "clause" ? triggerTop - start.anchorOffset : 0;
594
+ const at = start.mode === "absolute" ? start.value : reach + consumed;
595
+ const tied = Math.abs(at - opensAt) <= TIE_TOLERANCE_PX;
596
+ if (next === -1 || at < opensAt - .05 || tied && (isAbsolute ? !nextIsAbsolute || at < opensAt : !nextIsAbsolute && reach < nextReach - .05)) {
597
+ next = k;
598
+ opensAt = at;
599
+ nextIsAbsolute = isAbsolute;
600
+ nextReach = reach;
601
+ }
602
+ }
603
+ const { end } = measurements[next];
604
+ const reportedEnd = end.mode === "absolute" && atWrittenEnd(next) ? Math.max(opensAt, end.value) : opensAt + lengths[next];
605
+ const engagedStart = Math.max(opensAt, frozenUntil);
606
+ const engagedEnd = Math.max(engagedStart, reportedEnd);
607
+ rest.delete(next);
608
+ reported[next] = [opensAt, reportedEnd];
609
+ engaged[next] = [engagedStart, engagedEnd];
610
+ consumed += engagedEnd - engagedStart;
611
+ frozenUntil = Math.max(frozenUntil, engagedEnd);
612
+ }
613
+ return {
614
+ reported,
615
+ engaged
616
+ };
617
+ };
618
+ const planLayers = (measurements, deps) => {
619
+ const scenes = measurements.flatMap(({ kind }, k) => kind === "scene" ? [k] : []);
620
+ const needsConvergence = scenes.length > 1;
621
+ const liveTopCache = new Map();
622
+ const passDeps = {
623
+ ...deps,
624
+ measureLiveEndTriggerTop: (index) => {
625
+ const cached = liveTopCache.get(index);
626
+ if (cached !== void 0) return cached;
627
+ const value = deps.measureLiveEndTriggerTop(index);
628
+ liveTopCache.set(index, value);
629
+ return value;
630
+ }
631
+ };
632
+ const sameValues = (a, b) => a.every((value, i) => value === b[i] || value !== null && b[i] !== null && Math.abs(value - b[i]) <= .05);
633
+ const sameState = (a, b) => sameValues(a.paddings, b.paddings) && sameValues(a.freezeStarts, b.freezeStarts);
634
+ const lengthsOf = (windows) => windows.map((window) => window ? Math.max(0, window.freezeEnd - window.freezeStart) : 0);
635
+ const stateAt = (lengths, reported) => ({
636
+ paddings: measurements.map(({ kind }, k) => kind === "scene" ? lengths[k] : null),
637
+ freezeStarts: measurements.map(({ kind }, k) => kind === "scene" ? reported[k][0] : null)
638
+ });
639
+ const mix = (states, weights) => {
640
+ const of = (pick) => pick(states[0]).map((value, k) => value === null ? null : states.reduce((sum, state, j) => sum + weights[j] * pick(state)[k], 0));
641
+ return {
642
+ paddings: of((state) => state.paddings),
643
+ freezeStarts: of((state) => state.freezeStarts)
644
+ };
645
+ };
646
+ let world = null;
647
+ const place = (lengths, order, reading) => {
648
+ const placed = placeWindows(measurements, scenes, lengths, () => reading.endsAsRefreshed);
649
+ world = {
650
+ lengths,
651
+ order,
652
+ reported: placed.reported,
653
+ refreshTime: []
654
+ };
655
+ return placed;
656
+ };
657
+ const refreshTimeOf = (own) => {
658
+ if (world === null) return null;
659
+ const { lengths, order, refreshTime } = world;
660
+ const absent = (k) => k === own || order !== null && !order.isBefore(k, own);
661
+ refreshTime[own] ??= placeWindows(measurements, scenes, lengths.map((length, k) => absent(k) ? 0 : length), (k) => !absent(k)).reported;
662
+ return refreshTime[own];
663
+ };
664
+ const passWorld = (order, reading) => ({
665
+ unpaddedStart: (index, ownIndex, freezeStart) => {
666
+ const windows = (reading.startsAsRefreshed ? refreshTimeOf(ownIndex) : null) ?? world?.reported ?? [];
667
+ const spans = scenes.flatMap((k) => {
668
+ if (k === index || k === ownIndex || !windows[k]) return [];
669
+ if (order && !order.isBefore(k, ownIndex)) return [];
670
+ const [from, to] = windows[k];
671
+ return Math.min(to, freezeStart) > from ? [[from, Math.min(to, freezeStart)]] : [];
672
+ }).sort((a, b) => a[0] - b[0]);
673
+ let frozen = 0;
674
+ let frozenUntil = -Infinity;
675
+ for (const [from, to] of spans) {
676
+ const lo = Math.max(from, frozenUntil);
677
+ if (to > lo) frozen += to - lo;
678
+ frozenUntil = Math.max(frozenUntil, to);
679
+ }
680
+ return freezeStart - frozen;
681
+ },
682
+ absoluteEndLength: (index) => {
683
+ const { end } = measurements[index];
684
+ if (!reading.endsAsRefreshed || end.mode !== "absolute" || world === null) return null;
685
+ const windows = world.order === null ? world.reported : refreshTimeOf(index);
686
+ return Math.max(0, end.value - windows[index][0]);
687
+ }
688
+ });
689
+ const solve = (order, reading, cap, record = null, cycle = 2, damping = 1) => {
690
+ const reads = passWorld(order, reading);
691
+ const fed = [];
692
+ let previous = null;
693
+ for (let pass = 0; pass < cap; pass += 1) {
694
+ const lengths = lengthsOf(runPass(measurements, passDeps, previous, order, reads, record));
695
+ const placed = place(lengths, order, reading);
696
+ const next = stateAt(lengths, placed.reported);
697
+ if (!needsConvergence || previous !== null && sameState(next, previous)) return {
698
+ lengths,
699
+ ...placed
700
+ };
701
+ let feed = next;
702
+ if (previous !== null) {
703
+ fed.push(previous);
704
+ let back = -1;
705
+ 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;
706
+ if (back !== -1) {
707
+ const states = [...fed.slice(fed.length - back - 1), next];
708
+ feed = mix(states, states.map(() => 1 / states.length));
709
+ } else if (damping < 1) feed = mix([next, previous], [damping, 1 - damping]);
710
+ }
711
+ previous = feed;
712
+ }
713
+ return null;
714
+ };
715
+ const activeEdges = (lengths, reading) => {
716
+ const reads = passWorld(null, reading);
717
+ const respond = (from) => {
718
+ const { reported } = place(from, null, reading);
719
+ return lengthsOf(runPass(measurements, passDeps, stateAt(from, reported), null, reads, null, true));
720
+ };
721
+ const base = respond(lengths);
722
+ const edges = measurements.map(() => []);
723
+ scenes.forEach((k) => {
724
+ const nudged = lengths.slice();
725
+ nudged[k] += 2 ** -7;
726
+ respond(nudged).forEach((length, i) => {
727
+ if (i !== k && Math.abs(length - base[i]) > 1e-6) edges[i].push(k);
728
+ });
729
+ });
730
+ return edges;
731
+ };
732
+ const unsettled = (solved) => solved === null || solved.reported.some((window) => window.some((point) => !(Math.abs(point) <= 2 ** 48)));
733
+ const counted = measurements.map(() => new Set());
734
+ const everySpacer = {
735
+ endsAsRefreshed: true,
736
+ startsAsRefreshed: false
737
+ };
738
+ let solved = solve(null, everySpacer, Math.max(64, 2 * measurements.length + 2), (index, layers) => layers.forEach((k) => counted[index].add(k)));
739
+ const fallback = () => {
740
+ if (unsettled(solved)) return fallbackOrder(measurements, counted);
741
+ if (!needsConvergence) return null;
742
+ const edges = activeEdges(solved.lengths, everySpacer);
743
+ if (hasCycle(scenes, edges)) return fallbackOrder(measurements, counted);
744
+ return hasCycle(scenes, refreshOrderEdges(measurements, solved.lengths, edges)) ? { isBefore: (a, b) => a < b } : null;
745
+ };
746
+ const order = fallback();
747
+ if (order) {
748
+ const asReported = {
749
+ endsAsRefreshed: false,
750
+ startsAsRefreshed: false
751
+ };
752
+ solved = solve(order, asReported, 2 * measurements.length + 2);
753
+ if (unsettled(solved)) solved = solve(order, asReported, Math.max(64, 2 * measurements.length + 2), null, 4, .5);
754
+ if (unsettled(solved)) solved = solve(order, {
755
+ endsAsRefreshed: true,
756
+ startsAsRefreshed: true
757
+ }, 2 * measurements.length + 2);
758
+ }
759
+ 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.");
760
+ const { reported, engaged } = solved;
761
+ const scenePlans = measurements.map(({ kind }, index) => {
762
+ if (kind !== "scene") return null;
763
+ const [engagedStart, engagedEnd] = engaged[index];
764
+ const outerDwell = scenes.reduce((total, k) => k > index && engaged[k][1] <= engagedStart + .05 ? total + (engaged[k][1] - engaged[k][0]) : total, 0);
765
+ return {
766
+ freezeStart: reported[index][0],
767
+ freezeEnd: reported[index][1],
768
+ engagedStart,
769
+ engagedEnd,
770
+ stickyTop: deps.structureTop - (engagedStart - outerDwell),
771
+ paddingHeight: engagedEnd - engagedStart
772
+ };
773
+ });
774
+ const windows = scenes.map((k) => ({
775
+ freezeStart: engaged[k][0],
776
+ freezeEnd: engaged[k][1]
777
+ }));
778
+ const finalPlans = scenePlans.map((plan, index) => plan ?? planCover(measurements, index, windows, passDeps));
779
+ finalPlans.forEach((plan, index) => deps.onPlanned(index, plan));
780
+ return finalPlans;
781
+ };
181
782
  const OFFSET_PROPERTY = "--sst-scroll-margin-top-offset";
182
783
  let nextInstanceSuffix = 0;
183
784
  const supportsScrollDrivenAnimations = typeof CSS !== "undefined" && typeof CSS.supports === "function" && CSS.supports("animation-timeline", "scroll()");
@@ -232,8 +833,8 @@ var StickyScrollTrigger = (function() {
232
833
  jsHost = null;
233
834
  };
234
835
  return {
235
- sync(scenes, host) {
236
- const ramps = scenes.filter((scene) => scene.freezeEnd > scene.freezeStart);
836
+ sync(scenes, host, measureNaturalTops) {
837
+ const ramps = scenes.filter((scene) => scene.freezeEnd > scene.freezeStart).sort((a, b) => a.freezeStart - b.freezeStart);
237
838
  if (targetSelector === null || !ramps.length || !host) {
238
839
  written.forEach(restoreTarget);
239
840
  written = new Set();
@@ -257,20 +858,22 @@ var StickyScrollTrigger = (function() {
257
858
  sheet.replaceSync(buildStylesheet(instanceId, ramps));
258
859
  }
259
860
  const targets = Array.from(rootElement.querySelectorAll(targetSelector));
861
+ const naturalTops = measureNaturalTops(targets);
260
862
  targets.forEach((target) => {
261
863
  const existing = snapshots.get(target);
262
864
  if (!existing) snapshots.set(target, { inline: target.style.scrollMarginTop });
263
865
  else if (written.has(target)) target.style.scrollMarginTop = existing.inline;
264
866
  });
265
867
  const consumed = ramps.map((_, index) => `var(--${instanceId}-c${index}, 0px)`).join(" + ");
266
- targets.forEach((target) => {
868
+ targets.forEach((target, targetIndex) => {
267
869
  const authorPx = parseFloat(getComputedStyle(target).scrollMarginTop) || 0;
268
- let lag = 0;
269
- ramps.forEach((scene) => {
270
- if (compareDocumentOrder(scene.trigger, target) >= 0) return;
271
- lag += scene.freezeEnd - scene.freezeStart;
272
- });
273
- target.style.scrollMarginTop = `calc(${authorPx}px + var(${OFFSET_PROPERTY}, 0px) + ${consumed} - ${lag}px)`;
870
+ let earlierDwell = 0;
871
+ const lag = ramps.map(({ freezeStart, freezeEnd }) => {
872
+ const margin = naturalTops[targetIndex] - authorPx + earlierDwell - freezeStart - TIE_TOLERANCE_PX;
873
+ earlierDwell += freezeEnd - freezeStart;
874
+ return `clamp(0px, (${margin}px - var(${OFFSET_PROPERTY}, 0px)) * 1000000, ${freezeEnd - freezeStart}px)`;
875
+ }).join(" + ");
876
+ target.style.scrollMarginTop = `calc(${authorPx}px + var(${OFFSET_PROPERTY}, 0px) + ${consumed} - (${lag}))`;
274
877
  });
275
878
  const next = new Set(targets);
276
879
  written.forEach((target) => {
@@ -300,7 +903,7 @@ var StickyScrollTrigger = (function() {
300
903
  let outermost = null;
301
904
  for (const layer of layers) {
302
905
  if (layer.kind !== "scene") continue;
303
- const wrapped = wrapScene(inner);
906
+ const wrapped = wrapScene(inner, inner === rootElement);
304
907
  layer.container = wrapped.container;
305
908
  layer.wrapper = wrapped.wrapper;
306
909
  layer.padding = wrapped.padding;
@@ -326,212 +929,6 @@ var StickyScrollTrigger = (function() {
326
929
  }
327
930
  });
328
931
  };
329
- const resolveMaybeFn = (value) => typeof value === "function" ? value() : value;
330
- const KEYWORD_FRACTIONS = {
331
- top: 0,
332
- center: .5,
333
- bottom: 1
334
- };
335
- const signedPx = (sign, value, unit, refSize) => {
336
- const magnitude = unit === "%" ? parseFloat(value) / 100 * refSize : parseFloat(value);
337
- return sign?.startsWith("-") ? -magnitude : magnitude;
338
- };
339
- const CLAUSE_TOKEN_RE = /^(top|center|bottom|[+-]?(?:\d+(?:\.\d*)?|\.\d+))?(%|px)?(?:([+-]=?)(\d+(?:\.\d*)?|\.\d+)(%|px)?)?$/;
340
- const parseClauseToken = (token, refSize) => {
341
- const match = CLAUSE_TOKEN_RE.exec(token);
342
- if (!match || !match[1] && !match[3]) {
343
- if (MAX_TOKEN_RE.test(token)) throw new Error(`StickyScrollTrigger: unsupported position clause "${token}": 'max' is GSAP's end-only keyword for the scroller's maximum scroll position.`);
344
- throw new Error(`StickyScrollTrigger: unsupported position clause "${token}"`);
345
- }
346
- const [, base, baseUnit, sign, offsetValue, offsetUnit] = match;
347
- if (base !== void 0 && sign && !sign.includes("=")) {
348
- const suggestion = `${base}${baseUnit ?? ""}${sign}=${offsetValue}${offsetUnit ?? ""}`;
349
- throw new Error(`StickyScrollTrigger: unsupported position clause "${token}": a signed offset needs an explicit '=' when it follows a keyword or number (GSAP needs it to tell "${base}" from the offset). Did you mean "${suggestion}"?`);
350
- }
351
- const isKeyword = base !== void 0 && base in KEYWORD_FRACTIONS;
352
- const basePercent = baseUnit === "%";
353
- return {
354
- fraction: isKeyword ? KEYWORD_FRACTIONS[base] : basePercent ? parseFloat(base) / 100 : 0,
355
- offsetPx: (!isKeyword && !basePercent && base !== void 0 ? parseFloat(base) : 0) + (sign ? signedPx(sign, offsetValue, offsetUnit, refSize) : 0)
356
- };
357
- };
358
- const isAbsoluteFormat = (resolved) => {
359
- if (typeof resolved === "number") return true;
360
- return resolved.trim() !== "" && !Number.isNaN(Number(resolved));
361
- };
362
- const resolveAbsolute = (resolved) => typeof resolved === "number" ? resolved : Number(resolved);
363
- const CLAMP_PREFIX = "clamp(";
364
- const assertNotClamped = (trimmed) => {
365
- if (!trimmed.startsWith(CLAMP_PREFIX)) return;
366
- const inner = trimmed.slice(6).replace(/\)$/, "").trim();
367
- throw new Error(`StickyScrollTrigger: unsupported position clause "${trimmed}": GSAP's clamp() wrapper isn't supported here.` + (inner ? ` Did you mean "${inner}"?` : ""));
368
- };
369
- const resolveAnchorTop = (position, elementHeight, viewportHeight) => {
370
- const trimmed = position.trim();
371
- assertNotClamped(trimmed);
372
- const [elementToken, viewportToken = "top"] = trimmed.split(/\s+/);
373
- const elementClause = parseClauseToken(elementToken, elementHeight);
374
- const viewportClause = parseClauseToken(viewportToken, viewportHeight);
375
- return viewportHeight * viewportClause.fraction + viewportClause.offsetPx - (elementHeight * elementClause.fraction + elementClause.offsetPx);
376
- };
377
- const DWELL_RELATIVE_RE = /^\+=(\d+(?:\.\d*)?|\.\d+)(%|px)?$/;
378
- const isDwellFormat = (resolved) => typeof resolved === "string" && DWELL_RELATIVE_RE.test(resolved.trim());
379
- const prefixSpacedRelativeEnd = (start, endResolved) => {
380
- if (typeof endResolved !== "string") return endResolved;
381
- const trimmedEnd = endResolved.trim();
382
- if (!trimmedEnd.startsWith("+=") || !/\s/.test(trimmedEnd)) return endResolved;
383
- const startResolved = resolveMaybeFn(start);
384
- if (typeof startResolved !== "string") return endResolved;
385
- const trimmedStart = startResolved.trim();
386
- assertNotClamped(trimmedStart);
387
- const [elementToken] = trimmedStart.split(/\s+/);
388
- try {
389
- parseClauseToken(elementToken, 0);
390
- } catch (error) {
391
- if (!isAbsoluteFormat(startResolved)) throw error;
392
- return endResolved;
393
- }
394
- parseClauseToken(trimmedEnd.split(/\s+/)[0], 0);
395
- if (elementToken.includes("=")) throw new Error(`StickyScrollTrigger: end "${endResolved}" can't be resolved against start "${startResolved}": GSAP reads an end that starts with '+=' and holds a space by prefixing it with the start clause's element token, and "${elementToken}" carries an offset of its own, which GSAP resolves by discarding the end's. Give end a complete position clause instead, such as 'top+=100 bottom'.`);
396
- return elementToken + trimmedEnd;
397
- };
398
- const resolveDwell = (resolved, viewportHeight) => {
399
- const match = DWELL_RELATIVE_RE.exec(String(resolved).trim());
400
- if (!match) throw new Error(`StickyScrollTrigger: unsupported end format "${resolved}"`);
401
- const [, value, unit] = match;
402
- return signedPx(void 0, value, unit, viewportHeight);
403
- };
404
- const MAX_TOKEN_RE = /^max(?:([+-]=)(\d+(?:\.\d*)?|\.\d+)(%|px)?)?$/;
405
- const isMaxFormat = (resolved) => typeof resolved === "string" && MAX_TOKEN_RE.test(resolved.trim());
406
- const resolveMaxOffset = (resolved, viewportHeight) => {
407
- const match = MAX_TOKEN_RE.exec(resolved.trim());
408
- if (!match) throw new Error(`StickyScrollTrigger: unsupported max-position format "${resolved}"`);
409
- const [, sign, value, unit] = match;
410
- return sign ? signedPx(sign, value, unit, viewportHeight) : 0;
411
- };
412
- const classifyPosition = (resolved) => {
413
- if (typeof resolved === "number") return {
414
- kind: "absolute",
415
- value: resolved
416
- };
417
- if (isDwellFormat(resolved)) return {
418
- kind: "dwell",
419
- value: resolved
420
- };
421
- if (isMaxFormat(resolved)) return {
422
- kind: "max",
423
- value: resolved
424
- };
425
- if (isAbsoluteFormat(resolved)) return {
426
- kind: "absolute",
427
- value: resolveAbsolute(resolved)
428
- };
429
- return {
430
- kind: "clause",
431
- value: resolved
432
- };
433
- };
434
- const gapsBeforeRawPosition = (measurements, paddingHeightsSoFar, previous, rawPosition, ownIndex) => {
435
- let total = 0;
436
- measurements.forEach((measurement, i) => {
437
- if (i === ownIndex || measurement.triggerTop >= rawPosition) return;
438
- const paddingHeight = paddingHeightsSoFar[i] !== void 0 ? paddingHeightsSoFar[i] : previous ? previous.paddings[i] : null;
439
- if (paddingHeight !== null && paddingHeight !== void 0) total += paddingHeight;
440
- });
441
- return total;
442
- };
443
- const runPass = (measurements, { viewportHeight, structureTop, documentMaxScroll, measureLiveEndTriggerTop }, previous) => {
444
- const naturalTops = [];
445
- const paddingHeightsSoFar = [];
446
- let precedingGaps = 0;
447
- return {
448
- plans: measurements.map((measurement, index) => {
449
- const naturalAbsoluteTop = measurement.triggerTop + precedingGaps;
450
- const freezeStart = measurement.start.mode === "absolute" ? measurement.start.value : naturalAbsoluteTop - measurement.start.anchorOffset;
451
- let freezeEnd;
452
- switch (measurement.end.mode) {
453
- case "auto":
454
- if (measurement.start.mode !== "clause") throw new Error("StickyScrollTrigger: internal error: an absolute start reached 'auto' end mode, which resolveStartSpec should have already rejected.");
455
- freezeEnd = freezeStart + Math.max(0, measurement.start.anchorOffset + (measurement.coverTop - measurement.triggerTop));
456
- break;
457
- case "dwell":
458
- freezeEnd = freezeStart + measurement.end.distancePx;
459
- break;
460
- case "absolute":
461
- freezeEnd = Math.max(freezeStart, measurement.end.value);
462
- break;
463
- case "max":
464
- freezeEnd = Math.max(freezeStart, documentMaxScroll + measurement.end.offsetPx);
465
- break;
466
- case "clause": {
467
- let endTop;
468
- if (measurement.endTriggerIsSelf) endTop = naturalAbsoluteTop;
469
- else {
470
- const known = measurement.endTriggerIndex === null ? void 0 : naturalTops[measurement.endTriggerIndex] !== void 0 ? naturalTops[measurement.endTriggerIndex] : previous ? previous.naturalTops[measurement.endTriggerIndex] : void 0;
471
- if (known !== void 0) endTop = known;
472
- else if (measurement.end.measureLive) endTop = measureLiveEndTriggerTop(index);
473
- else endTop = measurement.end.rawTop === null ? 0 : measurement.end.rawTop + gapsBeforeRawPosition(measurements, paddingHeightsSoFar, previous, measurement.end.rawTop, index);
474
- }
475
- const anchorOffsetEnd = resolveAnchorTop(measurement.end.clause, measurement.endTriggerHeight, viewportHeight);
476
- freezeEnd = Math.max(freezeStart, endTop - anchorOffsetEnd);
477
- break;
478
- }
479
- }
480
- let plan;
481
- if (measurement.kind === "cover") {
482
- if (measurement.start.mode !== "clause") throw new Error("StickyScrollTrigger: internal error: a cover layer measurement carries an absolute start, which resolveStartSpec should have already rejected.");
483
- plan = {
484
- freezeStart,
485
- freezeEnd,
486
- stickyTop: measurement.start.anchorOffset - (measurement.triggerTop - measurement.wrapperTop),
487
- paddingHeight: null
488
- };
489
- } else plan = {
490
- freezeStart,
491
- freezeEnd,
492
- stickyTop: structureTop - freezeStart,
493
- paddingHeight: Math.max(0, freezeEnd - freezeStart)
494
- };
495
- if (plan.paddingHeight !== null) precedingGaps += plan.paddingHeight;
496
- naturalTops[index] = naturalAbsoluteTop;
497
- paddingHeightsSoFar[index] = plan.paddingHeight;
498
- return plan;
499
- }),
500
- naturalTops
501
- };
502
- };
503
- const planLayers = (measurements, deps) => {
504
- const needsConvergence = measurements.some((measurement, index) => {
505
- if (measurement.end.mode !== "clause" || measurement.endTriggerIsSelf) return false;
506
- return measurement.endTriggerIndex === null ? measurement.end.rawTop !== null : measurement.endTriggerIndex >= index;
507
- });
508
- const liveTopCache = new Map();
509
- const passDeps = {
510
- ...deps,
511
- measureLiveEndTriggerTop: (index) => {
512
- const cached = liveTopCache.get(index);
513
- if (cached !== void 0) return cached;
514
- const value = deps.measureLiveEndTriggerTop(index);
515
- liveTopCache.set(index, value);
516
- return value;
517
- }
518
- };
519
- let { plans, naturalTops } = runPass(measurements, passDeps, null);
520
- if (needsConvergence) for (let pass = 0; pass < measurements.length; pass += 1) {
521
- const previous = {
522
- paddings: plans.map((plan) => plan.paddingHeight),
523
- naturalTops
524
- };
525
- const next = runPass(measurements, passDeps, previous);
526
- const stable = next.plans.every((plan, i) => plan.paddingHeight === plans[i].paddingHeight);
527
- plans = next.plans;
528
- naturalTops = next.naturalTops;
529
- if (stable) break;
530
- if (pass === measurements.length - 1) throw new Error("StickyScrollTrigger: could not resolve endTrigger positions: some endTrigger references form a circular structural dependency, each layer's end depending on a layer whose own end depends back on it. Point each endTrigger at a layer that doesn't depend on it.");
531
- }
532
- plans.forEach((plan, index) => deps.onPlanned(index, plan));
533
- return plans;
534
- };
535
932
  const resolveEndSpec = (rootElement, viewportHeight, layer, endResolved, ownIndex, endTriggerIndex) => {
536
933
  if (endResolved === null) return { mode: "auto" };
537
934
  const classified = classifyPosition(endResolved);
@@ -551,7 +948,7 @@ var StickyScrollTrigger = (function() {
551
948
  offsetPx: resolveMaxOffset(classified.value, viewportHeight)
552
949
  };
553
950
  case "clause": {
554
- if (layer.kind !== "cover" && endTriggerIndex !== null && endTriggerIndex > ownIndex) throw new Error(`StickyScrollTrigger: createStickyTrigger's trigger ${describeElement(layer.trigger)}'s endTrigger (${describeElement(layer.endTrigger)}) refers to a layer positioned later in DOM order, which isn't supported: this layer's own dwell padding pushes that one down, so the freeze window would depend on its own dwell. Point endTrigger at a layer earlier in DOM order, or use a dwell distance such as '+=500'.`);
951
+ if (layer.kind !== "cover" && endTriggerIndex !== null && endTriggerIndex > ownIndex) throw new Error(`StickyScrollTrigger: createStickyTrigger's trigger ${describeElement(layer.trigger)}'s endTrigger (${describeElement(layer.endTrigger)}) refers to a layer positioned later in DOM order, which isn't supported for createStickyTrigger. Point endTrigger at a layer earlier in DOM order, use an unregistered element at the same spot, or use a dwell distance such as '+=500'.`);
555
952
  const unregistered = endTriggerIndex === null;
556
953
  const insideRoot = rootElement.contains(layer.endTrigger);
557
954
  if (unregistered && !insideRoot && layer.kind !== "cover") throw new Error(`StickyScrollTrigger: createStickyTrigger's trigger ${describeElement(layer.trigger)} has an endTrigger (${describeElement(layer.endTrigger)}) outside the shared container: the layer's own dwell keeps pushing it away, so the freeze window never settles. Point endTrigger at an element inside the container, or use a dwell distance such as '+=500'.`);
@@ -577,7 +974,8 @@ var StickyScrollTrigger = (function() {
577
974
  case "dwell":
578
975
  case "clause": return {
579
976
  mode: "clause",
580
- anchorOffset: resolveAnchorTop(classified.value, elementHeight, viewportHeight)
977
+ anchorOffset: resolveAnchorTop(classified.value, elementHeight, viewportHeight),
978
+ elementFraction: resolveElementFraction(classified.value)
581
979
  };
582
980
  }
583
981
  };
@@ -593,12 +991,16 @@ var StickyScrollTrigger = (function() {
593
991
  kind: layer.kind,
594
992
  start,
595
993
  triggerTop: documentTop(layer.trigger),
994
+ triggerHeight: elementHeight,
995
+ triggerEnclosedBy: [...indexByTrigger].filter(([trigger]) => trigger.contains(layer.trigger)).map(([, index]) => index),
596
996
  wrapperTop: layer.wrapper ? documentTop(layer.wrapper) : 0,
597
997
  coverTop: layer.kind === "cover" ? documentTop(layer.cover) : 0,
598
998
  end,
599
999
  endTriggerIsSelf,
600
1000
  endTriggerIndex,
601
- endTriggerHeight: end.mode === "clause" ? measureUsedHeight(layer.endTrigger) : 0
1001
+ endTriggerHeight: end.mode === "clause" ? measureUsedHeight(layer.endTrigger) : 0,
1002
+ endTriggerEnclosedBy: end.mode === "clause" && !end.measureLive && !endTriggerIsSelf ? [...indexByTrigger].filter(([trigger]) => trigger.contains(layer.endTrigger)).map(([, index]) => index) : [],
1003
+ endTriggerNests: end.mode === "clause" && !end.measureLive && !endTriggerIsSelf ? [...indexByTrigger].filter(([trigger]) => trigger !== layer.endTrigger && layer.endTrigger.contains(trigger)).map(([, index]) => index) : []
602
1004
  };
603
1005
  };
604
1006
  const EXCLUDED_VAR_KEYS = [
@@ -624,11 +1026,11 @@ var StickyScrollTrigger = (function() {
624
1026
  };
625
1027
  return typeof top === "function" ? () => toClause(top()) : toClause(top);
626
1028
  };
627
- const resolvePinReleaseTop = (endTrigger, classifiedEnd, engageTop, viewportHeight) => {
1029
+ const resolvePinReleaseScroll = (endTrigger, classifiedEnd, engageScroll, viewportHeight, toScroll) => {
628
1030
  switch (classifiedEnd.kind) {
629
- case "dwell": return engageTop + resolveDwell(classifiedEnd.value, viewportHeight);
1031
+ case "dwell": return engageScroll + resolveDwell(classifiedEnd.value, viewportHeight);
630
1032
  case "absolute": return classifiedEnd.value;
631
- case "clause": return documentTop(endTrigger) - resolveAnchorTop(classifiedEnd.value, measureUsedHeight(endTrigger), viewportHeight);
1033
+ case "clause": return toScroll(endTrigger, documentTop(endTrigger) - resolveAnchorTop(classifiedEnd.value, measureUsedHeight(endTrigger), viewportHeight));
632
1034
  }
633
1035
  };
634
1036
  const hasDuplicateTrigger = (list, trigger) => list.some((existing) => existing.trigger === trigger);
@@ -743,6 +1145,24 @@ var StickyScrollTrigger = (function() {
743
1145
  });
744
1146
  };
745
1147
  }
1148
+ #resetPinStickyState() {
1149
+ const snapshots = this.#pinLayers.filter((layer) => layer.inner).map(({ trigger }) => ({
1150
+ trigger,
1151
+ position: captureInlinePosition(trigger)
1152
+ }));
1153
+ snapshots.forEach(({ trigger }) => resetStickyPosition(trigger));
1154
+ return () => {
1155
+ snapshots.forEach(({ trigger, position }) => restoreInlinePosition(trigger, position));
1156
+ };
1157
+ }
1158
+ #resetStickyState() {
1159
+ const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
1160
+ const restorePinStickyState = this.#resetPinStickyState();
1161
+ return () => {
1162
+ restorePinStickyState();
1163
+ restoreSceneCoverStickyState();
1164
+ };
1165
+ }
746
1166
  #resetPinState() {
747
1167
  const snapshots = this.#pinLayers.map((layer) => ({
748
1168
  layer,
@@ -765,7 +1185,7 @@ var StickyScrollTrigger = (function() {
765
1185
  const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
766
1186
  const restorePinState = this.#resetPinState();
767
1187
  try {
768
- this.#refreshPinLayers(viewportHeight);
1188
+ this.#refreshPinLayers(viewportHeight, measureDocumentHeightWithoutPinRanges());
769
1189
  } catch (error) {
770
1190
  restorePinState();
771
1191
  throw error;
@@ -773,7 +1193,7 @@ var StickyScrollTrigger = (function() {
773
1193
  restoreSceneCoverStickyState();
774
1194
  }
775
1195
  }
776
- #refreshPinLayers(viewportHeight) {
1196
+ #refreshPinLayers(viewportHeight, documentHeight) {
777
1197
  this.#pinLayers.forEach((layer) => {
778
1198
  if (!layer.inner) return;
779
1199
  const resolvedStart = resolveMaybeFn(layer.start);
@@ -782,12 +1202,16 @@ var StickyScrollTrigger = (function() {
782
1202
  if (classifiedEnd.kind === "max") throw new Error(`StickyScrollTrigger: createStickyPin's end "${resolvedEnd}" uses GSAP's 'max' keyword, which isn't supported here: the pin's own spacer height adds to the document's max scroll position, so it would depend on itself. Use a position clause against endTrigger, such as 'top top'.`);
783
1203
  const triggerTop = documentTop(layer.trigger);
784
1204
  const triggerHeight = measureUsedHeight(layer.trigger);
1205
+ const triggerMarginBottom = parseFloat(getComputedStyle(layer.trigger).marginBottom) || 0;
785
1206
  const classifiedStart = classifyPosition(resolvedStart);
786
1207
  if (classifiedStart.kind === "absolute") throw new Error(`StickyScrollTrigger: createStickyPin's start "${resolvedStart}" is an absolute scroll position (GSAP reads any bare number this way). A pin can't act on one: it engages when position:sticky engages, so start says where trigger sits in the viewport while pinned. Use the top option (top: ${resolvedStart}) for a px distance from the viewport's top edge, or a position clause such as 'top top'.`);
787
1208
  const topPx = resolveAnchorTop(classifiedStart.value, triggerHeight, viewportHeight);
788
- const height = resolvePinReleaseTop(layer.endTrigger, classifiedEnd, triggerTop - topPx, viewportHeight) - triggerTop + topPx + triggerHeight;
1209
+ const toScroll = (element, reachedAt) => this.#addDwellBeforeReach(element, reachedAt);
1210
+ const releaseScroll = resolvePinReleaseScroll(layer.endTrigger, classifiedEnd, toScroll(layer.trigger, triggerTop - topPx), viewportHeight, toScroll);
1211
+ const height = releaseScroll - (this.#rootElement.contains(layer.trigger) ? dwellConsumedAt(releaseScroll, this.#engagedWindows()) : 0) - triggerTop + topPx + triggerHeight + triggerMarginBottom;
1212
+ const room = documentHeight > 0 ? documentHeight - triggerTop : Infinity;
789
1213
  applyStickyPosition(layer.trigger, topPx);
790
- layer.inner.style.height = `${Math.max(0, height)}px`;
1214
+ layer.inner.style.height = `${Math.max(0, Math.min(height, room))}px`;
791
1215
  });
792
1216
  }
793
1217
  #refreshScenesAndCovers(viewportHeight) {
@@ -795,11 +1219,14 @@ var StickyScrollTrigger = (function() {
795
1219
  const active = this.#layers.filter((layer) => layer.wrapper !== null);
796
1220
  if (!active.length) return;
797
1221
  const restoreStickyState = this.#resetSceneCoverStickyState();
1222
+ const restorePinStickyState = this.#resetPinStickyState();
798
1223
  try {
799
1224
  this.#planLayerPositions(viewportHeight, active);
800
1225
  } catch (error) {
801
1226
  restoreStickyState();
802
1227
  throw error;
1228
+ } finally {
1229
+ restorePinStickyState();
803
1230
  }
804
1231
  }
805
1232
  #planLayerPositions(viewportHeight, active) {
@@ -819,6 +1246,8 @@ var StickyScrollTrigger = (function() {
819
1246
  const layer = active[index];
820
1247
  layer.freezeStart = plan.freezeStart;
821
1248
  layer.freezeEnd = plan.freezeEnd;
1249
+ layer.engagedStart = plan.engagedStart;
1250
+ layer.engagedEnd = plan.engagedEnd;
822
1251
  if (!layer.wrapper) return;
823
1252
  applyStickyPosition(layer.wrapper, plan.stickyTop);
824
1253
  if (layer.kind === "scene" && layer.padding && plan.paddingHeight !== null) layer.padding.style.height = `${plan.paddingHeight}px`;
@@ -861,11 +1290,13 @@ var StickyScrollTrigger = (function() {
861
1290
  });
862
1291
  }
863
1292
  #syncScrollMargins() {
864
- this.#scrollMarginSync.sync(this.#layers.filter((layer) => layer.kind === "scene").map(({ trigger, freezeStart, freezeEnd }) => ({
865
- trigger,
866
- freezeStart,
867
- freezeEnd
868
- })), this.#outermostContainer);
1293
+ this.#scrollMarginSync.sync(this.#engagedWindows(), this.#outermostContainer, (targets) => {
1294
+ if (!targets.length) return [];
1295
+ const restoreStickyState = this.#resetStickyState();
1296
+ const tops = targets.map((target) => documentTop(target));
1297
+ restoreStickyState();
1298
+ return tops;
1299
+ });
869
1300
  }
870
1301
  #assertNoExcludedVars(rest, context) {
871
1302
  const found = EXCLUDED_VAR_KEYS.filter((key) => key in rest);
@@ -922,7 +1353,9 @@ var StickyScrollTrigger = (function() {
922
1353
  start,
923
1354
  end,
924
1355
  freezeStart: 0,
925
- freezeEnd: 0
1356
+ freezeEnd: 0,
1357
+ engagedStart: 0,
1358
+ engagedEnd: 0
926
1359
  }, onKill, rest);
927
1360
  }
928
1361
  createOverlapScroll({ trigger: triggerInput, cover, start = "bottom bottom", end = null, endTrigger: endTriggerInput, onKill, ...rest }) {
@@ -942,7 +1375,9 @@ var StickyScrollTrigger = (function() {
942
1375
  start,
943
1376
  end,
944
1377
  freezeStart: 0,
945
- freezeEnd: 0
1378
+ freezeEnd: 0,
1379
+ engagedStart: 0,
1380
+ engagedEnd: 0
946
1381
  };
947
1382
  const vars = this.#registerLayer(layer, (self) => {
948
1383
  this.#coverRestoreByLayer.get(layer)?.();
@@ -996,23 +1431,30 @@ var StickyScrollTrigger = (function() {
996
1431
  }
997
1432
  }
998
1433
  #resolveClauseScrollPosition(element, clause, viewportHeight) {
999
- let gap = 0;
1000
- this.#layers.forEach((layer) => {
1001
- if (layer.kind !== "scene") return;
1002
- if (compareDocumentOrder(layer.trigger, element) >= 0) return;
1003
- gap += layer.freezeEnd - layer.freezeStart;
1004
- });
1005
1434
  const anchorOffset = resolveAnchorTop(clause, measureUsedHeight(element), viewportHeight);
1006
- const restoreSceneCoverStickyState = this.#resetSceneCoverStickyState();
1007
- const result = documentTop(element) + gap - anchorOffset;
1008
- restoreSceneCoverStickyState();
1009
- return result;
1435
+ const restoreStickyState = this.#resetStickyState();
1436
+ const reachedAt = documentTop(element) - anchorOffset;
1437
+ restoreStickyState();
1438
+ return this.#addDwellBeforeReach(element, reachedAt);
1439
+ }
1440
+ #addDwellBeforeReach(element, reachedAt) {
1441
+ if (!this.#rootElement.contains(element)) return reachedAt;
1442
+ return reachedAt + dwellBeforeReach(reachedAt, this.#engagedWindows());
1443
+ }
1444
+ #engagedWindows() {
1445
+ return this.#layers.flatMap((layer) => layer.kind === "scene" ? [{
1446
+ freezeStart: layer.engagedStart,
1447
+ freezeEnd: layer.engagedEnd
1448
+ }] : []);
1010
1449
  }
1011
1450
  static getScrollTop(elementInput, instances) {
1012
1451
  const element = resolveElement(elementInput, "StickyScrollTrigger.getScrollTop");
1013
1452
  const owner = instances.find((instance) => instance.#rootElement.contains(element));
1014
1453
  if (owner) return owner.resolveScrollPosition(element, "top top");
1015
- return documentTop(element);
1454
+ const restores = instances.map((instance) => instance.#resetPinStickyState());
1455
+ const top = documentTop(element);
1456
+ restores.forEach((restore) => restore());
1457
+ return top;
1016
1458
  }
1017
1459
  createResolvedTrigger({ trigger: triggerInput, start = "top bottom", end = "bottom top", endTrigger: endTriggerInput, ...rest }) {
1018
1460
  this.#assertNoExcludedVars(rest, "createResolvedTrigger");