@askrjs/askr 0.0.52 → 0.0.54

package/dist/renderer/keyed.js

@@ -1,167 +0,0 @@
-import { buildKeyMapFromChildren, getMaterializedKey, hasPropChanged, isIgnoredForPropChanges } from "./utils.js";
-import { extractKeyedVnodes } from "./keyed-children.js";
-//#region src/renderer/keyed.ts
-const keyedElements = /* @__PURE__ */ new WeakMap();
-/**
-* Retrieve existing keyed map for a parent element (runtime use)
-*/
-function getKeyMapForElement(el) {
-	return keyedElements.get(el);
-}
-/**
-* Populate a keyed map for an element by scanning its immediate children
-* for `data-key` attributes. Proactive initialization for runtime layers.
-*/
-function populateKeyMapForElement(parent) {
-	try {
-		if (keyedElements.has(parent)) return;
-		let domMap = buildKeyMapFromChildren(parent);
-		if (domMap.size === 0) {
-			domMap = /* @__PURE__ */ new Map();
-			const children = Array.from(parent.children);
-			for (const ch of children) {
-				const text = (ch.textContent || "").trim();
-				if (text) {
-					domMap.set(text, ch);
-					const n = Number(text);
-					if (!Number.isNaN(n)) domMap.set(n, ch);
-				}
-			}
-		}
-		if (domMap.size > 0) keyedElements.set(parent, domMap);
-	} catch {}
-}
-const _reconcilerRecordedParents = /* @__PURE__ */ new WeakSet();
-const LIS_THRESHOLD_MIN = 64;
-/**
-* Compute LIS (Longest Increasing Subsequence) length for positions
-*/
-function computeLISLength(positions) {
-	const tails = [];
-	for (const pos of positions) {
-		if (pos === -1) continue;
-		let lo = 0;
-		let hi = tails.length;
-		while (lo < hi) {
-			const mid = lo + hi >> 1;
-			if (tails[mid] < pos) lo = mid + 1;
-			else hi = mid;
-		}
-		if (lo === tails.length) tails.push(pos);
-		else tails[lo] = pos;
-	}
-	return tails.length;
-}
-function keyToken(key) {
-	return `${typeof key}:${String(key)}`;
-}
-function collectCurrentKeyOrder(parent, oldKeyMap) {
-	const currentKeys = [];
-	if (oldKeyMap && oldKeyMap.size > 0) {
-		let lastElement = null;
-		let keyCount = 0;
-		for (const [key, el] of oldKeyMap) {
-			if (el === lastElement) continue;
-			lastElement = el;
-			currentKeys.push(keyToken(key));
-			keyCount++;
-		}
-		if (keyCount > 0) return {
-			keyCount,
-			currentKeys
-		};
-	}
-	let keyCount = 0;
-	try {
-		for (let el = parent.firstElementChild; el; el = el.nextElementSibling) {
-			const key = getMaterializedKey(el);
-			if (key === void 0) continue;
-			currentKeys.push(keyToken(key));
-			keyCount++;
-		}
-	} catch {}
-	return {
-		keyCount,
-		currentKeys
-	};
-}
-function checkVnodePropChanges(keyedVnodes, oldKeyMap) {
-	for (const { key, vnode } of keyedVnodes) {
-		const el = oldKeyMap?.get(key);
-		if (!el || typeof vnode !== "object" || vnode === null) continue;
-		const props = vnode.props || {};
-		for (const k of Object.keys(props)) {
-			if (isIgnoredForPropChanges(k)) continue;
-			if (hasPropChanged(el, k, props[k])) return true;
-		}
-	}
-	return false;
-}
-/**
-* Plan keyed reorder eligibility from one snapshot of keyed order and props.
-*/
-function planKeyedReorderFastPath(parent, keyedVnodes, totalChildren, oldKeyMap) {
-	const totalKeyed = keyedVnodes.length;
-	const isWholeKeyedList = totalKeyed === totalChildren;
-	const shouldEvaluateShape = isWholeKeyedList && totalKeyed >= LIS_THRESHOLD_MIN;
-	if (!shouldEvaluateShape) return {
-		useFastPath: false,
-		totalKeyed,
-		totalChildren,
-		currentKeyCount: 0,
-		moveCount: 0,
-		lisLen: 0,
-		hasPropChanges: false,
-		isWholeKeyedList
-	};
-	const hasPropChanges = checkVnodePropChanges(keyedVnodes, oldKeyMap);
-	if (hasPropChanges) return {
-		useFastPath: false,
-		totalKeyed,
-		totalChildren,
-		currentKeyCount: 0,
-		moveCount: 0,
-		lisLen: 0,
-		hasPropChanges,
-		isWholeKeyedList
-	};
-	const { keyCount: currentKeyCount, currentKeys } = collectCurrentKeyOrder(parent, oldKeyMap);
-	let moveCount = 0;
-	for (let i = 0; i < totalKeyed; i++) if (currentKeys[i] !== keyToken(keyedVnodes[i].key)) moveCount++;
-	const cheapMoveTrigger = shouldEvaluateShape && currentKeyCount > 0 && moveCount > Math.max(64, Math.floor(totalKeyed * .1));
-	let lisTrigger = false;
-	let lisLen = 0;
-	if (shouldEvaluateShape && !cheapMoveTrigger) {
-		const indexByKey = /* @__PURE__ */ new Map();
-		for (let i = 0; i < currentKeys.length; i++) indexByKey.set(currentKeys[i], i);
-		const positions = Array(totalKeyed).fill(-1);
-		for (let i = 0; i < totalKeyed; i++) positions[i] = indexByKey.get(keyToken(keyedVnodes[i].key)) ?? -1;
-		lisLen = computeLISLength(positions);
-		lisTrigger = lisLen < Math.floor(totalKeyed * .5);
-	}
-	if (!shouldEvaluateShape || !(cheapMoveTrigger || lisTrigger)) return {
-		useFastPath: false,
-		totalKeyed,
-		totalChildren,
-		currentKeyCount,
-		moveCount,
-		lisLen,
-		hasPropChanges: false,
-		isWholeKeyedList
-	};
-	return {
-		useFastPath: true,
-		totalKeyed,
-		totalChildren,
-		currentKeyCount,
-		moveCount,
-		lisLen,
-		hasPropChanges: false,
-		isWholeKeyedList
-	};
-}
-function isKeyedReorderFastPathEligible(parent, newChildren, oldKeyMap) {
-	return planKeyedReorderFastPath(parent, extractKeyedVnodes(newChildren), newChildren.length, oldKeyMap);
-}
-//#endregion
-export { _reconcilerRecordedParents, getKeyMapForElement, isKeyedReorderFastPathEligible, keyedElements, planKeyedReorderFastPath, populateKeyMapForElement };

