@blotch/angular-lynx 22.2.10 → 22.2.11

package/fesm2022/blotch-angular-lynx.mjs

@@ -2590,6 +2590,11 @@ const flushesBefore = (first, second) => {
 const isIOS = () => {
 	return ((typeof lynx !== "undefined" ? lynx.SystemInfo : void 0) ?? (typeof SystemInfo !== "undefined" ? SystemInfo : void 0))?.platform === "iOS";
 };
+const listenForScrollsFromTheStart = (element) => {
+	if (__WEB__ || !isIOS()) return;
+	element.addEventListener("bindscroll", ignoreScroll);
+};
+const ignoreScroll = () => {};
 const insertHidesBlurView = (parent, child) => !__WEB__ && child.tagName === "blur-view" && parent.tagName !== "blur-view" && isIOS();
 const isTextish = (el) => el.tagName === "text" || el.tagName === "raw-text";
 var LynxElement = class {
@@ -2615,6 +2620,7 @@ var LynxElement = class {
 	#ownTraits = null;
 	#addedTraits = [];
 	#listeners = [];
+	#heldEvents = /* @__PURE__ */ new Map();
 	#webLongPress = null;
 	#pointerEvents = null;
 	#webPointer = null;
@@ -2630,6 +2636,8 @@ var LynxElement = class {
 	static #pendingAttributeRemovals = /* @__PURE__ */ new Set();
 	#removedAttributes = /* @__PURE__ */ new Set();
 	static #byNativeId = /* @__PURE__ */ new Map();
+	static #pendingReleases = /* @__PURE__ */ new Set();
+	#destroyed = false;
 	static #canonicalFor(ref) {
 		return _a.#byNativeId.get(__GetElementUniqueID(ref)) ?? new _a(ref);
 	}
@@ -2644,6 +2652,15 @@ var LynxElement = class {
 		const id = __GetElementUniqueID(this.#nativeRef);
 		if (_a.#byNativeId.get(id) === this) _a.#byNativeId.delete(id);
 	}
+	markDestroyed() {
+		if (this.isRootPageElement) return;
+		this.#destroyed = true;
+		_a.#pendingReleases.add(this);
+		scheduleSettleFlush();
+	}
+	virtualChildren() {
+		return [];
+	}
 	get ownerDocument() {
 		return globalEvents().document;
 	}
@@ -2762,6 +2779,7 @@ var LynxElement = class {
 	insertBefore(newChild, refChild) {
 		if (newChild.isRootPageElement) return;
 		newChild.#cancelPendingRemoval();
+		newChild.#keepIfDestroyed();
 		newChild.#removeIfMoveWouldBeLost(this);
 		newChild.#recreateIfDead();
 		if (refChild == null) this.appendChild(newChild);
@@ -2783,6 +2801,7 @@ var LynxElement = class {
 	appendChild(newChild) {
 		if (newChild.isRootPageElement) return;
 		newChild.#cancelPendingRemoval();
+		newChild.#keepIfDestroyed();
 		newChild.#removeIfMoveWouldBeLost(this);
 		newChild.#recreateIfDead();
 		if (wouldFormCycle(this.element, newChild.element)) return;
@@ -2841,10 +2860,18 @@ var LynxElement = class {
 		}
 	}
 	static commitPendingRemovals() {
-		if (_a.#pendingRemovals.size === 0) return;
-		const items = [..._a.#pendingRemovals];
-		_a.#pendingRemovals.clear();
-		for (const el of items) el.#doRemove();
+		if (_a.#pendingRemovals.size > 0) {
+			const items = [..._a.#pendingRemovals];
+			_a.#pendingRemovals.clear();
+			for (const el of items) el.#doRemove();
+		}
+		_a.#commitPendingReleases();
+	}
+	static #commitPendingReleases() {
+		if (_a.#pendingReleases.size === 0) return;
+		const elements = [..._a.#pendingReleases];
+		_a.#pendingReleases.clear();
+		for (const el of elements) if (el.#destroyed && !el.#jsParent && !el._virtualParent) el.#release();
 	}
 	static #enqueueTextNormalization(el) {
 		_a.#pendingTextNormalization.add(el);
@@ -2896,6 +2923,11 @@ var LynxElement = class {
 	#cancelPendingRemoval() {
 		_a.#pendingRemovals.delete(this);
 	}
+	#keepIfDestroyed() {
+		if (!this.#destroyed) return;
+		this.#destroyed = false;
+		_a.#pendingReleases.delete(this);
+	}
 	#removeIfMoveWouldBeLost(newParent) {
 		if (__WEB__ || this.#paintingDead || this._virtualParent) return;
 		const oldParent = __GetParent(this.element);
@@ -2903,7 +2935,7 @@ var LynxElement = class {
 		if (flushesBefore(newParent.element, oldParent)) this.#doRemove();
 	}
 	#doRemove() {
-		const parent = this.parentNode();
+		const parent = __GetParent(this.element);
 		if (!parent) return;
 		for (const anim of this.#activeAnimations) anim.cancel();
 		if (this.#activeAnimations.length > 0) {
@@ -2911,7 +2943,7 @@ var LynxElement = class {
 			__AddInlineStyle(this.element, "transform", null);
 			this.#activeAnimations.length = 0;
 		}
-		__RemoveElement(parent.element, this.element);
+		__RemoveElement(parent, this.element);
 		const jsParent = this.#jsParent;
 		if (jsParent) {
 			const i = jsParent.#children.indexOf(this);
@@ -2921,6 +2953,15 @@ var LynxElement = class {
 		}
 		this.#markPaintingDead();
 		if (jsParent && isTextish(this)) _a.#enqueueTextNormalization(jsParent);
+		if (this.#destroyed) this.#release();
+	}
+	#release() {
+		this.#destroyed = false;
+		this.#paintingDead = true;
+		this.deregisterNative();
+		for (const { eventType, eventName } of this.#nativeHandlers.values()) __AddEvent(this.element, eventType, eventName, void 0);
+		for (const child of this.#children) child.#release();
+		for (const child of this.virtualChildren()) child.#release();
 	}
 	#markPaintingDead() {
 		this.#paintingDead = true;
@@ -3132,11 +3173,13 @@ var LynxElement = class {
 	}
 	#syncNativeHandler(entry) {
 		const key = nativeEventKey(entry.eventType, entry.eventName);
+		if (this.#heldEvents.has(key)) return;
 		const listeners = this.#listenersLike(entry);
 		const current = this.#nativeHandlers.get(key);
 		const eventType = listeners.length ? combinedEventType(listeners) : null;
 		if (current?.eventType === eventType) return;
 		scheduleSettleFlush();
+		this.#sendHandlersWithNextFlush();
 		if (current) {
 			__AddEvent(this.element, current.eventType, entry.eventName, void 0);
 			this.#nativeHandlers.delete(key);
@@ -3153,6 +3196,25 @@ var LynxElement = class {
 			value: handler.dispatch
 		});
 	}
+	holdNativeEvent(eventName) {
+		this.#heldEvents.set(eventName, (this.#heldEvents.get(eventName) ?? 0) + 1);
+		this.#nativeHandlers.delete(eventName);
+	}
+	releaseNativeEvent(eventName) {
+		const held = this.#heldEvents.get(eventName);
+		if (held === void 0) return;
+		if (held > 1) {
+			this.#heldEvents.set(eventName, held - 1);
+			return;
+		}
+		this.#heldEvents.delete(eventName);
+		const entry = this.#listeners.find((listener) => listener.eventName === eventName && listener.eventType !== "global-bindEvent");
+		if (entry) this.#syncNativeHandler(entry);
+	}
+	#sendHandlersWithNextFlush() {
+		if (__WEB__) return;
+		__SetDataset(this.element, { ...this.#dataset });
+	}
 	#dispatch(entry, event) {
 		if (event && typeof event === "object") {
 			if (typeof event.stopPropagation !== "function") event.stopPropagation = () => {};
@@ -3269,6 +3331,11 @@ var LynxListElement = class extends LynxElement {
 		}
 		return children;
 	}
+	virtualChildren() {
+		const children = [];
+		for (let child = this.#firstVirtualChild; child; child = child._virtualNext) children.push(child);
+		return children;
+	}
 	getCommittedUIChildren() {
 		return this.#committedUIChildren;
 	}
@@ -5937,6 +6004,9 @@ const noHandler = () => ({
 });
 var LynxMainThreadEvent = class LynxMainThreadEvent {
 	#el = inject(ElementRef).nativeElement;
+	get #host() {
+		return this.#el;
+	}
 	#registrations = /* @__PURE__ */ new Map();
 	mainThreadBindtap;
 	mainThreadCatchtap;
@@ -5981,9 +6051,13 @@ var LynxMainThreadEvent = class LynxMainThreadEvent {
 				__workletMap[workletId] = handle;
 			}
 			if (workletId === void 0) {
-				if (this.#registrations.delete(inputName)) __AddEvent(elementRef, eventType, eventName, noHandler());
+				if (this.#registrations.delete(inputName)) {
+					__AddEvent(elementRef, eventType, eventName, noHandler());
+					this.#host.releaseNativeEvent?.(eventName);
+				}
 				continue;
 			}
+			if (!this.#registrations.has(inputName)) this.#host.holdNativeEvent?.(eventName);
 			__AddEvent(elementRef, eventType, eventName, {
 				type: "worklet",
 				value: {
@@ -5999,6 +6073,7 @@ var LynxMainThreadEvent = class LynxMainThreadEvent {
 		if (!elementRef) return;
 		for (const [inputName, { eventType, eventName }] of this.#registrations) {
 			__AddEvent(elementRef, eventType, eventName, noHandler());
+			this.#host.releaseNativeEvent?.(eventName);
 			this.#release(inputName);
 		}
 		this.#registrations.clear();
@@ -9593,6 +9668,7 @@ const CONTEXT_EVENTS = /* @__PURE__ */ new Set([
 	"webglcontextrestored",
 	"webglcontextcreationerror"
 ]);
+const contextFinalizer = typeof FinalizationRegistry === "function" ? new FinalizationRegistry((free) => free()) : null;
 const kebab = (name) => name.startsWith("--") ? name : name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
 const createStyle = (element) => {
 	return new Proxy({}, {
@@ -9702,6 +9778,7 @@ var LynxCanvasElement = class extends LynxElement {
 			return null;
 		}
 		this.#context = new LynxWebGL2RenderingContext(bridge, contextId, this, resolved);
+		contextFinalizer?.register(this, () => bridge.destroy(contextId));
 		return this.#context;
 	}
 	addEventListener(name, cb) {
@@ -9840,7 +9917,11 @@ var LynxDocument = class {
 		/* v8 ignore next */
 		if (__PROFILE__) devStats.elementCreated++;
 		scheduleSettleFlush();
-		if (tag === "list") return createListElement(this.#pageId);
+		if (tag === "list") {
+			const list = createListElement(this.#pageId);
+			listenForScrollsFromTheStart(list);
+			return list;
+		}
 		if (tag === "page") {
 			const result = createPageElement(this.page, this.#pageElementRequested);
 			this.#pageElementRequested = result.pageElementRequested;
@@ -9851,6 +9932,7 @@ var LynxDocument = class {
 		el.tagName = tag;
 		if (tag === "raw-text") el.setInitialText(value ?? "");
 		if (tag === "blur-view") el.updateBlurMaterial();
+		if (tag === "scroll-view") listenForScrollsFromTheStart(el);
 		return el;
 	}
 	createText(value) {
@@ -9994,7 +10076,7 @@ var LynxRenderer = class {
 		return this.#document.createText(collapseWhitespace(value));
 	}
 	destroyNode = (node) => {
-		node.deregisterNative?.();
+		node.markDestroyed?.();
 		node.releaseContext?.();
 	};
 	appendChild(parent, newChild) {
@@ -11407,7 +11489,7 @@ const sizeOf = (width, height) => [{
 	inlineSize: width,
 	blockSize: height
 }];
-const entryFor$1 = (target, rect) => {
+const entryFor = (target, rect) => {
 	const ratio = pixelRatio();
 	return {
 		target,
@@ -11436,7 +11518,7 @@ var LynxResizeObserver = class {
 		const notify = (rect) => {
 			if (last && last.width === rect.width && last.height === rect.height) return;
 			last = rect;
-			this.#callback([entryFor$1(target, rect)], this);
+			this.#callback([entryFor(target, rect)], this);
 		};
 		this.#observed.set(target, target.observeLayout(notify));
 		const rect = target.layoutRect;
@@ -11491,40 +11573,64 @@ const wrapResizeObserver = (NativeResizeObserver) => {
 	};
 };
 const isLynxElement = (value) => typeof value === "object" && value !== null && "element" in value && typeof value.addEventListener === "function" && typeof value.observeLayout === "function" && typeof value.parentNode === "function";
-const SCROLL_CONTAINERS = /* @__PURE__ */ new Set([
-	"scroll-view",
-	"list",
-	"viewpager",
-	"scroll-coordinator"
+const SCROLL_EVENTS = /* @__PURE__ */ new Map([
+	["scroll-view", "bindscroll"],
+	["list", "bindscroll"],
+	["viewpager", "bindoffsetchange"],
+	["scroll-coordinator", "bindoffset"]
 ]);
-const measure = (element) => new Promise((resolve) => measureLayout(element.element, resolve));
-const measureGeometry = async (target) => {
+const measurements = /* @__PURE__ */ new Map();
+let sampleMeasurements = null;
+const measure = (element) => {
+	const native = element.element;
+	const shared = sampleMeasurements?.get(native) ?? measurements.get(native);
+	if (shared) return shared;
+	let answered = false;
+	const rect = new Promise((resolve) => measureLayout(native, (box) => {
+		answered = true;
+		measurements.delete(native);
+		resolve(box);
+	}));
+	sampleMeasurements?.set(native, rect);
+	if (!answered) measurements.set(native, rect);
+	return rect;
+};
+const measureGeometry = async (target, root) => {
 	const scrollContainers = [];
 	let top = target;
+	let inRoot = false;
 	while (!top.isRootPageElement) {
 		const parent = top.parentNode();
 		if (!parent) break;
-		if (SCROLL_CONTAINERS.has(parent.tagName)) scrollContainers.push(parent);
+		if (parent === root) {
+			inRoot = true;
+			break;
+		}
+		if (SCROLL_EVENTS.has(parent.tagName)) scrollContainers.push(parent);
 		top = parent;
 	}
-	const page = top.isRootPageElement ? top : null;
-	const [box, root, ...scrollBoxes] = await Promise.all([
+	if (!root) inRoot = top.isRootPageElement === true;
+	const rootElement = root ?? (inRoot ? top : null);
+	const clips = inRoot ? scrollContainers : [];
+	const [box, rootBox, ...scrollBoxes] = await Promise.all([
 		measure(target),
-		page ? measure(page) : null,
-		...scrollContainers.map(measure)
+		rootElement ? measure(rootElement) : null,
+		...clips.map(measure)
 	]);
 	return {
 		box: box ?? null,
-		root: root ?? null,
-		scrollContainers: scrollBoxes
+		root: rootBox ?? null,
+		inRoot,
+		scrollContainers: scrollBoxes,
+		scrolledBy: root && inRoot && SCROLL_EVENTS.has(root.tagName) ? [...clips, root] : clips
 	};
 };
-const intersect = (a, b) => {
+const intersect = (a, b, touching) => {
 	const left = Math.max(a.left, b.left);
 	const top = Math.max(a.top, b.top);
 	const right = Math.min(a.left + a.width, b.left + b.width);
 	const bottom = Math.min(a.top + a.height, b.top + b.height);
-	return right > left && bottom > top ? {
+	return (touching ? right >= left && bottom >= top : right > left && bottom > top) ? {
 		left,
 		top,
 		width: right - left,
@@ -11533,11 +11639,11 @@ const intersect = (a, b) => {
 };
 const visiblePart = ({ box, root, scrollContainers }) => {
 	let visible = box;
-	for (const clip of [root, ...scrollContainers]) visible = visible && clip ? intersect(visible, clip) : null;
+	for (const clip of [root, ...scrollContainers]) visible = visible && clip ? intersect(visible, clip, false) : null;
 	return visible;
 };
 const area = (rect) => rect.width * rect.height;
-const entryFor = (target, geometry, exposed) => {
+const exposureEntryFor = (target, geometry, exposed) => {
 	const visible = visiblePart(geometry);
 	const isIntersecting = exposed ?? visible !== null;
 	const { box } = geometry;
@@ -11553,6 +11659,51 @@ const entryFor = (target, geometry, exposed) => {
 		isIntersecting
 	};
 };
+const grow = (rect, margin) => {
+	const [top, right, bottom, left] = margin.map((side, index) => side.percent ? side.value * (index % 2 ? rect.width : rect.height) / 100 : side.value);
+	return {
+		left: rect.left - left,
+		top: rect.top - top,
+		width: Math.max(rect.width + left + right, 0),
+		height: Math.max(rect.height + top + bottom, 0)
+	};
+};
+const thresholdIndexOf = (ratio, thresholds) => {
+	let index = 0;
+	while (index < thresholds.length && thresholds[index] <= ratio + 1e-6) index++;
+	return index;
+};
+const measuredEntryFor = (target, geometry, margin, thresholds, exposed) => {
+	const { box } = geometry;
+	const rootBounds = geometry.root && grow(geometry.root, margin);
+	let visible = null;
+	let overlaps = false;
+	let ratio = 0;
+	if (!box) {
+		overlaps = exposed === true;
+		ratio = overlaps ? 1 : 0;
+	} else if (geometry.inRoot && rootBounds) {
+		visible = box;
+		for (const clip of [...geometry.scrollContainers, rootBounds]) visible = visible && clip ? intersect(visible, clip, true) : null;
+		if (visible) {
+			overlaps = true;
+			ratio = area(box) === 0 ? 1 : Math.min(area(visible) / area(box), 1);
+		}
+	}
+	const index = overlaps ? thresholdIndexOf(ratio, thresholds) : 0;
+	return {
+		index,
+		entry: {
+			target,
+			time: performance.now(),
+			rootBounds: rootBounds ? toDOMRect(rootBounds) : null,
+			boundingClientRect: toDOMRect(box),
+			intersectionRect: toDOMRect(visible),
+			intersectionRatio: ratio,
+			isIntersecting: index > 0
+		}
+	};
+};
 const thresholdsOf = (threshold) => {
 	const given = threshold === void 0 ? [] : Array.isArray(threshold) ? threshold.map(Number) : [Number(threshold)];
 	for (const value of given) if (!(value >= 0 && value <= 1)) throw new RangeError("Failed to construct 'IntersectionObserver': Threshold values must be numbers between 0 and 1");
@@ -11561,26 +11712,53 @@ const thresholdsOf = (threshold) => {
 const rootMarginOf = (margin) => {
 	const tokens = String(margin ?? "").trim().split(/\s+/).filter(Boolean);
 	if (tokens.length > 4) throw invalidRootMargin();
-	const [top = "0px", right = top, bottom = top, left = right] = tokens.map((token) => {
+	const [top = NO_MARGIN, right = top, bottom = top, left = right] = tokens.map((token) => {
 		const match = /^(-?(?:\d+\.?\d*|\.\d+))(px|%)?$/.exec(token);
 		if (!match || !match[2] && Number(match[1]) !== 0) throw invalidRootMargin();
-		return match[2] ? token : "0px";
+		return match[2] ? {
+			text: token,
+			value: Number(match[1]),
+			percent: match[2] === "%"
+		} : NO_MARGIN;
 	});
-	return `${top} ${right} ${bottom} ${left}`;
+	return [
+		top,
+		right,
+		bottom,
+		left
+	];
+};
+const NO_MARGIN = {
+	text: "0px",
+	value: 0,
+	percent: false
 };
 const invalidRootMargin = () => /* @__PURE__ */ new SyntaxError("Failed to construct 'IntersectionObserver': rootMargin must be specified in pixels or percent.");
-const DEFAULT_ROOT_MARGIN = "0px 0px 0px 0px";
-let warnedOfOptions = false;
-const warnOfOptions = (observer) => {
-	if (warnedOfOptions) return;
-	const ignored = [
-		observer.root !== null && "root",
-		observer.rootMargin !== DEFAULT_ROOT_MARGIN && "rootMargin",
-		(observer.thresholds.length !== 1 || observer.thresholds[0] !== 0) && "threshold"
-	].filter(Boolean);
-	if (!ignored.length) return;
-	warnedOfOptions = true;
-	console.warn(`[angular-lynx] IntersectionObserver on Lynx reports when an element comes into view and when it leaves, inside its scroll containers and the screen. It ignores ${ignored.join(", ")} for now.`);
+const SAMPLE_INTERVAL = 50;
+const SAMPLES_AFTER_SCROLL = 6;
+const scrolling = /* @__PURE__ */ new Map();
+let samplingTimer = null;
+const sampleWhileScrolling = (sample) => {
+	scrolling.set(sample, SAMPLES_AFTER_SCROLL);
+	if (samplingTimer === null) samplingTimer = setTimeout(sampleScrolling, SAMPLE_INTERVAL);
+};
+const sampleScrolling = () => {
+	samplingTimer = null;
+	sampleMeasurements = /* @__PURE__ */ new Map();
+	for (const [sample, left] of Array.from(scrolling)) {
+		if (left > 1) scrolling.set(sample, left - 1);
+		else scrolling.delete(sample);
+		sample();
+	}
+	sampleMeasurements = null;
+	if (scrolling.size && samplingTimer === null) samplingTimer = setTimeout(sampleScrolling, SAMPLE_INTERVAL);
+};
+const stopSampling = (sample) => {
+	scrolling.delete(sample);
+	if (!scrolling.size && samplingTimer !== null) {
+		clearTimeout(samplingTimer);
+		samplingTimer = null;
+	}
 };
 var LynxIntersectionObserver = class {
 	static forLynxElements = true;
@@ -11588,6 +11766,9 @@ var LynxIntersectionObserver = class {
 	rootMargin;
 	thresholds;
 	#callback;
+	#root;
+	#margin;
+	#measures;
 	#observed = /* @__PURE__ */ new Map();
 	#records = [];
 	#delivering = false;
@@ -11595,39 +11776,56 @@ var LynxIntersectionObserver = class {
 		if (typeof callback !== "function") throw new TypeError("Failed to construct 'IntersectionObserver': parameter 1 is not of type 'Function'.");
 		this.#callback = callback;
 		const root = options.root;
-		this.root = root === void 0 || root === globalThis.document ? null : root;
-		this.rootMargin = rootMarginOf(options.rootMargin);
+		if (root === void 0 || root === null || root === globalThis.document) this.#root = null;
+		else if (isLynxElement(root)) this.#root = root;
+		else throw new TypeError("Failed to construct 'IntersectionObserver': Failed to read the 'root' property from 'IntersectionObserverInit': The provided value is not of type '(Document or Element)'.");
+		this.root = this.#root;
+		this.#margin = rootMarginOf(options.rootMargin);
+		this.rootMargin = this.#margin.map((side) => side.text).join(" ");
 		this.thresholds = thresholdsOf(options.threshold);
-		warnOfOptions(this);
+		this.#measures = this.#root !== null || this.#margin.some((side) => side.value !== 0) || this.thresholds.length !== 1 || this.thresholds[0] !== 0;
 	}
 	observe(target) {
 		if (!isLynxElement(target)) throw new TypeError("Failed to execute 'observe' on 'IntersectionObserver': parameter 1 is not of type 'Element'.");
 		if (this.#observed.has(target)) return;
 		const stopAppear = target.addEventListener("binduiappear", () => {
-			this.#report(target, observation, true);
+			this.#exposure(target, observation, true);
 		});
 		const stopDisappear = target.addEventListener("binduidisappear", () => {
-			this.#report(target, observation, false);
+			this.#exposure(target, observation, false);
 		});
 		let laidOut = false;
-		const first = () => {
+		const layout = () => {
+			if (this.#measures) {
+				observation.sample();
+				return;
+			}
 			if (laidOut) return;
 			laidOut = true;
 			stopLayout();
 			this.#report(target, observation, null);
 		};
-		const stopLayout = target.observeLayout(first);
+		const stopLayout = target.observeLayout(layout);
 		const observation = {
 			stop: () => {
 				stopAppear();
 				stopDisappear();
 				stopLayout();
+				for (const stopScroll of observation.scrollListeners.values()) stopScroll();
+				observation.scrollListeners.clear();
+				stopSampling(observation.sample);
 			},
-			intersecting: null,
-			events: 0
+			index: null,
+			exposed: null,
+			events: 0,
+			measuring: false,
+			again: false,
+			measured: false,
+			scrollListeners: /* @__PURE__ */ new Map(),
+			sample: () => this.#sample(target, observation)
 		};
 		this.#observed.set(target, observation);
-		if (target.layoutRect) queueMicrotask(first);
+		if (target.layoutRect) queueMicrotask(layout);
 	}
 	unobserve(target) {
 		const observation = this.#observed.get(target);
@@ -11644,14 +11842,61 @@ var LynxIntersectionObserver = class {
 	takeRecords() {
 		return this.#records.splice(0);
 	}
+	#exposure(target, observation, exposed) {
+		observation.exposed = exposed;
+		if (this.#measures) observation.sample();
+		else this.#report(target, observation, exposed);
+	}
 	async #report(target, observation, exposed) {
 		const event = exposed === null ? 0 : ++observation.events;
-		const geometry = await measureGeometry(target);
+		const geometry = await measureGeometry(target, null);
 		if (this.#observed.get(target) !== observation) return;
 		if (observation.events !== event) return;
-		const entry = entryFor(target, geometry, exposed);
-		if (entry.isIntersecting === observation.intersecting) return;
-		observation.intersecting = entry.isIntersecting;
+		const entry = exposureEntryFor(target, geometry, exposed);
+		const index = entry.isIntersecting ? 1 : 0;
+		if (index === observation.index) return;
+		observation.index = index;
+		this.#queue(entry);
+	}
+	#sample(target, observation) {
+		if (this.#observed.get(target) !== observation) return;
+		if (observation.measuring) {
+			observation.again = true;
+			return;
+		}
+		observation.measuring = true;
+		measureGeometry(target, this.#root).then((geometry) => {
+			observation.measuring = false;
+			if (this.#observed.get(target) !== observation) return;
+			this.#listenForScrolls(observation, geometry.scrolledBy);
+			if (geometry.box) observation.measured = true;
+			const { entry, index } = measuredEntryFor(target, geometry, this.#margin, this.thresholds, observation.measured ? null : observation.exposed);
+			if (index !== observation.index) {
+				observation.index = index;
+				this.#queue(entry);
+			}
+			if (observation.again) {
+				observation.again = false;
+				observation.sample();
+			}
+		});
+	}
+	#listenForScrolls(observation, scrolledBy) {
+		const current = new Set(scrolledBy);
+		for (const [scroller, stopScroll] of observation.scrollListeners) {
+			if (current.has(scroller)) continue;
+			stopScroll();
+			observation.scrollListeners.delete(scroller);
+		}
+		for (const scroller of scrolledBy) {
+			if (observation.scrollListeners.has(scroller)) continue;
+			const event = SCROLL_EVENTS.get(scroller.tagName);
+			observation.scrollListeners.set(scroller, scroller.addEventListener(event, () => {
+				sampleWhileScrolling(observation.sample);
+			}));
+		}
+	}
+	#queue(entry) {
 		this.#records.push(entry);
 		this.#deliverSoon();
 	}