@askrjs/askr 0.2.4 → 0.3.1

package/dist/cleanup-TXSsApEl.js

@@ -1,535 +0,0 @@
-import { l as runRuntimeHandlerScope, y as logger } from "./access-BucjYZcX.js";
-import "./fastlane-BKZduiBQ.js";
-import { T as withAppRenderRuntime, d as getCurrentAppRenderRuntime } from "./component-scope-4I3yEMkb.js";
-import { t as cleanupComponent } from "./component-cleanup-jdbgjkT1.js";
-import { u as registerLifecycleTransaction } from "./lifecycle-batch-63aXFf2S.js";
-import { n as setRef } from "./compose-ref-Bfaf4kUC.js";
-//#region src/runtime/events.ts
-/**
-* Event delegation system for Askr
-*
-* Provides efficient event handling by attaching listeners to a container
-* instead of individual elements. This significantly reduces memory usage
-* and improves performance when many elements have the same event type.
-*
-* Delegated handling is enabled by default. Tests and internal runtime code
-* can still disable or re-enable it when they need to exercise both modes.
-*/
-const DELEGATED_EVENTS = [
-	"click",
-	"dblclick",
-	"mousedown",
-	"mouseup",
-	"mouseover",
-	"mouseout",
-	"mousemove",
-	"focus",
-	"blur",
-	"input",
-	"change",
-	"keydown",
-	"keyup",
-	"keypress",
-	"submit",
-	"scroll",
-	"wheel",
-	"touchstart",
-	"touchend",
-	"touchmove",
-	"touchcancel"
-];
-function createDelegatedEventFacade(event, currentTarget) {
-	return new Proxy(event, { get(target, property, _receiver) {
-		if (property === "currentTarget") return currentTarget;
-		const value = Reflect.get(target, property, target);
-		return typeof value === "function" ? value.bind(target) : value;
-	} });
-}
-const DELEGATED_HANDLERS = Symbol("askr.delegated-handlers");
-const delegatedHandlerFallback = /* @__PURE__ */ new WeakMap();
-function getDelegatedHandlerStore(element) {
-	return element[DELEGATED_HANDLERS] ?? delegatedHandlerFallback.get(element);
-}
-function isElementNode(node) {
-	if (!node || typeof node !== "object") return false;
-	if (typeof Element !== "undefined") return node instanceof Element;
-	return node.nodeType === 1;
-}
-function setDelegatedHandlerStore(element, store) {
-	const host = element;
-	try {
-		host[DELEGATED_HANDLERS] = store;
-		if (host[DELEGATED_HANDLERS] === store) return;
-	} catch {}
-	delegatedHandlerFallback.set(element, store);
-}
-function deleteDelegatedHandlerStore(element) {
-	const host = element;
-	if (host[DELEGATED_HANDLERS] !== void 0) try {
-		delete host[DELEGATED_HANDLERS];
-		return;
-	} catch {}
-	delegatedHandlerFallback.delete(element);
-}
-let eventDelegationEnabled = true;
-const containerDelegatedListeners = /* @__PURE__ */ new Map();
-function isEventDelegationEnabled() {
-	return eventDelegationEnabled;
-}
-function usesDelegatedCapture(eventName) {
-	return eventName === "focus" || eventName === "blur" || eventName === "scroll";
-}
-function removeContainerDelegatedListener(container, eventName, handler) {
-	if (usesDelegatedCapture(eventName)) {
-		container.removeEventListener(eventName, handler, true);
-		return;
-	}
-	container.removeEventListener(eventName, handler);
-}
-function decrementContainerListenerUsage(entry) {
-	const listeners = containerDelegatedListeners.get(entry.container);
-	const listener = listeners?.get(entry.eventName);
-	if (!listener) return;
-	listener.usage -= 1;
-	if (listener.usage > 0) return;
-	removeContainerDelegatedListener(entry.container, entry.eventName, listener.handler);
-	listeners?.delete(entry.eventName);
-	if (listeners?.size === 0) containerDelegatedListeners.delete(entry.container);
-}
-function getDelegationContainer() {
-	if (typeof document !== "undefined") return document.body;
-	return null;
-}
-function attachDelegatedListener(container, element, eventName, handler, originalHandler, options, fresh = false) {
-	const existingStore = fresh ? void 0 : getDelegatedHandlerStore(element);
-	const hadHandler = existingStore instanceof Map ? existingStore.has(eventName) : existingStore?.eventName === eventName;
-	let containerListeners = containerDelegatedListeners.get(container);
-	if (!containerListeners) {
-		containerListeners = /* @__PURE__ */ new Map();
-		containerDelegatedListeners.set(container, containerListeners);
-	}
-	let containerListener = containerListeners.get(eventName);
-	if (!containerListener) {
-		const delegatedHandler = (e) => {
-			runRuntimeHandlerScope(() => {
-				const path = [];
-				const seenPathNodes = /* @__PURE__ */ new Set();
-				let node = e.target;
-				while (node) {
-					if (!seenPathNodes.has(node)) {
-						seenPathNodes.add(node);
-						path.push(node);
-					}
-					if (node === container) break;
-					node = isElementNode(node) ? node.parentNode : node.parentNode;
-				}
-				if (typeof e.composedPath === "function") {
-					for (const composedNode of e.composedPath()) if (!seenPathNodes.has(composedNode)) {
-						seenPathNodes.add(composedNode);
-						path.push(composedNode);
-					}
-				}
-				const dispatchPath = [];
-				for (const node of path) {
-					if (node === container) break;
-					if (!isElementNode(node)) continue;
-					const store = getDelegatedHandlerStore(node);
-					const entry = !store ? void 0 : store instanceof Map ? store.get(eventName) : store.eventName === eventName ? store : void 0;
-					if (entry) dispatchPath.push({
-						node,
-						entry
-					});
-				}
-				if (eventName === "focus" || eventName === "blur" || eventName === "scroll") dispatchPath.reverse();
-				for (const { node, entry } of dispatchPath) {
-					try {
-						withAppRenderRuntime(entry.appRuntime, () => entry.handler(createDelegatedEventFacade(e, node)));
-					} catch (error) {
-						logger.error("[Askr] Delegated event error:", error);
-					}
-					if (e.cancelBubble) break;
-				}
-			}, "sync");
-		};
-		const passiveOptions = getPassiveOptions(eventName);
-		const listenerOptions = usesDelegatedCapture(eventName) ? {
-			...passiveOptions ?? options,
-			capture: true
-		} : passiveOptions ?? options;
-		container.addEventListener(eventName, delegatedHandler, listenerOptions);
-		containerListener = {
-			handler: delegatedHandler,
-			usage: 0
-		};
-		containerListeners.set(eventName, containerListener);
-	}
-	setDelegatedHandlerForElement(element, {
-		handler,
-		original: originalHandler,
-		appRuntime: getCurrentAppRenderRuntime(),
-		container,
-		eventName,
-		options
-	}, existingStore);
-	if (!hadHandler) containerListener.usage += 1;
-}
-function setDelegatedHandlerForElement(element, entry, existing = getDelegatedHandlerStore(element)) {
-	if (!existing) {
-		setDelegatedHandlerStore(element, entry);
-		return;
-	}
-	if (existing instanceof Map) {
-		existing.set(entry.eventName, entry);
-		return;
-	}
-	if (existing.eventName === entry.eventName) {
-		setDelegatedHandlerStore(element, entry);
-		return;
-	}
-	const next = /* @__PURE__ */ new Map();
-	next.set(existing.eventName, existing);
-	next.set(entry.eventName, entry);
-	setDelegatedHandlerStore(element, next);
-}
-function getPassiveOptions(eventName) {
-	if (eventName === "scroll") return { passive: true };
-}
-function addDelegatedListener(element, eventName, handler, originalHandler, options) {
-	const container = getDelegationContainer();
-	if (!container) return;
-	attachDelegatedListener(container, element, eventName, handler, originalHandler, options);
-}
-/** @internal Attach a delegated handler to a newly cloned element. */
-function addFreshDelegatedListener(element, eventName, handler, originalHandler, options) {
-	const container = getDelegationContainer();
-	if (!container) return;
-	attachDelegatedListener(container, element, eventName, handler, originalHandler, options, true);
-}
-function updateDelegatedListener(element, eventName, handler, originalHandler, options) {
-	const existing = getDelegatedHandlerForElement(element, eventName);
-	if (!existing) return false;
-	const container = getDelegationContainer();
-	if (!container || existing.container !== container || !containerDelegatedListeners.get(existing.container)?.has(eventName)) {
-		removeDelegatedListener(element, eventName);
-		return false;
-	}
-	existing.handler = handler;
-	existing.original = originalHandler;
-	existing.appRuntime = getCurrentAppRenderRuntime();
-	existing.options = options;
-	return true;
-}
-function removeDelegatedListener(element, eventName) {
-	const existing = getDelegatedHandlerStore(element);
-	if (!existing) return;
-	if (existing instanceof Map) {
-		if (existing.has(eventName)) decrementContainerListenerUsage(existing.get(eventName));
-		existing.delete(eventName);
-		if (existing.size === 0) {
-			deleteDelegatedHandlerStore(element);
-			return;
-		}
-		if (existing.size === 1) {
-			const only = existing.values().next().value;
-			setDelegatedHandlerStore(element, only);
-		}
-		return;
-	}
-	if (existing.eventName === eventName) {
-		decrementContainerListenerUsage(existing);
-		deleteDelegatedHandlerStore(element);
-	}
-}
-function getDelegatedHandlerForElement(element, eventName) {
-	const store = getDelegatedHandlerStore(element);
-	if (!store) return void 0;
-	if (store instanceof Map) return store.get(eventName);
-	return store.eventName === eventName ? store : void 0;
-}
-function getDelegatedHandlersForElement(element) {
-	const store = getDelegatedHandlerStore(element);
-	if (!store) return void 0;
-	if (store instanceof Map) return store;
-	return /* @__PURE__ */ new Map([[store.eventName, store]]);
-}
-function clearDelegatedHandlersForElement(element) {
-	const existing = getDelegatedHandlerStore(element);
-	if (existing instanceof Map) for (const entry of existing.values()) decrementContainerListenerUsage(entry);
-	else if (existing) decrementContainerListenerUsage(existing);
-	deleteDelegatedHandlerStore(element);
-}
-function isDelegatedEvent(eventName) {
-	return DELEGATED_EVENTS.includes(eventName);
-}
-//#endregion
-//#region src/renderer/cleanup.ts
-const elementRefs = /* @__PURE__ */ new WeakMap();
-const refOwners = /* @__PURE__ */ new WeakMap();
-function isRefOwnerKey(ref) {
-	return typeof ref === "function" || typeof ref === "object" && ref !== null;
-}
-/** @internal Return the current exact owner for ref reconciliation. */
-function getElementRefOwner(ref) {
-	return isRefOwnerKey(ref) ? refOwners.get(ref) : void 0;
-}
-/** @internal Synchronize ref registries without invoking user callbacks. */
-function replaceElementRefBookkeeping(element, ref) {
-	const previousRef = elementRefs.get(element);
-	if (isRefOwnerKey(previousRef) && refOwners.get(previousRef) === element) refOwners.delete(previousRef);
-	if (ref) {
-		elementRefs.set(element, ref);
-		if (isRefOwnerKey(ref)) refOwners.set(ref, element);
-	} else elementRefs.delete(element);
-}
-function applyRefValue(ref, value) {
-	setRef(ref, value);
-}
-function updateElementRef(element, ref) {
-	if (registerLifecycleTransaction({}, () => updateElementRefImmediately(element, ref), () => void 0)) return;
-	updateElementRefImmediately(element, ref);
-}
-function updateElementRefImmediately(element, ref) {
-	const previousRef = elementRefs.get(element);
-	if (previousRef === ref) return;
-	if (previousRef) {
-		applyRefValue(previousRef, null);
-		if (getElementRefOwner(previousRef) === element) refOwners.delete(previousRef);
-	}
-	if (ref) {
-		const previousOwner = getElementRefOwner(ref);
-		if (typeof ref === "function" && previousOwner && previousOwner !== element) {
-			elementRefs.set(element, ref);
-			refOwners.set(ref, element);
-			return;
-		}
-		applyRefValue(ref, element);
-		elementRefs.set(element, ref);
-		if (isRefOwnerKey(ref)) refOwners.set(ref, element);
-	} else elementRefs.delete(element);
-}
-function removeElementRef(element) {
-	const ref = elementRefs.get(element);
-	if (!ref) return;
-	if (typeof ref !== "function" && getElementRefOwner(ref) !== element) {
-		elementRefs.delete(element);
-		return;
-	}
-	applyRefValue(ref, null);
-	const nextOwner = getElementRefOwner(ref);
-	if (typeof ref === "function" && nextOwner && nextOwner !== element) applyRefValue(ref, nextOwner);
-	replaceElementRefBookkeeping(element, void 0);
-}
-function cleanupSingleInstance(node, errors, strict) {
-	const instanceList = node.__ASKR_INSTANCES;
-	const primaryInstance = node.__ASKR_INSTANCE;
-	if (!instanceList && !primaryInstance) return;
-	const instances = /* @__PURE__ */ new Set();
-	if (Array.isArray(instanceList)) {
-		for (const instance of instanceList) if (instance) instances.add(instance);
-	}
-	if (primaryInstance) instances.add(primaryInstance);
-	for (const instance of instances) try {
-		cleanupComponent(instance);
-	} catch (err) {
-		if (strict) errors.push(err);
-		else logger.warn("[Askr] cleanupComponent failed:", err);
-	}
-	try {
-		delete node.__ASKR_INSTANCE;
-		delete node.__ASKR_INSTANCES;
-	} catch (e) {
-		if (strict) errors.push(e);
-	}
-}
-function teardownSingleElement(element, errors, strict) {
-	try {
-		removeElementRef(element);
-	} catch (err) {
-		if (strict) errors.push(err);
-		else logger.warn("[Askr] removeElementRef failed:", err);
-	}
-	try {
-		removeElementListeners(element);
-	} catch (err) {
-		if (strict) errors.push(err);
-		else logger.warn("[Askr] removeElementListeners failed:", err);
-	}
-	try {
-		removeElementReactiveProps(element);
-	} catch (err) {
-		if (strict) errors.push(err);
-		else logger.warn("[Askr] removeElementReactiveProps failed:", err);
-	}
-	try {
-		cleanupSingleInstance(element, errors, strict);
-	} catch (err) {
-		if (strict) errors.push(err);
-		else logger.warn("[Askr] cleanupSingleInstance failed:", err);
-	}
-}
-function forEachDescendantElement(root, visit) {
-	try {
-		const doc = root.ownerDocument;
-		const createTreeWalker = doc?.createTreeWalker;
-		if (typeof createTreeWalker === "function") {
-			const walker = createTreeWalker.call(doc, root, 1);
-			let n = walker.firstChild();
-			while (n) {
-				visit(n);
-				n = walker.nextNode();
-			}
-			return;
-		}
-	} catch {}
-	const descendants = root.querySelectorAll("*");
-	for (let i = 0; i < descendants.length; i++) visit(descendants[i]);
-}
-/** @internal Walk every descendant node, including component-host comments. */
-function forEachDescendantNode(root, visit) {
-	try {
-		const doc = root.ownerDocument;
-		const createTreeWalker = doc?.createTreeWalker;
-		if (typeof createTreeWalker === "function") {
-			const walker = createTreeWalker.call(doc, root, 4294967295);
-			let node = walker.nextNode();
-			while (node) {
-				visit(node);
-				node = walker.nextNode();
-			}
-			return;
-		}
-	} catch {}
-	const stack = Array.from(root.childNodes).reverse();
-	while (stack.length > 0) {
-		const node = stack.pop();
-		visit(node);
-		for (let child = node.lastChild; child; child = child.previousSibling) stack.push(child);
-	}
-}
-function forEachElementInSubtree(root, visit) {
-	visit(root);
-	forEachDescendantElement(root, visit);
-}
-const elementListeners = /* @__PURE__ */ new WeakMap();
-/**
-* Clean up component instance attached to a DOM node
-* Accepts an optional `opts.strict` flag to surface errors instead of swallowing them.
-*/
-function cleanupInstanceIfPresent(node, opts) {
-	if (!node) return;
-	const strict = opts?.strict ?? false;
-	const errors = strict ? [] : null;
-	try {
-		cleanupSingleInstance(node, errors, strict);
-	} catch (err) {
-		if (strict) errors.push(err);
-		else logger.warn("[Askr] cleanupInstanceIfPresent failed:", err);
-	}
-	try {
-		forEachDescendantNode(node, (descendant) => {
-			try {
-				cleanupSingleInstance(descendant, errors, strict);
-			} catch (err) {
-				if (strict) errors.push(err);
-				else logger.warn("[Askr] cleanupInstanceIfPresent descendant cleanup failed:", err);
-			}
-		});
-	} catch (err) {
-		if (strict) errors.push(err);
-		else logger.warn("[Askr] cleanupInstanceIfPresent descendant query failed:", err);
-	}
-	if (errors && errors.length > 0) throw new AggregateError(errors, "cleanupInstanceIfPresent failed");
-}
-function cleanupInstancesUnder(node, opts) {
-	cleanupInstanceIfPresent(node, opts);
-}
-function teardownNodeSubtree(node, opts) {
-	if (!node) return;
-	const strict = opts?.strict ?? false;
-	const errors = strict ? [] : null;
-	if (!(node instanceof Element)) {
-		cleanupSingleInstance(node, errors, strict);
-		if (errors && errors.length > 0) throw new AggregateError(errors, "teardownNodeSubtree failed");
-		return;
-	}
-	try {
-		teardownSingleElement(node, errors, strict);
-		forEachDescendantNode(node, (descendant) => {
-			if (descendant instanceof Element) teardownSingleElement(descendant, errors, strict);
-			else cleanupSingleInstance(descendant, errors, strict);
-		});
-	} catch (err) {
-		if (strict) errors.push(err);
-		else logger.warn("[Askr] teardownNodeSubtree failed:", err);
-	}
-	if (errors && errors.length > 0) throw new AggregateError(errors, "teardownNodeSubtree failed");
-}
-const REACTIVE_CHILDREN_KEY = "__askr_reactive_children__";
-const elementReactivePropsCleanup = /* @__PURE__ */ new WeakMap();
-function getElementReactivePropsCleanupMap(element, create = false) {
-	const store = elementReactivePropsCleanup.get(element);
-	if (store instanceof Map) return store;
-	if (store) {
-		const map = /* @__PURE__ */ new Map([[store._bindingKey, store]]);
-		elementReactivePropsCleanup.set(element, map);
-		return map;
-	}
-	if (!create) return;
-	const map = /* @__PURE__ */ new Map();
-	elementReactivePropsCleanup.set(element, map);
-	return map;
-}
-function setDirectElementReactivePropCleanup(element, bindingKey, entry) {
-	if (!elementReactivePropsCleanup.get(element)) {
-		entry._bindingKey = bindingKey;
-		elementReactivePropsCleanup.set(element, entry);
-		return;
-	}
-	getElementReactivePropsCleanupMap(element, true).set(bindingKey, entry);
-}
-/** @internal Publish the first reactive binding on a newly created element. */
-function setFreshElementReactivePropCleanup(element, bindingKey, entry) {
-	entry._bindingKey = bindingKey;
-	elementReactivePropsCleanup.set(element, entry);
-}
-function getElementReactivePropCleanupSize(element) {
-	const store = elementReactivePropsCleanup.get(element);
-	return store instanceof Map ? store.size : store ? 1 : 0;
-}
-function forEachElementReactivePropCleanup(element, visit) {
-	const store = elementReactivePropsCleanup.get(element);
-	if (store instanceof Map) for (const entry of store.values()) visit(entry);
-	else if (store) visit(store);
-}
-function removeElementReactiveProps(element) {
-	if (elementReactivePropsCleanup.has(element)) {
-		forEachElementReactivePropCleanup(element, (entry) => {
-			try {
-				entry.cleanup();
-			} catch (err) {
-				logger.warn("[Askr] reactive prop cleanup failed:", err);
-			}
-		});
-		elementReactivePropsCleanup.delete(element);
-	}
-}
-function removeElementListeners(element) {
-	const map = elementListeners.get(element);
-	if (map) {
-		for (const entry of map.values()) if (entry.isDelegated) removeDelegatedListener(element, entry.eventName);
-		else if (entry.options !== void 0) element.removeEventListener(entry.eventName, entry.handler, entry.options);
-		else element.removeEventListener(entry.eventName, entry.handler);
-		elementListeners.delete(element);
-	}
-	clearDelegatedHandlersForElement(element);
-}
-function removeAllListeners(root) {
-	if (!root) return;
-	forEachElementInSubtree(root, (el) => {
-		removeElementRef(el);
-		removeElementListeners(el);
-		removeElementReactiveProps(el);
-	});
-}
-//#endregion
-export { getDelegatedHandlersForElement as C, updateDelegatedListener as D, removeDelegatedListener as E, getDelegatedHandlerForElement as S, isEventDelegationEnabled as T, teardownNodeSubtree as _, elementReactivePropsCleanup as a, addFreshDelegatedListener as b, forEachElementReactivePropCleanup as c, removeAllListeners as d, removeElementReactiveProps as f, setFreshElementReactivePropCleanup as g, setDirectElementReactivePropCleanup as h, elementListeners as i, getElementReactivePropCleanupSize as l, replaceElementRefBookkeeping as m, cleanupInstanceIfPresent as n, elementRefs as o, removeElementRef as p, cleanupInstancesUnder as r, forEachDescendantNode as s, REACTIVE_CHILDREN_KEY as t, getElementReactivePropsCleanupMap as u, updateElementRef as v, isDelegatedEvent as w, clearDelegatedHandlersForElement as x, addDelegatedListener as y };