package/dist/renderer/namespaces.js

@@ -1,21 +0,0 @@
-import { tagNamesEqualIgnoreCase } from "./utils.js";
-//#region src/renderer/namespaces.ts
-const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
-function getParentNamespace(parent) {
-	return parent.namespaceURI === "http://www.w3.org/2000/svg" ? SVG_NAMESPACE : void 0;
-}
-function resolveChildNamespace(type, parentNamespace) {
-	if (type === "svg") return SVG_NAMESPACE;
-	if (parentNamespace === "http://www.w3.org/2000/svg" && type !== "foreignObject") return SVG_NAMESPACE;
-}
-function createElementForNamespace(type, parentNamespace, ownerDocument = document) {
-	const namespace = resolveChildNamespace(type, parentNamespace);
-	return namespace ? ownerDocument.createElementNS(namespace, type) : ownerDocument.createElement(type);
-}
-function canReuseIntrinsicElementInNamespace(existing, type, parentNamespace) {
-	if (!tagNamesEqualIgnoreCase(existing.tagName, type)) return false;
-	const expectedNamespace = resolveChildNamespace(type, parentNamespace);
-	return expectedNamespace === void 0 ? true : existing.namespaceURI === expectedNamespace;
-}
-//#endregion
-export { SVG_NAMESPACE, canReuseIntrinsicElementInNamespace, createElementForNamespace, getParentNamespace, resolveChildNamespace };

package/dist/renderer/prop-bindings.js

