@askrjs/askr 0.0.52 → 0.0.54

package/dist/renderer/for-commit-reorder.js

@@ -1,87 +0,0 @@
-import { recordBenchCounter, recordBenchEvent } from "../runtime/for-bench.js";
-import "../runtime/index.js";
-import { canUseDirectReplaceChildrenSpread } from "./utils.js";
-//#region src/renderer/for-commit-reorder.ts
-const DENSE_MOVE_MINIMUM = 64;
-const DENSE_MOVE_RATIO = .75;
-function replaceChildrenInOrder(parent, nodes, allowDirectSpread) {
-	if (allowDirectSpread && canUseDirectReplaceChildrenSpread(nodes.length)) {
-		parent.replaceChildren(...nodes);
-		return;
-	}
-	const fragment = parent.ownerDocument.createDocumentFragment();
-	for (let i = 0; i < nodes.length; i++) fragment.appendChild(nodes[i]);
-	parent.replaceChildren(fragment);
-}
-function getLISIndices(sequence) {
-	if (sequence.length === 0) return [];
-	const predecessors = sequence.slice();
-	const lisIndices = [0];
-	for (let i = 1; i < sequence.length; i += 1) {
-		const current = sequence[i];
-		const lastLisIndex = lisIndices[lisIndices.length - 1];
-		if (sequence[lastLisIndex] < current) {
-			predecessors[i] = lastLisIndex;
-			lisIndices.push(i);
-			continue;
-		}
-		let lo = 0;
-		let hi = lisIndices.length - 1;
-		while (lo < hi) {
-			const mid = lo + hi >> 1;
-			if (sequence[lisIndices[mid]] < current) lo = mid + 1;
-			else hi = mid;
-		}
-		if (current < sequence[lisIndices[lo]]) {
-			if (lo > 0) predecessors[i] = lisIndices[lo - 1];
-			lisIndices[lo] = i;
-		}
-	}
-	let cursor = lisIndices.length - 1;
-	let index = lisIndices[cursor];
-	while (cursor >= 0) {
-		lisIndices[cursor] = index;
-		index = predecessors[index];
-		cursor -= 1;
-	}
-	return lisIndices;
-}
-function commitMoveOnlyReorder(parent, nodes) {
-	const currentNodes = Array.from(parent.childNodes);
-	if (currentNodes.length !== nodes.length) return false;
-	const currentIndexByNode = /* @__PURE__ */ new Map();
-	for (let i = 0; i < currentNodes.length; i += 1) currentIndexByNode.set(currentNodes[i], i);
-	const positions = Array.from({ length: nodes.length }, () => 0);
-	for (let i = 0; i < nodes.length; i += 1) {
-		const position = currentIndexByNode.get(nodes[i]);
-		if (position === void 0) return false;
-		positions[i] = position;
-	}
-	const lisIndices = getLISIndices(positions);
-	if (lisIndices.length === nodes.length) return true;
-	const moveCount = nodes.length - lisIndices.length;
-	if (moveCount >= Math.max(DENSE_MOVE_MINIMUM, Math.floor(nodes.length * DENSE_MOVE_RATIO))) {
-		recordBenchEvent("domMove", moveCount);
-		recordBenchCounter("replaceChildrenCommits");
-		replaceChildrenInOrder(parent, nodes, false);
-		return true;
-	}
-	let lisCursor = lisIndices.length - 1;
-	let anchor = null;
-	for (let i = nodes.length - 1; i >= 0; i -= 1) {
-		const node = nodes[i];
-		if (lisCursor >= 0 && i === lisIndices[lisCursor]) {
-			anchor = node;
-			lisCursor -= 1;
-			continue;
-		}
-		if (node.nextSibling !== anchor) {
-			recordBenchEvent("domMove");
-			parent.insertBefore(node, anchor);
-		}
-		anchor = node;
-	}
-	return true;
-}
-//#endregion
-export { commitMoveOnlyReorder, replaceChildrenInOrder };

package/dist/renderer/for-commit.js