package/dist/component-cleanup-jdbgjkT1.js

@@ -1,143 +0,0 @@
-import { S as isProductionEnvironment, x as isDevelopmentEnvironment, y as logger } from "./access-BucjYZcX.js";
-import { a as clearCurrentComponentScope, y as restoreCurrentComponentScope } from "./component-scope-4I3yEMkb.js";
-import { n as cleanupReadableSubscriptions, t as cleanupReadableSubscriptionSources } from "./readable-Di1fzSwm.js";
-//#region src/runtime/state-diagnostics.ts
-/**
-* Report state cells that were never read during a component's completed
-* lifetime. A branch that has not rendered yet is not evidence that its state
-* is unused, so this diagnostic belongs at unmount rather than every commit.
-*/
-function warnUnusedStateReads(instance) {
-	if (isProductionEnvironment() || !instance.mounted) return;
-	const stateValues = instance.stateValues;
-	if (!stateValues) return;
-	for (let i = 0; i < stateValues.length; i++) {
-		const state = stateValues[i];
-		const diagnosticEligible = state?._unusedStateDiagnosticEligible;
-		const hasCommittedUsage = (state?._readers?.size ?? 0) > 0 || (state?._derivedSubscribers?.size ?? 0) > 0;
-		if (state && diagnosticEligible !== false && !state._hasEverBeenRead && !hasCommittedUsage) {
-			const warnings = instance.devWarningsEmitted ??= /* @__PURE__ */ new Set();
-			const key = `unused-state:${i}`;
-			if (warnings.has(key)) continue;
-			warnings.add(key);
-			try {
-				const name = instance.fn?.name || "<anonymous>";
-				logger.warn(`[askr] Unused state variable detected in ${name} at index ${i}. State should be read during render or removed.`);
-			} catch {
-				logger.warn("[askr] Unused state variable detected. State should be read during render or removed.");
-			}
-		}
-	}
-}
-//#endregion
-//#region src/runtime/component-cleanup.ts
-/**
-* Component cleanup and owned child-scope bookkeeping.
-*/
-/**
-* Dispose an inactive ownership generation without swapping it back onto the
-* component instance that now represents a different live route.
-*/
-function cleanupComponentGeneration(instance, generation) {
-	const savedScope = clearCurrentComponentScope();
-	try {
-		const cleanupErrors = instance.cleanupStrict ? [] : void 0;
-		const recordCleanupError = (message, err) => {
-			if (cleanupErrors) cleanupErrors.push(err);
-			else if (isDevelopmentEnvironment()) logger.warn(message, err);
-		};
-		const ownedChildScopes = generation.ownedChildScopes;
-		if (ownedChildScopes && ownedChildScopes.size > 0) {
-			for (const scope of ownedChildScopes) try {
-				scope.dispose();
-			} catch (err) {
-				recordCleanupError("[Askr] child scope cleanup threw:", err);
-			}
-			ownedChildScopes.clear();
-		}
-		try {
-			cleanupReadableSubscriptionSources(instance, generation.readSources, generation.ownershipGeneration);
-		} catch (err) {
-			recordCleanupError("[Askr] readable subscription cleanup threw:", err);
-		}
-		const cleanupFns = generation.cleanupFns;
-		generation.cleanupFns = void 0;
-		if (cleanupFns) for (const cleanup of cleanupFns) try {
-			cleanup();
-		} catch (err) {
-			recordCleanupError("[Askr] cleanup function threw:", err);
-		}
-		try {
-			if (generation.abortController && !generation.abortController.signal.aborted) generation.abortController.abort();
-		} catch (err) {
-			recordCleanupError("[Askr] abort controller cleanup threw:", err);
-		}
-		generation.abortController = null;
-		if (cleanupErrors && cleanupErrors.length > 0) throw new AggregateError(cleanupErrors, `Cleanup failed for component ${instance.id}`);
-	} finally {
-		restoreCurrentComponentScope(savedScope);
-	}
-}
-/**
-* Clean up component resources on unmount or route changes.
-*/
-function cleanupComponent(instance) {
-	const savedScope = clearCurrentComponentScope();
-	try {
-		warnUnusedStateReads(instance);
-		const cleanupErrors = instance.cleanupStrict ? [] : void 0;
-		const recordCleanupError = (message, err) => {
-			if (cleanupErrors) cleanupErrors.push(err);
-			else if (isDevelopmentEnvironment()) logger.warn(message, err);
-		};
-		const ownedChildScopes = instance._ownedChildScopes;
-		if (ownedChildScopes && ownedChildScopes.size > 0) {
-			instance._ownedChildScopes = /* @__PURE__ */ new Set();
-			for (const scope of ownedChildScopes) try {
-				scope.dispose();
-			} catch (err) {
-				recordCleanupError("[Askr] child scope cleanup threw:", err);
-			}
-		}
-		const cleanupFns = instance.cleanupFns;
-		instance.cleanupFns = void 0;
-		if (cleanupFns) for (const cleanup of cleanupFns) try {
-			cleanup();
-		} catch (err) {
-			recordCleanupError("[Askr] cleanup function threw:", err);
-		}
-		try {
-			cleanupReadableSubscriptions(instance);
-		} catch (err) {
-			recordCleanupError("[Askr] readable subscription cleanup threw:", err);
-		}
-		try {
-			if (instance.abortController && !instance.abortController.signal.aborted) instance.abortController.abort();
-		} catch (err) {
-			recordCleanupError("[Askr] abort controller cleanup threw:", err);
-		}
-		instance.abortController = null;
-		instance.lifecycleGeneration++;
-		instance.evaluationGeneration++;
-		instance.mountOperations = void 0;
-		instance.commitOperations = void 0;
-		instance.lifecycleSlots = void 0;
-		instance.hasPendingUpdate = false;
-		instance.notifyUpdate = null;
-		instance._portalErrorParent = void 0;
-		instance._portalErrorParentGeneration = void 0;
-		instance._placeholder = void 0;
-		instance.mounted = false;
-		if (cleanupErrors && cleanupErrors.length > 0) throw new AggregateError(cleanupErrors, `Cleanup failed for component ${instance.id}`);
-	} finally {
-		restoreCurrentComponentScope(savedScope);
-	}
-}
-function registerOwnedChildScope(instance, scope) {
-	(instance._ownedChildScopes ??= /* @__PURE__ */ new Set()).add(scope);
-}
-function unregisterOwnedChildScope(instance, scope) {
-	instance._ownedChildScopes?.delete(scope);
-}
-//#endregion
-export { unregisterOwnedChildScope as i, cleanupComponentGeneration as n, registerOwnedChildScope as r, cleanupComponent as t };