@@ -1,315 +0,0 @@
-import { getRuntimeEnv } from "../common/env.js";
-import { logger } from "../common/logger.js";
-import { incrementPerfMetric } from "../runtime/perf-metrics.js";
-import { incDevCounter } from "../runtime/dev-namespace.js";
-import { createFineGrainedEffect, markFineGrainedEffectsDirtySource } from "../runtime/effect.js";
-import { addDelegatedListener, addFreshDelegatedListener, getDelegatedHandlerForElement, getDelegatedHandlersForElement, isDelegatedEvent, isEventDelegationEnabled, removeDelegatedListener, updateDelegatedListener } from "../runtime/events.js";
-import "../runtime/for-bench.js";
-import "../runtime/index.js";
-import { REACTIVE_CHILDREN_KEY, elementListeners, elementReactivePropsCleanup, elementRefs, getElementReactivePropCleanupSize, getElementReactivePropsCleanupMap, updateElementRef } from "./cleanup.js";
-import "./env.js";
-import { createMutableWrappedHandler, getEventListenerKey, getEventListenerOptions, isSkippedProp, parseEventProp } from "./utils.js";
-import { applyScalarPropValue, removeStaleAttributes } from "./attributes.js";
-import { stageHydrationListener } from "./hydration-listener-transaction.js";
-const reactivePropRegistry = /* @__PURE__ */ new Set();
-function addTrackedListener(el, eventName, handler, capture = false, fresh = false) {
-	const useDelegation = !capture && isEventDelegationEnabled() && isDelegatedEvent(eventName);
-	const listenerKey = getEventListenerKey(eventName, capture);
-	if (stageHydrationListener({
-		kind: useDelegation ? "delegated" : "direct",
-		eventName,
-		publish: () => addTrackedListener(el, eventName, handler, capture, fresh),
-		rollback: () => removeTrackedListener(el, eventName, capture)
-	})) return;
-	if (useDelegation) {
-		if (fresh) addFreshDelegatedListener(el, eventName, handler, handler, void 0);
-		else addDelegatedListener(el, eventName, handler, handler, void 0);
-		return;
-	}
-	const options = getEventListenerOptions(eventName, capture);
-	const mutableHandler = createMutableWrappedHandler(handler, true);
-	const trackedHandler = mutableHandler.handler;
-	if (options !== void 0) el.addEventListener(eventName, trackedHandler, options);
-	else el.addEventListener(eventName, trackedHandler);
-	incDevCounter("listenerAdds");
-	if (!elementListeners.has(el)) elementListeners.set(el, /* @__PURE__ */ new Map());
-	elementListeners.get(el).set(listenerKey, {
-		handler: trackedHandler,
-		original: handler,
-		eventName,
-		options,
-		isDelegated: false,
-		updateHandler: mutableHandler?.updateHandler
-	});
-}
-function removeTrackedListener(el, eventName, capture) {
-	if (!capture && getDelegatedHandlerForElement(el, eventName)) {
-		removeDelegatedListener(el, eventName);
-		return;
-	}
-	const listenerKey = getEventListenerKey(eventName, capture);
-	const entry = elementListeners.get(el)?.get(listenerKey);
-	if (!entry) return;
-	if (entry.options !== void 0) el.removeEventListener(entry.eventName, entry.handler, entry.options);
-	else el.removeEventListener(entry.eventName, entry.handler);
-	incDevCounter("listenerRemoves");
-	const listeners = elementListeners.get(el);
-	listeners?.delete(listenerKey);
-	if (listeners?.size === 0) elementListeners.delete(el);
-}
-function markReactivePropsDirtySource(source) {
-	markFineGrainedEffectsDirtySource(source);
-}
-function setupReactiveProp(el, propName, propFn, tagName) {
-	const descriptor = {
-		el,
-		propName,
-		propFn,
-		tagName,
-		lastClassTokens: null
-	};
-	let effectHandle = null;
-	reactivePropRegistry.add(descriptor);
-	effectHandle = createFineGrainedEffect({
-		lane: "reactive",
-		compute: () => descriptor.propFn(),
-		commit: (value, previousValue) => {
-			incrementPerfMetric("reactivePropReevaluations");
-			applyScalarPropValue(el, propName, value, tagName, previousValue, descriptor);
-		},
-		equals: (previousValue, nextValue) => {
-			if (Object.is(previousValue, nextValue)) {
-				incrementPerfMetric("skippedDomPropWrites");
-				return true;
-			}
-			return false;
-		},
-		onError: (err) => {
-			if (getRuntimeEnv().NODE_ENV !== "production") logger.warn("[Askr] Reactive prop update failed:", err);
-		}
-	});
-	const cleanup = () => {
-		reactivePropRegistry.delete(descriptor);
-		effectHandle?.cleanup();
-		effectHandle = null;
-	};
-	const updateFn = (nextFn) => {
-		if (!effectHandle) return;
-		descriptor.propFn = nextFn;
-		try {
-			effectHandle.updateCompute(nextFn);
-		} catch (err) {
-			if (getRuntimeEnv().NODE_ENV !== "production") logger.warn("[Askr] Reactive prop update failed:", err);
-		}
-	};
-	return {
-		cleanup,
-		updateFn
-	};
-}
-function getOrCreateReactivePropsCleanupMap(el) {
-	return getElementReactivePropsCleanupMap(el, true);
-}
-/** @internal Create a standalone reactive prop entry for rollback restoration. */
-function createReactivePropCleanupEntry(el, propName, propFn, tagName) {
-	const reactive = setupReactiveProp(el, propName, propFn, tagName);
-	return {
-		cleanup: reactive.cleanup,
-		updateFn: (nextValue) => {
-			reactive.updateFn(nextValue);
-		},
-		restoreFn: (nextValue) => createReactivePropCleanupEntry(el, propName, nextValue, tagName),
-		fnRef: propFn
-	};
-}
-function hasTrackedElementPropBindings(el) {
-	const existingListeners = elementListeners.get(el);
-	return existingListeners !== void 0 && existingListeners.size > 0 || getElementReactivePropCleanupSize(el) > 0;
-}
-function hasAnyElementBindingState(el) {
-	return hasTrackedElementPropBindings(el) || getDelegatedHandlersForElement(el) !== void 0 || elementRefs.has(el);
-}
-function applyMatchingElementBindings(el, props) {
-	if (Object.prototype.hasOwnProperty.call(props, "ref")) updateElementRef(el, props.ref);
-	for (const key in props) {
-		const eventProp = parseEventProp(key);
-		if (!eventProp) continue;
-		const value = props[key];
-		if (typeof value === "function") addTrackedListener(el, eventProp.eventName, value, eventProp.capture);
-	}
-}
-/** @internal Attach stateful bindings to a newly cloned blueprint element. */
-function applyFreshElementBindings(el, props) {
-	if (Object.prototype.hasOwnProperty.call(props, "ref")) updateElementRef(el, props.ref);
-	for (const key in props) {
-		const eventProp = parseEventProp(key);
-		if (eventProp) {
-			const value = props[key];
-			if (typeof value === "function") addTrackedListener(el, eventProp.eventName, value, eventProp.capture, true);
-		}
-	}
-}
-function applyPropsToElement(el, props, tagName, isHydrationSkipped) {
-	if (isHydrationSkipped(el)) return;
-	for (const key in props) {
-		const value = props[key];
-		if (key === "ref") {
-			updateElementRef(el, value);
-			continue;
-		}
-		if (isSkippedProp(key)) continue;
-		if (value === void 0 || value === null || value === false) continue;
-		const eventProp = parseEventProp(key);
-		if (eventProp) {
-			addTrackedListener(el, eventProp.eventName, value, eventProp.capture);
-			continue;
-		}
-		if (typeof value === "function" && key !== "ref") {
-			getOrCreateReactivePropsCleanupMap(el).set(key, createReactivePropCleanupEntry(el, key, value, tagName));
-			continue;
-		}
-		applyScalarPropValue(el, key, value, tagName);
-	}
-}
-function syncElementPropBindings(el, domVNode, props, usesReactiveChildren) {
-	const existingListeners = elementListeners.get(el);
-	const existingReactiveProps = getElementReactivePropsCleanupMap(el);
-	let desiredListenerKeys = null;
-	let desiredDelegatedEventNames = null;
-	let desiredReactivePropNames = null;
-	if (usesReactiveChildren) (desiredReactivePropNames ??= /* @__PURE__ */ new Set()).add(REACTIVE_CHILDREN_KEY);
-	for (const key in props) {
-		const value = props[key];
-		if (key === "ref") continue;
-		if (isSkippedProp(key)) continue;
-		const eventProp = parseEventProp(key);
-		const eventName = eventProp?.eventName;
-		const eventCapture = eventProp?.capture ?? false;
-		const listenerKey = eventName === void 0 ? null : getEventListenerKey(eventName, eventCapture);
-		if (value === void 0 || value === null || value === false) {
-			if (listenerKey && existingListeners?.has(listenerKey)) {
-				const entry = existingListeners.get(listenerKey);
-				incDevCounter("listenerRemoves");
-				if (entry.isDelegated) removeDelegatedListener(el, entry.eventName);
-				else if (entry.options !== void 0) el.removeEventListener(entry.eventName, entry.handler, entry.options);
-				else el.removeEventListener(entry.eventName, entry.handler);
-				existingListeners.delete(listenerKey);
-			} else {
-				const entry = existingReactiveProps?.get(key);
-				if (entry) {
-					entry.cleanup();
-					existingReactiveProps?.delete(key);
-				} else applyScalarPropValue(el, key, value, domVNode.type);
-			}
-			continue;
-		}
-		if (typeof value === "function" && !eventProp && key !== "ref") {
-			const existingEntry = existingReactiveProps?.get(key);
-			if (existingReactiveProps && existingReactiveProps.size > 0) (desiredReactivePropNames ??= /* @__PURE__ */ new Set()).add(key);
-			if (existingEntry && existingEntry.fnRef === value) continue;
-			if (existingEntry?.updateFn) {
-				existingEntry.updateFn(value);
-				existingEntry.fnRef = value;
-				continue;
-			}
-			if (existingEntry) existingEntry.cleanup();
-			getOrCreateReactivePropsCleanupMap(el).set(key, createReactivePropCleanupEntry(el, key, value, domVNode.type));
-			continue;
-		}
-		const existingReactiveEntry = existingReactiveProps?.get(key);
-		if (existingReactiveEntry) {
-			existingReactiveEntry.cleanup();
-			existingReactiveProps?.delete(key);
-		}
-		if (eventProp && listenerKey) {
-			const eventName = eventProp.eventName;
-			const eventCapture = eventProp.capture;
-			const useDelegation = !eventCapture && isEventDelegationEnabled() && isDelegatedEvent(eventName);
-			if (useDelegation) (desiredDelegatedEventNames ??= /* @__PURE__ */ new Set()).add(eventName);
-			if (useDelegation) {
-				const existingDelegated = getDelegatedHandlerForElement(el, eventName);
-				if (existingDelegated?.original === value) continue;
-				if (existingDelegated && updateDelegatedListener(el, eventName, value, value, void 0)) continue;
-				addDelegatedListener(el, eventName, value, value, void 0);
-				continue;
-			}
-			(desiredListenerKeys ??= /* @__PURE__ */ new Set()).add(listenerKey);
-			const existing = existingListeners?.get(listenerKey);
-			if (existing && existing.original === value) continue;
-			if (existing) {
-				if (useDelegation && existing.isDelegated && updateDelegatedListener(el, eventName, value, value, void 0)) {
-					existing.handler = value;
-					existing.original = value;
-					existing.options = void 0;
-					continue;
-				}
-				if (!useDelegation && !existing.isDelegated && existing.updateHandler) {
-					existing.updateHandler(value);
-					existing.original = value;
-					continue;
-				}
-				if (existing.isDelegated) removeDelegatedListener(el, existing.eventName);
-				else if (existing.options !== void 0) el.removeEventListener(existing.eventName, existing.handler, existing.options);
-				else el.removeEventListener(existing.eventName, existing.handler);
-			}
-			const options = getEventListenerOptions(eventName, eventCapture);
-			const mutableHandler = createMutableWrappedHandler(value, true);
-			const trackedHandler = mutableHandler.handler;
-			if (options !== void 0) el.addEventListener(eventName, trackedHandler, options);
-			else el.addEventListener(eventName, trackedHandler);
-			incDevCounter("listenerAdds");
-			const listenerEntry = {
-				handler: trackedHandler,
-				original: value,
-				eventName,
-				options,
-				isDelegated: false,
-				updateHandler: mutableHandler?.updateHandler
-			};
-			if (!elementListeners.has(el)) elementListeners.set(el, /* @__PURE__ */ new Map());
-			elementListeners.get(el).set(listenerKey, listenerEntry);
-		} else applyScalarPropValue(el, key, value, domVNode.type);
-	}
-	removeStaleAttributes(el, domVNode, props);
-	if (existingListeners && existingListeners.size > 0) if (desiredListenerKeys === null) {
-		existingListeners.forEach((entry) => {
-			incDevCounter("listenerRemoves");
-			if (entry.isDelegated) removeDelegatedListener(el, entry.eventName);
-			else if (entry.options !== void 0) el.removeEventListener(entry.eventName, entry.handler, entry.options);
-			else el.removeEventListener(entry.eventName, entry.handler);
-		});
-		elementListeners.delete(el);
-	} else {
-		existingListeners.forEach((entry, listenerKey) => {
-			if (!desiredListenerKeys.has(listenerKey)) {
-				incDevCounter("listenerRemoves");
-				if (entry.isDelegated) removeDelegatedListener(el, entry.eventName);
-				else if (entry.options !== void 0) el.removeEventListener(entry.eventName, entry.handler, entry.options);
-				else el.removeEventListener(entry.eventName, entry.handler);
-				existingListeners.delete(listenerKey);
-			}
-		});
-		if (existingListeners.size === 0) elementListeners.delete(el);
-	}
-	const delegatedHandlers = getDelegatedHandlersForElement(el);
-	if (delegatedHandlers && delegatedHandlers.size > 0) {
-		if (desiredDelegatedEventNames === null) for (const eventName of delegatedHandlers.keys()) removeDelegatedListener(el, eventName);
-		else for (const eventName of delegatedHandlers.keys()) if (!desiredDelegatedEventNames.has(eventName)) removeDelegatedListener(el, eventName);
-	}
-	if (existingReactiveProps && existingReactiveProps.size > 0) if (desiredReactivePropNames === null) {
-		existingReactiveProps.forEach((entry) => {
-			entry.cleanup();
-		});
-		elementReactivePropsCleanup.delete(el);
-	} else {
-		existingReactiveProps.forEach((entry, key) => {
-			if (!desiredReactivePropNames.has(key)) {
-				entry.cleanup();
-				existingReactiveProps.delete(key);
-			}
-		});
-		if (existingReactiveProps.size === 0) elementReactivePropsCleanup.delete(el);
-	}
-}
-//#endregion
-export { applyFreshElementBindings, applyMatchingElementBindings, applyPropsToElement, createReactivePropCleanupEntry, hasAnyElementBindingState, hasTrackedElementPropBindings, markReactivePropsDirtySource, syncElementPropBindings };