@@ -1,442 +0,0 @@
-import { beginLifecycleCommitBatch, discardLifecycleCommitBatch, flushLifecycleCommitBatch } from "../runtime/lifecycle-batch.js";
-import { recordBenchEvent } from "../runtime/for-bench.js";
-import { captureForFallbackTransactionSnapshot, captureForItemTransactionSnapshot } from "../runtime/for-scopes.js";
-import { beginForStateTransaction, clearForDomUpdateState, registerForStateTransaction, rollbackForStateTransaction } from "../runtime/for-internal.js";
-import "../runtime/index.js";
-import { teardownNodeSubtree } from "./cleanup.js";
-import { canUseDirectReplaceChildrenSpread } from "./utils.js";
-import { keyedElements } from "./keyed.js";
-import { getOrBuildDomKeyMap, hydrateExistingForDomInOrder, syncKeyedMapFromForState } from "./for-commit-dom-map.js";
-import { commitMoveOnlyReorder, replaceChildrenInOrder } from "./for-commit-reorder.js";
-import { removeForBoundaryNodes } from "./for-commit-removal.js";
-import { getRangeNodes, moveRange } from "./dom-range.js";
-import { isFragment } from "./evaluate-reconcile.js";
-function isExactRemovedBoundary(parent, removedNodes) {
-	if (removedNodes.length === 0 || removedNodes.length !== parent.childNodes.length) return false;
-	for (let index = 0; index < removedNodes.length; index++) if (removedNodes[index] !== parent.childNodes[index]) return false;
-	return true;
-}
-function isMultiNodeVNode(vnode) {
-	if (vnode === null || vnode === void 0 || vnode === false) return true;
-	return Array.isArray(vnode) || typeof vnode === "object" && vnode !== null && isFragment(vnode);
-}
-function getScopeRange(scope, node) {
-	if (scope.range) return scope.range;
-	if (!node) return null;
-	return {
-		start: node,
-		end: node,
-		single: true
-	};
-}
-function detachRange(range) {
-	const parent = range.start.parentNode;
-	if (!parent) return;
-	const fragment = parent.ownerDocument?.createDocumentFragment();
-	if (fragment) moveRange(fragment, range);
-}
-function detachRemovedForNodes(parent, forState) {
-	for (const range of forState.lastRemovedRanges) detachRange(range);
-	for (const node of forState.lastRemovedNodes) if (node.parentNode === parent) node.parentNode.removeChild(node);
-}
-function commitForStateBoundaryRanges(parent, forState, childrenVNodes, runtime) {
-	const desiredRanges = [];
-	if (forState.orderedKeys.length === 0) {
-		const fallbackScope = forState.fallbackScope;
-		const fallbackVNode = childrenVNodes[0];
-		if (fallbackScope && fallbackVNode !== void 0) {
-			const range = getScopeRange(fallbackScope, !fallbackScope.needsDomUpdate ? null : runtime.syncForItemDom(parent, fallbackScope, fallbackVNode));
-			if (range) desiredRanges.push(range);
-		}
-	} else for (let index = 0; index < forState.orderedItems.length; index += 1) {
-		const item = forState.orderedItems[index];
-		if (!item) continue;
-		captureItemBeforeRangeCommit(forState, item);
-		const node = !item.scope.needsDomUpdate ? null : runtime.syncForItemDom(parent, item.scope, childrenVNodes[index]);
-		const range = getScopeRange(item.scope, node);
-		if (range) desiredRanges.push(range);
-	}
-	const desiredNodes = /* @__PURE__ */ new Set();
-	for (const range of desiredRanges) {
-		desiredNodes.add(range.start);
-		for (const node of getRangeNodes(range)) desiredNodes.add(node);
-		if (!range.single) desiredNodes.add(range.end);
-	}
-	detachRemovedForNodes(parent, forState);
-	let anchor = null;
-	for (let index = desiredRanges.length - 1; index >= 0; index -= 1) {
-		const range = desiredRanges[index];
-		moveRange(parent, range, anchor);
-		anchor = range.start;
-	}
-	for (const node of Array.from(parent.childNodes)) {
-		if (desiredNodes.has(node)) continue;
-		node.parentNode?.removeChild(node);
-	}
-	forState._hasResolvedItemDom = true;
-	clearForDomUpdateState(forState);
-}
-function captureItemBeforeRangeCommit(forState, item) {
-	if (item.scope.needsDomUpdate || item.scope.hydrationPending) captureForItemTransactionSnapshot(forState, item);
-}
-function commitForStateBoundaryChildren(parent, forState, childrenVNodes, runtime) {
-	const previousChildren = Array.from(parent.childNodes);
-	const currentKeyedMap = keyedElements.get(parent);
-	const previousKeyedMap = currentKeyedMap ? new Map(currentKeyedMap) : void 0;
-	const lifecycleBatch = beginLifecycleCommitBatch();
-	beginForStateTransaction(forState, "reuse");
-	registerForStateTransaction(forState);
-	try {
-		commitForStateBoundaryChildrenImpl(parent, forState, childrenVNodes, runtime);
-		flushLifecycleCommitBatch(lifecycleBatch);
-	} catch (error) {
-		discardLifecycleCommitBatch(lifecycleBatch);
-		rollbackForStateTransaction(forState);
-		const previousChildrenSet = new Set(previousChildren);
-		for (const node of Array.from(parent.childNodes)) if (!previousChildrenSet.has(node)) teardownNodeSubtree(node);
-		parent.replaceChildren(...previousChildren);
-		if (previousKeyedMap) keyedElements.set(parent, new Map(previousKeyedMap));
-		else keyedElements.delete(parent);
-		throw error;
-	}
-}
-function commitForStateBoundaryChildrenImpl(parent, forState, childrenVNodes, runtime) {
-	if (childrenVNodes.some(isMultiNodeVNode) || forState.orderedItems.some((item) => item.scope.range && !item.scope.range.single) || Boolean(forState.fallbackScope?.range && !forState.fallbackScope.range.single)) {
-		commitForStateBoundaryRanges(parent, forState, childrenVNodes, runtime);
-		return;
-	}
-	let removedBoundaryConsumed = false;
-	const captureItemBeforeCommit = (item) => {
-		if (item.scope.needsDomUpdate || item.scope.hydrationPending) captureForItemTransactionSnapshot(forState, item);
-	};
-	const syncItemDom = (item, vnode) => {
-		captureItemBeforeCommit(item);
-		return runtime.syncForItemDom(parent, item.scope, vnode);
-	};
-	const hydrateExistingForDom = () => {
-		if (parent.children.length === forState.orderedKeys.length) for (let index = 0; index < forState.orderedItems.length; index++) {
-			const item = forState.orderedItems[index];
-			if (item) captureForItemTransactionSnapshot(forState, item);
-		}
-		if (hydrateExistingForDomInOrder(parent, forState)) return;
-		const domKeyMap = getOrBuildDomKeyMap(parent);
-		if (!domKeyMap) return;
-		for (let i = 0; i < forState.orderedKeys.length; i++) {
-			const itemKey = forState.orderedKeys[i];
-			const itemInstance = forState.items.get(itemKey);
-			if (!itemInstance || itemInstance.scope.dom) continue;
-			const existingDom = domKeyMap.get(itemKey);
-			if (!existingDom) continue;
-			captureForItemTransactionSnapshot(forState, itemInstance);
-			itemInstance.scope.dom = existingDom;
-			itemInstance.scope.needsDomUpdate = true;
-		}
-	};
-	if (forState.orderedKeys.length === 0) {
-		const fallbackScope = forState.fallbackScope;
-		const fallbackVNode = childrenVNodes[0];
-		if (fallbackScope && (fallbackScope.needsDomUpdate || fallbackScope.hydrationPending)) captureForFallbackTransactionSnapshot(forState, fallbackScope);
-		const nextDom = fallbackScope && fallbackVNode !== void 0 ? runtime.syncForItemDom(parent, fallbackScope, fallbackVNode) : null;
-		if (nextDom && isExactRemovedBoundary(parent, forState.lastRemovedNodes)) {
-			recordBenchEvent("domRemove", forState.lastRemovedNodes.length);
-			parent.replaceChildren(nextDom);
-			removedBoundaryConsumed = true;
-		} else removeForBoundaryNodes(parent, forState.lastRemovedNodes, { teardown: false });
-		if (nextDom) {
-			if (parent.childNodes.length !== 1 || parent.firstChild !== nextDom || forState.lastRemovedNodes.length > 0 && !removedBoundaryConsumed) parent.replaceChildren(nextDom);
-		} else if (parent.firstChild) parent.textContent = "";
-		keyedElements.delete(parent);
-		forState._hasResolvedItemDom = false;
-		clearForDomUpdateState(forState);
-		return;
-	}
-	if (!forState._hasResolvedItemDom && parent.childNodes.length > 0) hydrateExistingForDom();
-	const getDirtyForIndices = () => {
-		const pendingDirtyIndices = forState.pendingDirtyIndices;
-		if (pendingDirtyIndices && pendingDirtyIndices.length > 0) return pendingDirtyIndices;
-		const dirtyIndices = [];
-		for (let index = 0; index < forState.orderedKeys.length; index += 1) if (forState.orderedItems[index]?.scope.needsDomUpdate) dirtyIndices.push(index);
-		return dirtyIndices;
-	};
-	let dirtyIndicesCache = null;
-	const ensureDirtyIndices = () => {
-		if (dirtyIndicesCache) return dirtyIndicesCache;
-		dirtyIndicesCache = getDirtyForIndices();
-		return dirtyIndicesCache;
-	};
-	const dirtyIndices = forState.lastCommitStrategy === "NO_REORDER" ? ensureDirtyIndices() : [];
-	let boundaryChildrenExact = false;
-	const commitDirtyNoReorder = (dirtyIndices) => {
-		if (dirtyIndices.length === 0) {
-			boundaryChildrenExact = true;
-			return;
-		}
-		const orderedItems = forState.orderedItems;
-		const childNodes = parent.childNodes;
-		for (let dirtyIndex = 0; dirtyIndex < dirtyIndices.length; dirtyIndex++) {
-			const i = dirtyIndices[dirtyIndex];
-			const itemInstance = orderedItems[i];
-			if (!itemInstance) continue;
-			captureItemBeforeCommit(itemInstance);
-			if (runtime.tryPatchStableForDirtyItem(itemInstance.scope)) continue;
-			const dom = syncItemDom(itemInstance, childrenVNodes[i]);
-			if (!dom) continue;
-			const anchor = childNodes[i] ?? null;
-			if (dom.parentNode !== parent || dom !== anchor) {
-				recordBenchEvent("domInsert");
-				parent.insertBefore(dom, anchor);
-			}
-		}
-		boundaryChildrenExact = true;
-	};
-	const commitPositional = () => {
-		for (let i = 0; i < forState.orderedKeys.length; i++) {
-			const itemInstance = forState.orderedItems[i];
-			if (!itemInstance) continue;
-			const dom = syncItemDom(itemInstance, childrenVNodes[i]);
-			if (!dom) continue;
-			if (dom.parentNode !== parent) {
-				const anchor = parent.childNodes[i] ?? null;
-				recordBenchEvent("domInsert");
-				parent.insertBefore(dom, anchor);
-			}
-		}
-		boundaryChildrenExact = true;
-	};
-	const commitAppend = () => {
-		if (!forState._hasResolvedItemDom && forState.lastRemovedNodes.length === 0 && parent.childNodes.length === forState.orderedKeys.length) {
-			let exactOrder = true;
-			let currentNode = parent.firstChild;
-			for (let i = 0; i < forState.orderedKeys.length; i++) {
-				const itemInstance = forState.orderedItems[i];
-				if (!itemInstance) {
-					exactOrder = false;
-					currentNode = currentNode?.nextSibling ?? null;
-					continue;
-				}
-				const dom = syncItemDom(itemInstance, childrenVNodes[i]);
-				if (!dom || dom.parentNode !== parent || dom !== currentNode) exactOrder = false;
-				currentNode = currentNode?.nextSibling ?? null;
-			}
-			if (exactOrder) {
-				boundaryChildrenExact = true;
-				return;
-			}
-		}
-		const appendColdRows = () => {
-			const pendingAppend = [];
-			const appendStart = forState.pendingAppendStart ?? 0;
-			const hasDetachedSuffix = forState.pendingAppendStart !== null && parent.childNodes.length === appendStart;
-			for (let i = appendStart; i < forState.orderedKeys.length; i++) {
-				const itemInstance = forState.orderedItems[i];
-				if (!itemInstance) continue;
-				if (!hasDetachedSuffix && itemInstance.scope.dom?.parentNode === parent && !itemInstance.scope.needsDomUpdate) continue;
-				const dom = syncItemDom(itemInstance, childrenVNodes[i]);
-				if (!dom) continue;
-				if (hasDetachedSuffix || dom.parentNode !== parent) pendingAppend.push(dom);
-			}
-			if (pendingAppend.length > 0) {
-				const fragment = parent.ownerDocument.createDocumentFragment();
-				if (canUseDirectReplaceChildrenSpread(pendingAppend.length)) fragment.append(...pendingAppend);
-				else for (const node of pendingAppend) fragment.appendChild(node);
-				parent.appendChild(fragment);
-			}
-		};
-		appendColdRows();
-		boundaryChildrenExact = true;
-	};
-	const commitInsertOne = () => {
-		const index = forState.pendingInsertedIndex;
-		const item = index === null ? void 0 : forState.orderedItems[index];
-		if (index === null || !item || parent.childNodes.length !== forState.orderedKeys.length - 1) {
-			commitReorder();
-			return;
-		}
-		const anchor = parent.childNodes[index] ?? null;
-		const dom = syncItemDom(item, childrenVNodes[index]);
-		if (dom && (dom.parentNode !== parent || dom !== anchor)) {
-			recordBenchEvent("domInsert");
-			parent.insertBefore(dom, anchor);
-		}
-		boundaryChildrenExact = true;
-	};
-	const commitSwap = () => {
-		const swapIndices = forState.pendingSwapIndices;
-		if (!swapIndices) return;
-		let [firstIndex, secondIndex] = swapIndices;
-		if (firstIndex === secondIndex) return;
-		if (firstIndex > secondIndex) [firstIndex, secondIndex] = [secondIndex, firstIndex];
-		const firstKey = forState.orderedKeys[firstIndex];
-		const secondKey = forState.orderedKeys[secondIndex];
-		const firstItem = forState.items.get(firstKey);
-		const secondItem = forState.items.get(secondKey);
-		if (!firstItem || !secondItem) {
-			commitReorder();
-			return;
-		}
-		const firstDom = syncItemDom(firstItem, childrenVNodes[firstIndex]);
-		const secondDom = syncItemDom(secondItem, childrenVNodes[secondIndex]);
-		if (!firstDom || !secondDom) {
-			commitReorder();
-			return;
-		}
-		if (firstDom.parentNode !== parent || secondDom.parentNode !== parent) {
-			commitReorder();
-			return;
-		}
-		if ((firstDom.compareDocumentPosition(secondDom) & Node.DOCUMENT_POSITION_FOLLOWING) !== 0) {
-			boundaryChildrenExact = true;
-			return;
-		}
-		const firstNextSibling = firstDom.nextSibling;
-		recordBenchEvent("domMove");
-		parent.insertBefore(firstDom, secondDom);
-		recordBenchEvent("domMove");
-		parent.insertBefore(secondDom, firstNextSibling);
-		boundaryChildrenExact = true;
-	};
-	const commitReorder = () => {
-		const items = forState.orderedItems;
-		const count = items.length;
-		if (forState.pendingMoveOnly && forState.lastRemovedNodes.length === 0) {
-			const nodes = Array(count);
-			let movedCount = 0;
-			let insertedCount = 0;
-			for (let i = 0; i < count; i++) {
-				const itemInstance = items[i];
-				if (!itemInstance) return;
-				const scope = itemInstance.scope;
-				const dom = scope.dom && !scope.needsDomUpdate ? scope.dom : syncItemDom(itemInstance, childrenVNodes[i]);
-				if (!dom) return;
-				if (dom.parentNode === parent) movedCount++;
-				else insertedCount++;
-				nodes[i] = dom;
-			}
-			if (!canUseDirectReplaceChildrenSpread(count)) {
-				if (movedCount > 0) recordBenchEvent("domMove", movedCount);
-				if (insertedCount > 0) recordBenchEvent("domInsert", insertedCount);
-				replaceChildrenInOrder(parent, nodes, false);
-				boundaryChildrenExact = true;
-				return;
-			}
-			if (insertedCount > 0) {
-				if (movedCount > 0) recordBenchEvent("domMove", movedCount);
-				recordBenchEvent("domInsert", insertedCount);
-				replaceChildrenInOrder(parent, nodes, true);
-				boundaryChildrenExact = true;
-				return;
-			}
-			if (count > 1 && commitMoveOnlyReorder(parent, nodes)) {
-				boundaryChildrenExact = true;
-				return;
-			}
-			if (movedCount > 0) recordBenchEvent("domMove", movedCount);
-			if (insertedCount > 0) recordBenchEvent("domInsert", insertedCount);
-			replaceChildrenInOrder(parent, nodes, true);
-			boundaryChildrenExact = true;
-			return;
-		}
-		let hasExistingChild = false;
-		for (let i = 0; i < count; i++) if (items[i]?.scope.dom?.parentNode === parent) {
-			hasExistingChild = true;
-			break;
-		}
-		if (!hasExistingChild) {
-			const canConsumeRemovedBoundary = isExactRemovedBoundary(parent, forState.lastRemovedNodes);
-			const replaceColdRows = () => {
-				const nodes = [];
-				for (let i = 0; i < count; i++) {
-					const itemInstance = items[i];
-					if (!itemInstance) continue;
-					const dom = syncItemDom(itemInstance, childrenVNodes[i]);
-					if (dom) nodes.push(dom);
-				}
-				replaceChildrenInOrder(parent, nodes, canConsumeRemovedBoundary);
-			};
-			replaceColdRows();
-			removedBoundaryConsumed = canConsumeRemovedBoundary;
-			boundaryChildrenExact = true;
-			return;
-		}
-		if (forState.lastRemovedNodes.length === 0) {
-			const nodes = [];
-			for (let i = 0; i < count; i++) {
-				const itemInstance = items[i];
-				if (!itemInstance) continue;
-				const dom = syncItemDom(itemInstance, childrenVNodes[i]);
-				if (!dom) continue;
-				recordBenchEvent(dom.parentNode === parent ? "domMove" : "domInsert");
-				nodes.push(dom);
-			}
-			replaceChildrenInOrder(parent, nodes, false);
-			boundaryChildrenExact = true;
-			return;
-		}
-		for (let i = 0; i < count; i++) {
-			const itemInstance = items[i];
-			if (!itemInstance) continue;
-			const dom = syncItemDom(itemInstance, childrenVNodes[i]);
-			if (!dom) continue;
-			const anchor = parent.childNodes[i] ?? null;
-			if (dom !== anchor) {
-				recordBenchEvent("domMove");
-				parent.insertBefore(dom, anchor);
-			}
-		}
-		boundaryChildrenExact = true;
-	};
-	if (forState.lastCommitStrategy === "NO_REORDER" && dirtyIndices.length > 0 && forState.pendingDirtyIndices === null && forState.pendingSwapIndices === null && !forState.pendingMoveOnly && forState.lastRemovedNodes.length === 0 && parent.childNodes.length === forState.orderedKeys.length) {
-		commitDirtyNoReorder(dirtyIndices);
-		syncKeyedMapFromForState(parent, forState, "NO_REORDER", []);
-		clearForDomUpdateState(forState);
-		return;
-	}
-	switch (forState.lastCommitStrategy) {
-		case "NO_REORDER":
-			commitDirtyNoReorder(dirtyIndices);
-			break;
-		case "TRUNCATE":
-			commitPositional();
-			break;
-		case "APPEND":
-			commitAppend();
-			break;
-		case "INSERT_ONE":
-			commitInsertOne();
-			break;
-		case "SWAP":
-			commitSwap();
-			break;
-		default:
-			commitReorder();
-			break;
-	}
-	if (!removedBoundaryConsumed) removeForBoundaryNodes(parent, forState.lastRemovedNodes, { teardown: false });
-	syncKeyedMapFromForState(parent, forState, forState.lastCommitStrategy, forState.lastRemovedNodes);
-	const syncExactForBoundaryChildren = () => {
-		const expectedNodes = [];
-		for (let i = 0; i < forState.orderedKeys.length; i++) {
-			const itemInstance = forState.orderedItems[i];
-			if (!itemInstance) continue;
-			const dom = itemInstance.scope.dom && !itemInstance.scope.needsDomUpdate ? itemInstance.scope.dom : syncItemDom(itemInstance, childrenVNodes[i]);
-			if (dom) expectedNodes.push(dom);
-		}
-		const currentNodes = Array.from(parent.childNodes);
-		if (currentNodes.length === expectedNodes.length && currentNodes.every((node, index) => node === expectedNodes[index])) return;
-		const expectedNodeSet = new Set(expectedNodes);
-		for (const currentNode of currentNodes) {
-			if (expectedNodeSet.has(currentNode)) continue;
-			teardownNodeSubtree(currentNode);
-			if (currentNode.parentNode === parent) {
-				recordBenchEvent("domRemove");
-				currentNode.remove();
-			}
-		}
-		replaceChildrenInOrder(parent, expectedNodes, true);
-	};
-	if (!boundaryChildrenExact) syncExactForBoundaryChildren();
-	forState._hasResolvedItemDom = true;
-	clearForDomUpdateState(forState);
-}
-//#endregion
-export { commitForStateBoundaryChildren };

package/dist/renderer/hydration-boundaries.js

@@ -1,60 +0,0 @@
-//#region src/renderer/hydration-boundaries.ts
-const recordsByElement = /* @__PURE__ */ new WeakMap();
-const recordsByRoot = /* @__PURE__ */ new WeakMap();
-function registerDeferredHydrationBoundary(root, element, range) {
-	const existing = recordsByElement.get(element);
-	if (existing) return existing;
-	const record = {
-		root,
-		element,
-		ownership: {
-			owner: null,
-			parent: null,
-			portalScope: null
-		},
-		context: null,
-		range,
-		vnode: void 0,
-		renderResult: void 0,
-		state: "deferred",
-		attempts: 0
-	};
-	recordsByElement.set(element, record);
-	const rootRecords = recordsByRoot.get(root) ?? /* @__PURE__ */ new Set();
-	rootRecords.add(record);
-	recordsByRoot.set(root, rootRecords);
-	return record;
-}
-function rememberDeferredHydrationVNode(element, vnode, owner, context) {
-	const record = recordsByElement.get(element);
-	if (!record) return;
-	record.vnode = vnode;
-	record.renderResult = vnode;
-	record.ownership.owner = owner;
-	record.ownership.parent = owner?.parentInstance ?? null;
-	record.ownership.portalScope = owner?.portalScope ?? null;
-	record.context = context;
-	return record;
-}
-function beginDeferredHydrationActivation(element) {
-	const record = recordsByElement.get(element);
-	if (!record || !record.vnode || record.state === "active" || record.state === "activating") return;
-	record.attempts += 1;
-	record.state = "activating";
-	return record;
-}
-function commitDeferredHydrationActivation(record) {
-	record.state = "active";
-}
-function rollbackDeferredHydrationActivation(record) {
-	record.state = "failed";
-}
-function clearDeferredHydrationBoundaries(root) {
-	const records = recordsByRoot.get(root);
-	if (!records) return;
-	for (const record of records) recordsByElement.delete(record.element);
-	records.clear();
-	recordsByRoot.delete(root);
-}
-//#endregion
-export { beginDeferredHydrationActivation, clearDeferredHydrationBoundaries, commitDeferredHydrationActivation, registerDeferredHydrationBoundary, rememberDeferredHydrationVNode, rollbackDeferredHydrationActivation };