package/dist/renderer/reactive-child-dom.js

@@ -1,139 +0,0 @@
-import { teardownNodeSubtree } from "./cleanup.js";
-import { getRangeNodes } from "./dom-range.js";
-import { createElementForNamespace, getParentNamespace } from "./namespaces.js";
-import { collectReactiveChildBoundaryVNodes, isSingleRootReactiveChildBoundaryValue } from "./reactive-child-sources.js";
-import { syncControlBoundaryScopeDom } from "./boundary-range-sync.js";
-import "./boundaries.js";
-//#region src/renderer/reactive-child-dom.ts
-function materializeReactiveChildBoundaryNodes(value, parentNamespace, host) {
-	const nodes = [];
-	const dom = host.createDOMNode(value, parentNamespace);
-	if (!dom) return nodes;
-	if (dom instanceof DocumentFragment) {
-		for (let child = dom.firstChild; child; child = dom.firstChild) {
-			nodes.push(child);
-			dom.removeChild(child);
-		}
-		return nodes;
-	}
-	nodes.push(dom);
-	return nodes;
-}
-function createReactiveChildBoundaryHost(el) {
-	const ownerDocument = el.ownerDocument;
-	const parentNamespace = getParentNamespace(el);
-	return parentNamespace === "http://www.w3.org/2000/svg" ? createElementForNamespace("g", parentNamespace, ownerDocument) : createElementForNamespace("div", parentNamespace, ownerDocument);
-}
-function disposeReactiveChildBoundaryNodes(nodes) {
-	for (const node of nodes) {
-		if (node.parentNode) node.parentNode.removeChild(node);
-		teardownNodeSubtree(node);
-	}
-}
-function syncReactiveChildExpectedNodes(el, expectedNodes) {
-	const expectedNodeSet = new Set(expectedNodes);
-	for (let node = el.firstChild; node;) {
-		const next = node.nextSibling;
-		if (!expectedNodeSet.has(node)) {
-			teardownNodeSubtree(node);
-			el.removeChild(node);
-		}
-		node = next;
-	}
-	let anchor = el.firstChild;
-	for (const node of expectedNodes) {
-		if (node === anchor) {
-			anchor = anchor.nextSibling;
-			continue;
-		}
-		el.insertBefore(node, anchor);
-		anchor = node.nextSibling;
-	}
-}
-function commitReactiveChildBoundaryEntryNodes(el, entry, host) {
-	if (!entry.scope.needsDomUpdate) return entry.nodes;
-	if (entry.scope.vnode === null || entry.scope.vnode === void 0 || entry.scope.vnode === false) {
-		if (entry.nodes.length > 0) {
-			disposeReactiveChildBoundaryNodes(entry.nodes);
-			entry.nodes = [];
-		}
-		const dom = entry.scope.dom;
-		if (dom?.parentNode === el) {
-			teardownNodeSubtree(dom);
-			el.removeChild(dom);
-		}
-		entry.scope.dom = void 0;
-		entry.scope.needsDomUpdate = false;
-		return entry.nodes;
-	}
-	if (!isSingleRootReactiveChildBoundaryValue(entry.scope.vnode)) {
-		const nextChildren = [];
-		collectReactiveChildBoundaryVNodes(entry.scope.vnode, nextChildren);
-		const boundaryHost = createReactiveChildBoundaryHost(el);
-		for (const node of entry.nodes) boundaryHost.appendChild(node);
-		host.updateElementChildren(boundaryHost, nextChildren);
-		const nextNodes = Array.from(boundaryHost.childNodes);
-		entry.scope.dom = void 0;
-		entry.scope.range = void 0;
-		entry.scope.needsDomUpdate = false;
-		entry.nodes = nextNodes;
-		return nextNodes;
-	}
-	if (entry.nodes.length > 1) {
-		disposeReactiveChildBoundaryNodes(entry.nodes);
-		entry.nodes = [];
-		entry.scope.dom = void 0;
-		entry.scope.range = void 0;
-	}
-	const nextDom = syncControlBoundaryScopeDom(el, entry.scope, entry.scope.vnode ?? null);
-	if (!nextDom) {
-		entry.nodes = [];
-		entry.scope.needsDomUpdate = false;
-		return entry.nodes;
-	}
-	entry.nodes = nextDom.single ? [nextDom.start] : [
-		nextDom.start,
-		...getRangeNodes(nextDom),
-		nextDom.end
-	];
-	entry.scope.needsDomUpdate = false;
-	return entry.nodes;
-}
-function syncReactiveChildSequenceNodes(el, entries, host) {
-	const expectedNodes = [];
-	for (const entry of entries) {
-		if (entry.kind === "static") {
-			expectedNodes.push(...entry.nodes);
-			continue;
-		}
-		expectedNodes.push(...commitReactiveChildBoundaryEntryNodes(el, entry, host));
-	}
-	syncReactiveChildExpectedNodes(el, expectedNodes);
-}
-function syncReactiveScalarTextNodes(el, slotValues, values, host) {
-	const childNodes = el.childNodes;
-	if (childNodes.length === values.length) {
-		let allText = true;
-		for (let index = 0; index < childNodes.length; index += 1) if (childNodes[index]?.nodeType !== Node.TEXT_NODE) {
-			allText = false;
-			break;
-		}
-		if (allText) {
-			for (let index = 0; index < values.length; index += 1) {
-				const textNode = childNodes[index];
-				if (textNode.data !== values[index]) textNode.data = values[index];
-			}
-			return;
-		}
-	}
-	const boundaryHost = createReactiveChildBoundaryHost(el);
-	for (let node = el.firstChild; node;) {
-		const next = node.nextSibling;
-		boundaryHost.appendChild(node);
-		node = next;
-	}
-	host.updateElementChildren(boundaryHost, slotValues);
-	syncReactiveChildExpectedNodes(el, Array.from(boundaryHost.childNodes));
-}
-//#endregion
-export { commitReactiveChildBoundaryEntryNodes, createReactiveChildBoundaryHost, disposeReactiveChildBoundaryNodes, materializeReactiveChildBoundaryNodes, syncReactiveChildExpectedNodes, syncReactiveChildSequenceNodes, syncReactiveScalarTextNodes };