package/dist/renderer/hydration-listener-transaction.js

@@ -1,49 +0,0 @@
-//#region src/renderer/hydration-listener-transaction.ts
-let currentTransaction = null;
-function beginHydrationListenerTransaction() {
-	const transaction = {
-		parent: currentTransaction,
-		stages: [],
-		active: true
-	};
-	currentTransaction = transaction;
-	return transaction;
-}
-function stageHydrationListener(stage) {
-	if (!currentTransaction?.active) return false;
-	currentTransaction.stages.push(stage);
-	return true;
-}
-function closeTransaction(transaction) {
-	if (!transaction.active) return false;
-	transaction.active = false;
-	currentTransaction = transaction.parent;
-	return true;
-}
-function commitHydrationListenerTransaction(transaction) {
-	if (!closeTransaction(transaction)) return;
-	const stages = [...transaction.stages].sort((left, right) => {
-		if (left.kind !== right.kind) return left.kind === "delegated" ? -1 : 1;
-		return left.eventName.localeCompare(right.eventName);
-	});
-	const published = [];
-	try {
-		for (const stage of stages) {
-			stage.publish();
-			published.push(stage);
-		}
-	} catch (error) {
-		for (let index = published.length - 1; index >= 0; index -= 1) try {
-			published[index].rollback();
-		} catch {}
-		throw error;
-	}
-}
-function discardHydrationListenerTransaction(transaction) {
-	if (!closeTransaction(transaction)) return;
-	for (let index = transaction.stages.length - 1; index >= 0; index -= 1) try {
-		transaction.stages[index].rollback();
-	} catch {}
-}
-//#endregion
-export { beginHydrationListenerTransaction, commitHydrationListenerTransaction, discardHydrationListenerTransaction, stageHydrationListener };

package/dist/renderer/index.js

@@ -1,39 +0,0 @@
-import { _isDOMElement } from "../common/vnode.js";
-import "./types.js";
-import { configureRuntimeRenderer } from "../runtime/runtime.js";
-import { getDefaultRuntimeInstance } from "../runtime/access.js";
-import "../runtime/index.js";
-import { REACTIVE_CHILDREN_KEY, cleanupInstanceIfPresent, cleanupInstancesUnder, elementListeners, elementReactivePropsCleanup, elementRefs, forEachElementReactivePropCleanup, getElementReactivePropCleanupSize, getElementReactivePropsCleanupMap, removeAllListeners, removeElementListeners, removeElementReactiveProps, removeElementRef, setDirectElementReactivePropCleanup, setFreshElementReactivePropCleanup, teardownNodeSubtree, updateElementRef } from "./cleanup.js";
-import { getKeyMapForElement, isKeyedReorderFastPathEligible, populateKeyMapForElement } from "./keyed.js";
-import { performBulkPositionalKeyedTextUpdate } from "./children-fastpath.js";
-import { isBulkTextFastPathEligible, performBulkTextReplace } from "./children.js";
-import { setStaticChildSlotsCacheEnabled } from "./static-reuse.js";
-import { updateElementChildren, updateUnkeyedChildren } from "./element-children.js";
-import { markReactivePropsDirtySource } from "./prop-bindings.js";
-import { withIntrinsicHydrationAdoption } from "./intrinsic-hydration-adoption.js";
-import "./boundary-materialization.js";
-import "./boundaries.js";
-import { syncComponentElement } from "./component-host.js";
-import { tryPatchStableForDirtyItem } from "./stable-patch.js";
-import { clearDeferredHydrationBoundaries, registerDeferredHydrationBoundary } from "./hydration-boundaries.js";
-import { IS_DOM_AVAILABLE, activateHydrationBoundary, createDOMNode, updateElementFromVnode } from "./dom-internal.js";
-import "./dom.js";
-import { evaluate } from "./evaluate.js";
-//#region src/renderer/index.ts
-function createRendererHost() {
-	return {
-		evaluate,
-		cleanupInstancesUnder,
-		teardownNodeSubtree,
-		populateKeyMapForElement,
-		getKeyMapForElement,
-		isKeyedReorderFastPathEligible,
-		markReactivePropsDirtySource
-	};
-}
-function installRendererBridge(runtime = getDefaultRuntimeInstance()) {
-	configureRuntimeRenderer(createRendererHost(), runtime);
-	return true;
-}
-//#endregion
-export { IS_DOM_AVAILABLE, REACTIVE_CHILDREN_KEY, _isDOMElement, activateHydrationBoundary, cleanupInstanceIfPresent, cleanupInstancesUnder, clearDeferredHydrationBoundaries, createDOMNode, createRendererHost, elementListeners, elementReactivePropsCleanup, elementRefs, forEachElementReactivePropCleanup, getElementReactivePropCleanupSize, getElementReactivePropsCleanupMap, installRendererBridge, isBulkTextFastPathEligible, markReactivePropsDirtySource, performBulkPositionalKeyedTextUpdate, performBulkTextReplace, registerDeferredHydrationBoundary, removeAllListeners, removeElementListeners, removeElementReactiveProps, removeElementRef, setDirectElementReactivePropCleanup, setFreshElementReactivePropCleanup, setStaticChildSlotsCacheEnabled, syncComponentElement, teardownNodeSubtree, tryPatchStableForDirtyItem, updateElementChildren, updateElementFromVnode, updateElementRef, updateUnkeyedChildren, withIntrinsicHydrationAdoption };