@askrjs/askr 0.0.27 → 0.0.29

package/dist/renderer/dom.js

@@ -1 +1,2439 @@
-import{logger as Oe}from"../dev/logger.js";import"../jsx-runtime.js";import{CONTEXT_FRAME_SYMBOL as re,getCurrentContextFrame as oe,withContext as K}from"../runtime/context.js";import{getCurrentInstance as V,setCurrentComponentInstance as D,createComponentInstance as ie,renderComponentInline as se,mountInstanceInline as U}from"../runtime/component.js";import{elementListeners as h,elementReactivePropsCleanup as A,removeAllListeners as y,cleanupInstanceIfPresent as g}from"./cleanup.js";import{incDevCounter as q,getDevValue as ce,setDevValue as N}from"../runtime/dev-namespace.js";import"./types.js";import{__FOR_BOUNDARY__ as j,_isDOMElement as S}from"../common/vnode.js";import{evaluateForState as z}from"../runtime/for.js";import{keyedElements as v}from"./keyed.js";import{reconcileKeyedChildren as ae}from"./reconcile.js";import{createWrappedHandler as G,getPassiveOptions as X,isSkippedProp as $,parseEventName as Y,now as F,logFastPathDebug as I,recordFastPathStats as fe,hasNonTrivialProps as B,recordDOMReplace as le}from"./utils.js";import{globalScheduler as O}from"../runtime/scheduler.js";import{isEventDelegationEnabled as W,isDelegatedEvent as J,addDelegatedListener as Q,getDelegatedHandlersForElement as ue,removeDelegatedListener as k}from"../runtime/events.js";import{Fragment as de}from"../common/jsx.js";var P={};const pe=typeof document<"u";let H=0;function me(){const e="__COMPONENT_INSTANCE_ID";try{q(e);const t=ce(e);if(typeof t=="number"&&Number.isFinite(t))return`comp-${t}`}catch{}return H++,`comp-${H}`}function ge(e,t,n){const r=W()&&J(t);r&&Q(e,t,n,n,void 0);const o=G(n,!0),a=X(t);r||(a!==void 0?e.addEventListener(t,o,a):e.addEventListener(t,o)),h.has(e)||h.set(e,new Map),h.get(e).set(t,{handler:Z(r,e,t,o),original:n,options:a,isDelegated:r})}function Z(e,t,n,r){if(!e)return r;const o=ue(t);if(o){const a=o.get(n);if(a)return a.handler}return r}const E=new Set;let d=null,x=!1;function ye(){if(!d){d={id:"reactive-props-coordinator",lastRenderToken:0,hasPendingUpdate:!1,notifyUpdate:null,abortController:new AbortController};const e=()=>{if(!x)return;x=!1;const t=V();try{for(const n of E){if(!n.isActive)continue;for(const a of n.readStates)a._readers&&a._readers.delete(d);n.readStates.clear();const r=new Set,o={_pendingReadStates:r,_currentRenderToken:d.lastRenderToken};D(o);try{const a=n.propFn();te(n.el,n.propName,a,n.tagName),n.readStates=r}catch{}}d&&(d.lastRenderToken=(d.lastRenderToken??0)+1);for(const n of E)if(n.isActive)for(const r of n.readStates)r._readers||(r._readers=new Map),r._readers.set(d,d.lastRenderToken??0)}finally{D(t)}};d.notifyUpdate=()=>{x||(x=!0,O.isExecuting()?e():O.enqueue(e))},d._pendingFlushTask=()=>{d.hasPendingUpdate=!1,d.notifyUpdate()}}return d}function ee(e,t,n,r){const o=ye(),a={el:e,propName:t,propFn:n,tagName:r,readStates:new Set,isActive:!0};E.add(a);const s=V(),i=new Set,f={_pendingReadStates:i,_currentRenderToken:o.lastRenderToken};D(f);try{const c=n();te(e,t,c,r),a.readStates=i;for(const l of i)l._readers||(l._readers=new Map),l._readers.set(o,o.lastRenderToken??0)}finally{D(s)}return()=>{if(a.isActive=!1,E.delete(a),d)for(const c of a.readStates)c._readers&&c._readers.delete(d);a.readStates.clear(),E.size===0&&d&&(d.abortController.abort(),d=null)}}function te(e,t,n,r){if(n==null||n===!1){t==="class"||t==="className"?e.className="":e.removeAttribute(t);return}t==="class"||t==="className"?e.className=String(n):t==="value"||t==="checked"?ne(e,t,n,r):e.setAttribute(t,String(n))}function he(e,t,n){for(const r in t){const o=t[r];if(r==="ref"){Se(e,o);continue}if($(r)||o==null||o===!1)continue;const a=Y(r);if(a){ge(e,a,o);continue}if(typeof o=="function"&&!a&&r!=="ref"){const s=ee(e,r,o,n);A.has(e)||A.set(e,new Map),A.get(e).set(r,{cleanup:s,fnRef:o});continue}r==="class"||r==="className"?e.className=String(o):r==="value"||r==="checked"?ne(e,r,o,n):e.setAttribute(r,String(o))}}function Se(e,t){const n=t;if(n){if(typeof n=="function"){n(e);return}Object.isExtensible(n)&&(n.current=e)}}function ne(e,t,n,r){t==="value"?((b(r,"input")||b(r,"textarea")||b(r,"select"))&&(e.value=String(n)),e.setAttribute("value",String(n))):t==="checked"&&(b(r,"input")&&(e.checked=!!n),e.setAttribute("checked",String(!!n)))}function R(e,t,n){const r=t.key??n?.key;r!==void 0&&e.setAttribute("data-key",String(r))}function p(e){if(!pe)return null;if(typeof e=="string")return document.createTextNode(e);if(typeof e=="number")return document.createTextNode(String(e));if(!e)return null;if(Array.isArray(e)){const t=document.createDocumentFragment();for(const n of e){const r=p(n);r&&t.appendChild(r)}return t}if(typeof e=="object"&&e!==null&&"type"in e){const t=e.type,n=e.props||{};if(typeof t=="string")return Ae(e,t,n);if(typeof t=="function")return Ce(e,t,n);if(t===j)return be(e,n);if(typeof t=="symbol"&&(t===de||String(t)==="Symbol(Fragment)"))return Te(e,n)}return null}function Ae(e,t,n){const r=document.createElement(t);R(r,e,n),he(r,n,t);const o=n.children??e.children;if(o!=null)if(Array.isArray(o)){for(const a of o){const s=p(a);s&&r.appendChild(s)}}else{const a=p(o);a&&r.appendChild(a)}return r}function Ce(e,t,n){const o=e[re]||oe(),a=t;if(a.constructor.name==="AsyncFunction")throw new Error("Async components are not supported. Use resource() for async work.");let i=e.__instance;i||(i=ie(me(),a,n||{},null),e.__instance=i),o&&(i.ownerFrame=o);const f=K(o,()=>se(i));if(f instanceof Promise)throw new Error("Async components are not supported. Components must return synchronously.");const c=K(o,()=>p(f));if(c instanceof Element)return U(i,c),R(c,e,n),c;if(!c){const u=document.createComment("");return i._placeholder=u,i.mounted=!0,i.notifyUpdate=i._enqueueRun,u}const l=document.createElement("div");return l.appendChild(c),U(i,l),R(l,e,n),l}function Te(e,t){const n=document.createDocumentFragment(),r=t.children||e.children;if(r)if(Array.isArray(r))for(const o of r){const a=p(o);a&&n.appendChild(a)}else{const o=p(r);o&&n.appendChild(o)}return n}function _e(e,t){if(!S(t)||!(e instanceof Element))return!0;const n=t.type;return typeof n!="string"?!0:e.tagName.toLowerCase()!==n.toLowerCase()}function be(e,t){const n=e._forState;if(!n)return document.createDocumentFragment();const r=t.source,o=z(n,r),a=document.createDocumentFragment();for(let s=0;s<o.length;s++){const i=o[s],f=n.orderedKeys[s],c=f!=null?n.items.get(f):null;let l=null;if(c&&c._dom){const u=c._dom;_e(u,i)||(l=u)}l||(l=p(i),c&&(c._dom=l??void 0)),l&&(l instanceof Element&&C(l,i,!0),a.appendChild(l))}return a}function C(e,t,n=!0){if(!S(t))return;const r=t.props||{};R(e,t,r);const o=h.get(e);let a=null;for(const s in r){const i=r[s];if($(s))continue;const f=Y(s);if(i==null||i===!1){if(s==="class"||s==="className")e.className="";else if(f&&o?.has(f)){const c=o.get(f);c.isDelegated?k(e,f):c.options!==void 0?e.removeEventListener(f,c.handler,c.options):e.removeEventListener(f,c.handler),o.delete(f)}else e.removeAttribute(s);continue}if(typeof i=="function"&&!f&&s!=="ref"){const l=A.get(e)?.get(s);if(l&&l.fnRef===i)continue;l&&l.cleanup();const u=ee(e,s,i,t.type);A.has(e)||A.set(e,new Map),A.get(e).set(s,{cleanup:u,fnRef:i});continue}if(s==="class"||s==="className")e.className=String(i);else if(s==="value"||s==="checked")e[s]=i;else if(f){o&&o.size>0&&(a??=new Set).add(f);const c=W()&&J(f),l=o?.get(f);if(l&&l.original===i)continue;l&&(l.isDelegated?k(e,f):l.options!==void 0?e.removeEventListener(f,l.handler,l.options):e.removeEventListener(f,l.handler)),c&&Q(e,f,i,i,void 0);const u=G(i,!0),m=X(f);c||(m!==void 0?e.addEventListener(f,u,m):e.addEventListener(f,u)),h.has(e)||h.set(e,new Map),h.get(e).set(f,{handler:Z(c,e,f,u),original:i,options:m,isDelegated:c})}else e.setAttribute(s,String(i))}if(o&&o.size>0)if(a===null){for(const[s,i]of o)i.isDelegated?k(e,s):i.options!==void 0?e.removeEventListener(s,i.handler,i.options):e.removeEventListener(s,i.handler);h.delete(e)}else{for(const[s,i]of o)a.has(s)||(i.isDelegated?k(e,s):i.options!==void 0?e.removeEventListener(s,i.handler,i.options):e.removeEventListener(s,i.handler),o.delete(s));o.size===0&&h.delete(e)}if(n){const s=t.children||r.children;Ee(e,s)}}function Ee(e,t){if(t==null){for(let r=e.firstChild;r;){const o=r.nextSibling;r instanceof Element&&(y(r),g(r)),r=o}e.textContent="";return}if(!Array.isArray(t)&&(typeof t=="string"||typeof t=="number")){if(e.childNodes.length===1&&e.firstChild?.nodeType===3)e.firstChild.data=String(t);else{for(let r=e.firstChild;r;){const o=r.nextSibling;r instanceof Element&&(y(r),g(r)),r=o}e.textContent=String(t)}return}if(Array.isArray(t)&&t.length===1&&S(t[0])&&t[0].type===j){const r=t[0],o=r._forState;if(!o)throw new Error("[updateElementChildren] For boundary missing _forState");const a=(r.props||{}).source,s=z(o,a),i=v.get(e),f=ae(e,s,i||new Map);v.set(e,f);return}if(Array.isArray(t)){ve(e,t);return}for(let r=e.firstChild;r;){const o=r.nextSibling;r instanceof Element&&(y(r),g(r)),r=o}e.textContent="";const n=p(t);n&&e.appendChild(n)}function ve(e,t){const n=Array.from(e.children),r=t.some(s=>typeof s=="string"||typeof s=="number"),o=t.some(s=>S(s));if(r&&o){const s=Array.from(e.childNodes),i=Math.max(s.length,t.length);for(let f=0;f<i;f++){const c=s[f],l=t[f];if(l===void 0&&c){c.nodeType===1&&g(c),c.remove();continue}if(!c&&l!==void 0){const u=p(l);u&&e.appendChild(u);continue}if(!(!c||l===void 0)){if(typeof l=="string"||typeof l=="number")if(c.nodeType===3)c.data=String(l);else{const u=document.createTextNode(String(l));e.replaceChild(u,c)}else if(S(l))if(c.nodeType===1){const u=c;if(typeof l.type=="string")if(_(u.tagName,l.type))C(u,l);else{const m=p(l);m&&(y(u),g(u),e.replaceChild(m,c))}}else{const u=p(l);u&&e.replaceChild(u,c)}}}return}if(t.length===1&&n.length===0&&e.childNodes.length===1){const s=t[0],i=e.firstChild;if((typeof s=="string"||typeof s=="number")&&i?.nodeType===3){i.data=String(s);return}}if(n.length===0&&e.childNodes.length>0){for(let s=e.firstChild;s;){const i=s.nextSibling;s instanceof Element&&(y(s),g(s)),s=i}e.textContent=""}const a=Math.max(n.length,t.length);for(let s=0;s<a;s++){const i=n[s],f=t[s];if(f===void 0&&i){g(i),i.remove();continue}if(!i&&f!==void 0){const c=p(f);c&&e.appendChild(c);continue}if(!(!i||f===void 0))if(typeof f=="string"||typeof f=="number"){if(i instanceof Element&&i.childNodes.length>0)for(let c=i.firstChild;c;){const l=c.nextSibling;c instanceof Element&&(y(c),g(c)),c=l}i.textContent=String(f)}else if(S(f))if(typeof f.type=="string")if(_(i.tagName,f.type))C(i,f);else{const c=p(f);c&&(i instanceof Element&&y(i),g(i),e.replaceChild(c,i))}else{const c=p(f);c&&(i instanceof Element&&y(i),g(i),e.replaceChild(c,i))}else{const c=p(f);c&&(i instanceof Element&&y(i),g(i),e.replaceChild(c,i))}}}function tt(e,t){const n=t.length;let r=0,o=0;const a=F(),s=P.ASKR_FASTPATH_DEBUG==="1"||P.ASKR_FASTPATH_DEBUG==="true";for(let c=0;c<n;c++){const{key:l,vnode:u}=t[c],m=e.children[c];if(m&&S(u)&&typeof u.type=="string"){const L=u.type;if(_(m.tagName,L)){const w=u.children||u.props?.children;s&&I("positional idx",c,{chTag:m.tagName,vnodeType:L,chChildNodes:m.childNodes.length,childrenType:Array.isArray(w)?"array":typeof w}),ke(m,w,u),Ne(m,l,()=>o++),r++;continue}else s&&I("positional tag mismatch",c,{chTag:m.tagName,vnodeType:L})}else s&&I("positional missing or invalid",c,{ch:!!m});Fe(e,c,u)}const i=F()-a;Pe(e,t);const f={n,reused:r,updatedKeys:o,t:i};return fe(f,"bulkKeyedPositionalHits"),f}function ke(e,t,n){typeof t=="string"||typeof t=="number"?(T(e,String(t)),n.props&&B(n.props)&&C(e,n,!1)):Array.isArray(t)&&t.length===1&&(typeof t[0]=="string"||typeof t[0]=="number")?(T(e,String(t[0])),n.props&&B(n.props)&&C(e,n,!1)):xe(e,n)||C(e,n)}function xe(e,t){const n=t.children||t.props?.children;if(!Array.isArray(n)||n.length!==2)return!1;const r=n[0],o=n[1];if(!S(r)||!S(o)||typeof r.type!="string"||typeof o.type!="string")return!1;const a=e.children[0],s=e.children[1];if(!a||!s||!_(a.tagName,r.type)||!_(s.tagName,o.type))return!1;const i=r.children||r.props?.children,f=o.children||o.props?.children;if(typeof i=="string"||typeof i=="number")T(a,String(i));else if(Array.isArray(i)&&i.length===1&&(typeof i[0]=="string"||typeof i[0]=="number"))T(a,String(i[0]));else return!1;if(typeof f=="string"||typeof f=="number")T(s,String(f));else if(Array.isArray(f)&&f.length===1&&(typeof f[0]=="string"||typeof f[0]=="number"))T(s,String(f[0]));else return!1;return!0}function T(e,t){e.childNodes.length===1&&e.firstChild?.nodeType===3?e.firstChild.data=t:e.textContent=t}function Ne(e,t,n){try{const r=String(t);if(e.getAttribute("data-key")===r)return;e.setAttribute("data-key",r),n()}catch{}}function De(e){switch(e){case"div":return"DIV";case"span":return"SPAN";case"p":return"P";case"a":return"A";case"button":return"BUTTON";case"input":return"INPUT";case"ul":return"UL";case"ol":return"OL";case"li":return"LI";default:return null}}function b(e,t){if(e===t)return!0;const n=e.length;if(n!==t.length)return!1;for(let r=0;r<n;r++){const o=e.charCodeAt(r),a=t.charCodeAt(r);if(o===a)continue;const s=o>=65&&o<=90?o+32:o,i=a>=65&&a<=90?a+32:a;if(s!==i)return!1}return!0}function _(e,t){const n=De(t);return n!==null&&e===n?!0:b(e,t)}function Fe(e,t,n){const r=p(n);if(r){const o=e.children[t];o?(g(o),e.replaceChild(r,o)):e.appendChild(r)}}function Pe(e,t){try{const n=v.get(e),r=n?(n.clear(),n):new Map;for(let o=0;o<t.length;o++){const a=t[o].key,s=e.children[o];s&&r.set(a,s)}v.set(e,r)}catch{}}function nt(e,t){const n=F(),r=Array.from(e.childNodes),o=[];let a=0,s=0;for(let l=0;l<t.length;l++){const u=Re(t[l],r[l],o);u==="reused"?a++:u==="created"&&s++}const i=F()-n,f=Ie(e,o);v.delete(e);const c={n:t.length,reused:a,created:s,tBuild:i,tCommit:f};return Me(c),c}function Re(e,t,n){return typeof e=="string"||typeof e=="number"?Le(String(e),t,n):typeof e=="object"&&e!==null&&"type"in e?we(e,t,n):"skipped"}function Le(e,t,n){return t&&t.nodeType===3?(t.data=e,n.push(t),"reused"):(n.push(document.createTextNode(e)),"created")}function we(e,t,n){const r=e;if(typeof r.type=="string"){const a=r.type;if(t&&t.nodeType===1&&_(t.tagName,a))return C(t,e),n.push(t),"reused"}const o=p(e);return o?(n.push(o),"created"):"skipped"}function Ie(e,t){const n=Date.now(),r=document.createDocumentFragment();for(let o=0;o<t.length;o++)r.appendChild(t[o]);try{for(let o=e.firstChild;o;){const a=o.nextSibling;o instanceof Element&&y(o),g(o),o=a}}catch{}return le("bulk-text-replace"),e.replaceChildren(r),Date.now()-n}function Me(e){try{N("__LAST_BULK_TEXT_FASTPATH_STATS",e),N("__LAST_FASTPATH_STATS",e),N("__LAST_FASTPATH_COMMIT_COUNT",1),q("bulkTextFastpathHits")}catch{}}function rt(e,t){const n=Number(P.ASKR_BULK_TEXT_THRESHOLD)||1024,r=.8,o=Array.isArray(t)?t.length:0;if(o<n)return M({phase:"bulk-unkeyed-eligible",reason:"too-small",total:o,threshold:n}),!1;const a=Ke(t);if(a.componentFound!==void 0)return M({phase:"bulk-unkeyed-eligible",reason:"component-child",index:a.componentFound}),!1;const s=a.simple/o,i=s>=r&&e.childNodes.length>=o;return M({phase:"bulk-unkeyed-eligible",total:o,simple:a.simple,fraction:s,requiredFraction:r,eligible:i}),i}function Ke(e){let t=0;for(let n=0;n<e.length;n++){const r=e[n];if(typeof r=="string"||typeof r=="number"){t++;continue}if(typeof r=="object"&&r!==null&&"type"in r){const o=r;if(typeof o.type=="function")return{simple:t,componentFound:n};typeof o.type=="string"&&Ue(o)&&t++}}return{simple:t}}function Ue(e){const t=e.children||e.props?.children;return!!(t==null||typeof t=="string"||typeof t=="number"||Array.isArray(t)&&t.length===1&&(typeof t[0]=="string"||typeof t[0]=="number"))}function M(e){if(P.ASKR_FASTPATH_DEBUG==="1")try{N("__BULK_DIAG",e)}catch{}}export{pe as IS_DOM_AVAILABLE,p as createDOMNode,be as createForBoundary,rt as isBulkTextFastPathEligible,tt as performBulkPositionalKeyedTextUpdate,nt as performBulkTextReplace,Ee as updateElementChildren,C as updateElementFromVnode,ve as updateUnkeyedChildren};
+import { __FOR_BOUNDARY__, _isDOMElement } from "../common/vnode.js";
+import "./types.js";
+import { getRuntimeEnv } from "../common/env.js";
+import { logger } from "../dev/logger.js";
+import { incrementPerfMetric } from "../runtime/perf-metrics.js";
+import { globalScheduler } from "../runtime/scheduler.js";
+import { Fragment, STATIC_CHILDREN } from "../common/jsx.js";
+import { getCurrentContextFrame, getVNodeContextFrame, markVNodeTreeWithContextFrame, withContext } from "../runtime/context.js";
+import { getDevValue, incDevCounter } from "../runtime/dev-namespace.js";
+import "./env.js";
+import { createMutableWrappedHandler, extractKey, getPassiveOptions, isSkippedProp, parseEventName, readElementClassName, tagNamesEqualIgnoreCase, writeElementClassName } from "./utils.js";
+import { keyedElements } from "./keyed.js";
+import { cleanupComponent, createComponentInstance, getCurrentInstance, mountInstanceInline, renderComponentInline, warnUnusedStateReads } from "../runtime/component.js";
+import { addDelegatedListener, getDelegatedHandlerForElement, getDelegatedHandlersForElement, isDelegatedEvent, isEventDelegationEnabled, removeDelegatedListener, updateDelegatedListener } from "../runtime/events.js";
+import { REACTIVE_CHILDREN_KEY, elementListeners, elementReactivePropsCleanup, removeAllListeners, removeElementListeners, removeElementReactiveProps, teardownNodeSubtree } from "./cleanup.js";
+import "../jsx-runtime.js";
+import { createChildScope, disposeChildScope, rerenderChildScope } from "../runtime/child-scope.js";
+import { isBenchMetricScopeActive, recordBenchCounter, recordBenchEvent, recordBenchTiming, withBenchMetricScope } from "../runtime/for-bench.js";
+import { clearForDomUpdateState, evaluateForState } from "../runtime/for.js";
+import { clearCaseDomUpdateState, clearShowDomUpdateState, evaluateCaseState, evaluateShowState } from "../runtime/control.js";
+import { reconcileKeyedChildren } from "./reconcile.js";
+import { isBulkTextFastPathEligible, performBulkTextReplace } from "./children.js";
+import { createFineGrainedEffect, markFineGrainedEffectsDirtySource } from "../runtime/effect.js";
+//#region src/renderer/dom.ts
+const reactivePropRegistry = /* @__PURE__ */ new Set();
+const controlBoundaryOwners = /* @__PURE__ */ new WeakMap();
+let reactiveChildScopeId = 0;
+function collectReactiveScalarSequenceValue(value, normalized) {
+	if (isFragmentVNode(value)) return collectReactiveScalarSequenceValue(value.props?.children ?? value.children, normalized);
+	if (Array.isArray(value)) {
+		for (const child of value) if (!collectReactiveScalarSequenceValue(child, normalized)) return false;
+		return true;
+	}
+	if (value === null || value === void 0 || value === false) return true;
+	if (typeof value === "string" || typeof value === "number") {
+		normalized.push(String(value));
+		return true;
+	}
+	return false;
+}
+function collectReactiveScalarChildSource(children, slots, state) {
+	if (isFragmentVNode(children)) return collectReactiveScalarChildSource(children.props?.children ?? children.children, slots, state);
+	if (Array.isArray(children)) {
+		for (const child of children) if (!collectReactiveScalarChildSource(child, slots, state)) return false;
+		return true;
+	}
+	if (children === null || children === void 0 || children === false) return true;
+	if (typeof children === "function") {
+		slots.push({
+			kind: "dynamic",
+			compute: children
+		});
+		state.hasDynamic = true;
+		return true;
+	}
+	if (typeof children === "string" || typeof children === "number") {
+		slots.push({
+			kind: "static",
+			value: String(children)
+		});
+		return true;
+	}
+	return false;
+}
+function getReactiveScalarChildSource(children) {
+	const slots = [];
+	const state = { hasDynamic: false };
+	if (!collectReactiveScalarChildSource(children, slots, state)) return null;
+	return state.hasDynamic ? slots : null;
+}
+function getSingleReactiveChildBoundarySource(children) {
+	if (isFragmentVNode(children)) return getSingleReactiveChildBoundarySource(children.props?.children ?? children.children);
+	if (Array.isArray(children)) {
+		if (children.length !== 1) return null;
+		return getSingleReactiveChildBoundarySource(children[0]);
+	}
+	if (typeof children === "function") return children;
+	return null;
+}
+function collectReactiveChildBoundarySequenceSource(children, slots, state) {
+	if (isFragmentVNode(children)) return collectReactiveChildBoundarySequenceSource(children.props?.children ?? children.children, slots, state);
+	if (Array.isArray(children)) {
+		for (const child of children) if (!collectReactiveChildBoundarySequenceSource(child, slots, state)) return false;
+		return true;
+	}
+	if (children === null || children === void 0 || children === false) return true;
+	if (typeof children === "function") {
+		slots.push({
+			kind: "dynamic",
+			compute: children
+		});
+		state.dynamicCount += 1;
+		return true;
+	}
+	if (typeof children === "string" || typeof children === "number") {
+		slots.push({
+			kind: "static-text",
+			value: String(children)
+		});
+		return true;
+	}
+	if (_isDOMElement(children)) {
+		slots.push({
+			kind: "static-node",
+			value: children
+		});
+		return true;
+	}
+	return false;
+}
+function getReactiveChildBoundarySequenceSource(children) {
+	const slots = [];
+	const state = { dynamicCount: 0 };
+	if (!collectReactiveChildBoundarySequenceSource(children, slots, state)) return null;
+	return state.dynamicCount >= 1 && slots.length > 1 ? slots : null;
+}
+function areReactiveChildBoundarySequenceSourcesEqual(previousSource, nextSource) {
+	if (!Array.isArray(previousSource) || previousSource.length !== nextSource.length) return false;
+	for (let index = 0; index < nextSource.length; index += 1) {
+		const previousSlot = previousSource[index];
+		const nextSlot = nextSource[index];
+		if (!previousSlot || previousSlot.kind !== nextSlot.kind) return false;
+		if (nextSlot.kind === "static-text") {
+			if (previousSlot.kind !== "static-text" || previousSlot.value !== nextSlot.value) return false;
+			continue;
+		}
+		if (nextSlot.kind === "static-node") {
+			if (previousSlot.kind !== "static-node" || previousSlot.value !== nextSlot.value) return false;
+			continue;
+		}
+		if (previousSlot.kind !== "dynamic" || previousSlot.compute !== nextSlot.compute) return false;
+	}
+	return true;
+}
+function cleanupDetachedComponentHost(host, retainedInstance) {
+	removeElementListeners(host);
+	removeElementReactiveProps(host);
+	const hostInstances = host.__ASKR_INSTANCES;
+	if (hostInstances && hostInstances.length > 0) for (const instance of hostInstances) {
+		if (instance === retainedInstance) continue;
+		cleanupComponent(instance);
+	}
+	else if (host.__ASKR_INSTANCE && host.__ASKR_INSTANCE !== retainedInstance) cleanupComponent(host.__ASKR_INSTANCE);
+	const descendants = host.querySelectorAll("*");
+	for (let index = 0; index < descendants.length; index += 1) {
+		const descendant = descendants[index];
+		removeElementListeners(descendant);
+		removeElementReactiveProps(descendant);
+		if (descendant.__ASKR_INSTANCES?.length) {
+			for (const instance of descendant.__ASKR_INSTANCES) {
+				if (instance === retainedInstance) continue;
+				cleanupComponent(instance);
+			}
+			try {
+				delete descendant.__ASKR_INSTANCES;
+			} catch {}
+		} else if (descendant.__ASKR_INSTANCE && descendant.__ASKR_INSTANCE !== retainedInstance) {
+			cleanupComponent(descendant.__ASKR_INSTANCE);
+			try {
+				delete descendant.__ASKR_INSTANCE;
+			} catch {}
+		}
+	}
+	try {
+		delete host.__ASKR_INSTANCE;
+		delete host.__ASKR_INSTANCES;
+		delete host.__ASKR_WRAPPER_HOST;
+	} catch {}
+}
+function canUpdateReactiveChildBoundarySequenceSource(previousSource, nextSource) {
+	if (!Array.isArray(previousSource) || previousSource.length !== nextSource.length) return false;
+	for (let index = 0; index < nextSource.length; index += 1) {
+		const previousSlot = previousSource[index];
+		const nextSlot = nextSource[index];
+		if (!previousSlot || previousSlot.kind !== nextSlot.kind) return false;
+		if (nextSlot.kind === "static-text") {
+			if (previousSlot.kind !== "static-text" || previousSlot.value !== nextSlot.value) return false;
+			continue;
+		}
+		if (nextSlot.kind === "static-node") {
+			if (previousSlot.kind !== "static-node" || previousSlot.value !== nextSlot.value) return false;
+		}
+	}
+	return true;
+}
+function areReactiveScalarChildSourcesEqual(previousSource, nextSource) {
+	if (!Array.isArray(previousSource) || previousSource.length !== nextSource.length) return false;
+	for (let index = 0; index < nextSource.length; index += 1) {
+		const previousSlot = previousSource[index];
+		const nextSlot = nextSource[index];
+		if (!previousSlot || previousSlot.kind !== nextSlot.kind) return false;
+		if (nextSlot.kind === "static") {
+			if (previousSlot.kind !== "static" || previousSlot.value !== nextSlot.value) return false;
+			continue;
+		}
+		if (previousSlot.kind !== "dynamic" || previousSlot.compute !== nextSlot.compute) return false;
+	}
+	return true;
+}
+function getOrCreateElementReactiveCleanupMap(el) {
+	let cleanupMap = elementReactivePropsCleanup.get(el);
+	if (!cleanupMap) {
+		cleanupMap = /* @__PURE__ */ new Map();
+		elementReactivePropsCleanup.set(el, cleanupMap);
+	}
+	return cleanupMap;
+}
+function normalizeReactiveScalarSequenceValues(values) {
+	const normalized = [];
+	for (const value of values) if (!collectReactiveScalarSequenceValue(value, normalized)) return null;
+	return normalized;
+}
+function normalizeOwnedReactiveTextValue(value) {
+	if (typeof value === "string" || typeof value === "number") return String(value);
+	return null;
+}
+function collectReactiveChildValuesAsVNodes(values, children) {
+	for (const value of values) collectReactiveChildBoundaryVNodes(value, children);
+}
+function materializeReactiveChildBoundaryNodes(value, parentNamespace) {
+	const nodes = [];
+	const dom = 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 syncReactiveScalarTextNodes(el, slotValues, values) {
+	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 host = createReactiveChildBoundaryHost(el);
+	for (let node = el.firstChild; node;) {
+		const next = node.nextSibling;
+		host.appendChild(node);
+		node = next;
+	}
+	updateElementChildren(host, slotValues);
+	syncReactiveChildExpectedNodes(el, Array.from(host.childNodes));
+}
+function trySyncScalarChildSequenceInPlace(el, children) {
+	const normalized = normalizeReactiveScalarSequenceValues(children);
+	if (!normalized) return false;
+	if (el.childNodes.length !== normalized.length) return false;
+	for (let index = 0; index < el.childNodes.length; index += 1) if (el.childNodes[index]?.nodeType !== Node.TEXT_NODE) return false;
+	syncReactiveScalarTextNodes(el, children, normalized);
+	return true;
+}
+function normalizeReactiveChildBoundaryVNode(value) {
+	if (!isFragmentVNode(value)) return value;
+	const children = normalizeComponentChildren(value);
+	if (children.length !== 1) return value;
+	return normalizeReactiveChildBoundaryVNode(children[0]);
+}
+function isSingleRootReactiveChildBoundaryValue(value) {
+	if (value === null || value === void 0 || value === false) return true;
+	if (Array.isArray(value)) return value.length === 1 && isSingleRootReactiveChildBoundaryValue(value[0]);
+	if (isFragmentVNode(value)) {
+		const children = normalizeComponentChildren(value);
+		return children.length === 1 && isSingleRootReactiveChildBoundaryValue(children[0]);
+	}
+	return true;
+}
+function collectReactiveChildBoundaryVNodes(value, children) {
+	if (value === null || value === void 0 || value === false) return;
+	if (Array.isArray(value)) {
+		for (const child of value) collectReactiveChildBoundaryVNodes(child, children);
+		return;
+	}
+	if (isFragmentVNode(value)) {
+		collectReactiveChildBoundaryVNodes(value.props?.children ?? value.children, children);
+		return;
+	}
+	children.push(value);
+}
+function createReactiveChildBoundaryHost(el) {
+	const ownerDocument = el.ownerDocument;
+	return el.namespaceURI === SVG_NAMESPACE ? ownerDocument.createElementNS(SVG_NAMESPACE, "g") : ownerDocument.createElement("div");
+}
+function disposeReactiveChildBoundaryNodes(nodes) {
+	for (const node of nodes) {
+		if (node.parentNode) node.parentNode.removeChild(node);
+		if (node instanceof Element) 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)) {
+			if (node instanceof Element) 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) {
+	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) {
+			if (dom instanceof Element) 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 host = createReactiveChildBoundaryHost(el);
+		for (const node of entry.nodes) host.appendChild(node);
+		updateElementChildren(host, nextChildren);
+		const nextNodes = Array.from(host.childNodes);
+		entry.scope.dom = 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;
+	}
+	const nextDom = syncForItemDom(el, entry.scope, entry.scope.vnode ?? null);
+	if (!nextDom) {
+		entry.nodes = [];
+		entry.scope.needsDomUpdate = false;
+		return entry.nodes;
+	}
+	entry.nodes = [nextDom];
+	entry.scope.needsDomUpdate = false;
+	return entry.nodes;
+}
+function syncReactiveChildSequenceNodes(el, entries) {
+	const expectedNodes = [];
+	for (const entry of entries) {
+		if (entry.kind === "static") {
+			expectedNodes.push(...entry.nodes);
+			continue;
+		}
+		expectedNodes.push(...commitReactiveChildBoundaryEntryNodes(el, entry));
+	}
+	syncReactiveChildExpectedNodes(el, expectedNodes);
+}
+function setupReactiveScalarChild(el, source) {
+	let currentSource = source;
+	if (source.length === 1 && source[0]?.kind === "dynamic") {
+		let ownedTextNode = el.childNodes.length === 1 && el.firstChild?.nodeType === Node.TEXT_NODE ? el.firstChild : null;
+		let effectHandle = createFineGrainedEffect({
+			lane: "reactive",
+			compute: () => {
+				const currentSlot = currentSource[0];
+				if (!currentSlot || currentSlot.kind !== "dynamic") throw new Error("[Askr] Direct reactive text bindings require a single dynamic slot.");
+				const rawValue = currentSlot.compute();
+				return normalizeOwnedReactiveTextValue(rawValue) ?? rawValue;
+			},
+			commit: (value) => {
+				const normalized = normalizeOwnedReactiveTextValue(value);
+				if (normalized === null) {
+					ownedTextNode = null;
+					updateElementChildren(el, value);
+					return;
+				}
+				if (!ownedTextNode || el.childNodes.length !== 1 || el.firstChild !== ownedTextNode) {
+					updateElementChildren(el, normalized);
+					ownedTextNode = el.childNodes.length === 1 && el.firstChild?.nodeType === Node.TEXT_NODE ? el.firstChild : null;
+				}
+				if (!ownedTextNode) return;
+				if (ownedTextNode.data !== normalized) {
+					ownedTextNode.data = normalized;
+					incDevCounter("textNodeWrites");
+				}
+			},
+			onError: (err) => {
+				if (getRuntimeEnv().NODE_ENV !== "production") logger.warn("[Askr] Reactive child update failed:", err);
+			}
+		});
+		return {
+			cleanup: () => {
+				effectHandle?.cleanup();
+				effectHandle = null;
+			},
+			updateFn: (nextSource) => {
+				if (!effectHandle) return;
+				currentSource = nextSource;
+				effectHandle.updateCompute(() => {
+					const currentSlot = currentSource[0];
+					if (!currentSlot || currentSlot.kind !== "dynamic") throw new Error("[Askr] Direct reactive text bindings require a single dynamic slot.");
+					const rawValue = currentSlot.compute();
+					return normalizeOwnedReactiveTextValue(rawValue) ?? rawValue;
+				});
+			}
+		};
+	}
+	let effectHandle = createFineGrainedEffect({
+		lane: "reactive",
+		compute: () => currentSource.map((slot) => slot.kind === "static" ? slot.value : slot.compute()),
+		commit: (values) => {
+			if (!Array.isArray(values)) throw new Error("[Askr] Reactive scalar children must evaluate to a slot array.");
+			const normalized = normalizeReactiveScalarSequenceValues(values);
+			if (normalized) {
+				syncReactiveScalarTextNodes(el, values, normalized);
+				return;
+			}
+			const nextChildren = [];
+			collectReactiveChildValuesAsVNodes(values, nextChildren);
+			const host = createReactiveChildBoundaryHost(el);
+			for (let node = el.firstChild; node;) {
+				const next = node.nextSibling;
+				host.appendChild(node);
+				node = next;
+			}
+			updateElementChildren(host, nextChildren);
+			syncReactiveChildExpectedNodes(el, Array.from(host.childNodes));
+		},
+		equals: (previousValue, nextValue) => {
+			if (!Array.isArray(previousValue) || !Array.isArray(nextValue)) return false;
+			const previousNormalized = normalizeReactiveScalarSequenceValues(previousValue);
+			const nextNormalized = normalizeReactiveScalarSequenceValues(nextValue);
+			if (!previousNormalized || !nextNormalized) return false;
+			if (previousNormalized.length !== nextNormalized.length) return false;
+			for (let index = 0; index < previousNormalized.length; index += 1) if (previousNormalized[index] !== nextNormalized[index]) return false;
+			return true;
+		},
+		onError: (err) => {
+			if (getRuntimeEnv().NODE_ENV !== "production") logger.warn("[Askr] Reactive child update failed:", err);
+		}
+	});
+	return {
+		cleanup: () => {
+			effectHandle?.cleanup();
+			effectHandle = null;
+		},
+		updateFn: (nextSource) => {
+			if (!effectHandle) return;
+			currentSource = nextSource;
+			effectHandle.updateCompute(() => currentSource.map((slot) => slot.kind === "static" ? slot.value : slot.compute()));
+		}
+	};
+}
+function setupReactiveChildBoundary(el, childFn) {
+	let currentChildFn = childFn;
+	const entry = {
+		scope: createChildScope(getCurrentInstance(), `__reactive-child__:${reactiveChildScopeId += 1}`, () => {
+			syncReactiveChildExpectedNodes(el, commitReactiveChildBoundaryEntryNodes(el, entry));
+		}),
+		nodes: []
+	};
+	entry.scope.render(() => normalizeReactiveChildBoundaryVNode(currentChildFn()));
+	syncReactiveChildExpectedNodes(el, commitReactiveChildBoundaryEntryNodes(el, entry));
+	return {
+		cleanup: () => {
+			const dom = entry.scope.dom;
+			const nodes = entry.nodes;
+			disposeChildScope(entry.scope);
+			entry.nodes = [];
+			if (nodes.length > 0) {
+				disposeReactiveChildBoundaryNodes(nodes);
+				return;
+			}
+			if (dom?.parentNode === el) {
+				if (dom instanceof Element) teardownNodeSubtree(dom);
+				el.removeChild(dom);
+			}
+		},
+		updateFn: (nextValue) => {
+			currentChildFn = nextValue;
+			rerenderChildScope(entry.scope);
+			syncReactiveChildExpectedNodes(el, commitReactiveChildBoundaryEntryNodes(el, entry));
+		}
+	};
+}
+function setupReactiveChildBoundarySequence(el, source) {
+	let currentSource = source;
+	const parentInstance = getCurrentInstance();
+	const entries = [];
+	const dynamicEntries = [];
+	if (!currentSource.some((slot) => slot.kind === "dynamic")) throw new Error("[Askr] Reactive child boundary sequence requires at least one dynamic slot.");
+	const syncSequence = () => {
+		syncReactiveChildSequenceNodes(el, entries);
+	};
+	const parentNamespace = el.namespaceURI === SVG_NAMESPACE ? SVG_NAMESPACE : void 0;
+	for (let index = 0; index < currentSource.length; index += 1) {
+		const slot = currentSource[index];
+		if (!slot) continue;
+		if (slot.kind === "static-text") {
+			entries.push({
+				kind: "static",
+				nodes: [document.createTextNode(slot.value)]
+			});
+			continue;
+		}
+		if (slot.kind === "static-node") {
+			entries.push({
+				kind: "static",
+				nodes: materializeReactiveChildBoundaryNodes(slot.value, parentNamespace)
+			});
+			continue;
+		}
+		const dynamicEntry = {
+			kind: "dynamic",
+			scope: createChildScope(parentInstance, `__reactive-child-seq__:${reactiveChildScopeId += 1}`, syncSequence),
+			nodes: []
+		};
+		entries.push(dynamicEntry);
+		dynamicEntries.push({
+			index,
+			entry: dynamicEntry
+		});
+	}
+	for (const dynamicEntry of dynamicEntries) dynamicEntry.entry.scope.render(() => normalizeReactiveChildBoundaryVNode(currentSource[dynamicEntry.index].compute()));
+	syncSequence();
+	return {
+		cleanup: () => {
+			for (const dynamicEntry of dynamicEntries) {
+				const dom = dynamicEntry.entry.scope.dom;
+				const nodes = dynamicEntry.entry.nodes;
+				disposeChildScope(dynamicEntry.entry.scope);
+				if (nodes.length > 0) {
+					disposeReactiveChildBoundaryNodes(nodes);
+					continue;
+				}
+				if (dom?.parentNode === el) {
+					if (dom instanceof Element) teardownNodeSubtree(dom);
+					el.removeChild(dom);
+				}
+			}
+			for (const entry of entries) if (entry.kind === "static") disposeReactiveChildBoundaryNodes(entry.nodes);
+		},
+		updateFn: (nextValue) => {
+			currentSource = nextValue;
+			for (const dynamicEntry of dynamicEntries) rerenderChildScope(dynamicEntry.entry.scope);
+			syncSequence();
+		}
+	};
+}
+function syncReactiveScalarChild(el, children) {
+	const reactiveChildSource = getReactiveScalarChildSource(children);
+	const reactiveChildBoundary = getSingleReactiveChildBoundarySource(children);
+	const reactiveChildBoundarySequence = getReactiveChildBoundarySequenceSource(children);
+	const existingReactiveEntry = elementReactivePropsCleanup.get(el)?.get(REACTIVE_CHILDREN_KEY);
+	if (!reactiveChildSource && !reactiveChildBoundary && !reactiveChildBoundarySequence) {
+		if (existingReactiveEntry) {
+			existingReactiveEntry.cleanup();
+			const cleanupMap = elementReactivePropsCleanup.get(el);
+			cleanupMap?.delete(REACTIVE_CHILDREN_KEY);
+			if (cleanupMap && cleanupMap.size === 0) elementReactivePropsCleanup.delete(el);
+		}
+		return false;
+	}
+	if (reactiveChildSource && !reactiveChildBoundarySequence) {
+		if (existingReactiveEntry && Array.isArray(existingReactiveEntry.fnRef) && areReactiveScalarChildSourcesEqual(existingReactiveEntry.fnRef, reactiveChildSource)) return true;
+		if (existingReactiveEntry?.updateFn && Array.isArray(existingReactiveEntry.fnRef)) {
+			existingReactiveEntry.updateFn(reactiveChildSource);
+			existingReactiveEntry.fnRef = reactiveChildSource;
+			return true;
+		}
+		existingReactiveEntry?.cleanup();
+		try {
+			const reactive = setupReactiveScalarChild(el, reactiveChildSource);
+			getOrCreateElementReactiveCleanupMap(el).set(REACTIVE_CHILDREN_KEY, {
+				cleanup: reactive.cleanup,
+				updateFn: (nextValue) => {
+					reactive.updateFn(nextValue);
+				},
+				fnRef: reactiveChildSource
+			});
+			return true;
+		} catch (error) {
+			if (!reactiveChildBoundary && !reactiveChildBoundarySequence) throw error;
+		}
+	}
+	if (reactiveChildBoundarySequence) {
+		if (existingReactiveEntry && Array.isArray(existingReactiveEntry.fnRef) && areReactiveChildBoundarySequenceSourcesEqual(existingReactiveEntry.fnRef, reactiveChildBoundarySequence)) return true;
+		if (existingReactiveEntry?.updateFn && Array.isArray(existingReactiveEntry.fnRef) && canUpdateReactiveChildBoundarySequenceSource(existingReactiveEntry.fnRef, reactiveChildBoundarySequence)) {
+			existingReactiveEntry.updateFn(reactiveChildBoundarySequence);
+			existingReactiveEntry.fnRef = reactiveChildBoundarySequence;
+			return true;
+		}
+		existingReactiveEntry?.cleanup();
+		const reactive = setupReactiveChildBoundarySequence(el, reactiveChildBoundarySequence);
+		getOrCreateElementReactiveCleanupMap(el).set(REACTIVE_CHILDREN_KEY, {
+			cleanup: reactive.cleanup,
+			updateFn: reactive.updateFn,
+			fnRef: reactiveChildBoundarySequence
+		});
+		return true;
+	}
+	if (existingReactiveEntry?.fnRef === reactiveChildBoundary) return true;
+	if (existingReactiveEntry?.updateFn && !Array.isArray(existingReactiveEntry.fnRef)) {
+		existingReactiveEntry.updateFn(reactiveChildBoundary);
+		existingReactiveEntry.fnRef = reactiveChildBoundary;
+		return true;
+	}
+	existingReactiveEntry?.cleanup();
+	if (!reactiveChildBoundary) return false;
+	const reactive = setupReactiveChildBoundary(el, reactiveChildBoundary);
+	getOrCreateElementReactiveCleanupMap(el).set(REACTIVE_CHILDREN_KEY, {
+		cleanup: reactive.cleanup,
+		updateFn: reactive.updateFn,
+		fnRef: reactiveChildBoundary
+	});
+	return true;
+}
+const vnodeComponentInstances = /* @__PURE__ */ new WeakMap();
+function getVNodeComponentInstance(node) {
+	if (typeof node !== "object" || node === null) return;
+	return vnodeComponentInstances.get(node) ?? node.__instance;
+}
+function setVNodeComponentInstance(node, instance) {
+	if (typeof node !== "object" || node === null) return;
+	const objectNode = node;
+	if (Object.prototype.hasOwnProperty.call(objectNode, "__instance")) try {
+		objectNode.__instance = instance;
+		return;
+	} catch {}
+	if (Object.isExtensible(objectNode)) try {
+		objectNode.__instance = instance;
+		return;
+	} catch {}
+	vnodeComponentInstances.set(objectNode, instance);
+}
+const IS_DOM_AVAILABLE = typeof document !== "undefined";
+const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+function resolveChildNamespace(type, parentNamespace) {
+	if (type === "svg") return SVG_NAMESPACE;
+	if (parentNamespace === SVG_NAMESPACE && type !== "foreignObject") return SVG_NAMESPACE;
+}
+function createElementForNamespace(type, parentNamespace) {
+	const namespace = resolveChildNamespace(type, parentNamespace);
+	return namespace ? document.createElementNS(namespace, type) : document.createElement(type);
+}
+function getHydrationSkipBoundary(el) {
+	return el.closest("[data-skip-hydrate=\"true\"]");
+}
+function isHydrationSkipped(el) {
+	return getHydrationSkipBoundary(el) !== null;
+}
+function clearHydrationDeferredSubtree(el) {
+	const boundary = getHydrationSkipBoundary(el);
+	if (!boundary) return;
+	if (boundary === el) {
+		removeAllListeners(el);
+		removeElementReactiveProps(el);
+	}
+}
+let fallbackComponentInstanceId = 0;
+function nextComponentInstanceId() {
+	const key = "__COMPONENT_INSTANCE_ID";
+	try {
+		incDevCounter(key);
+		const n = getDevValue(key);
+		if (typeof n === "number" && Number.isFinite(n)) return `comp-${n}`;
+	} catch {}
+	fallbackComponentInstanceId++;
+	return `comp-${fallbackComponentInstanceId}`;
+}
+/**
+* Add an event listener to an element with tracking
+* Uses event delegation when enabled (opt-out model)
+*/
+function addTrackedListener(el, eventName, handler) {
+	if (isEventDelegationEnabled() && isDelegatedEvent(eventName)) {
+		addDelegatedListener(el, eventName, handler, handler, void 0);
+		if (isBenchMetricScopeActive("coldCreate")) recordBenchCounter("listenerBindings");
+		return;
+	}
+	const options = getPassiveOptions(eventName);
+	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(eventName, {
+		handler: trackedHandler,
+		original: handler,
+		options,
+		isDelegated: false,
+		updateHandler: mutableHandler?.updateHandler
+	});
+	if (isBenchMetricScopeActive("coldCreate")) recordBenchCounter("listenerBindings");
+}
+function markReactivePropsDirtySource(source) {
+	markFineGrainedEffectsDirtySource(source);
+}
+/**
+* Set up a reactive prop that re-evaluates when its dependencies change
+* Returns a cleanup function to unsubscribe
+*/
+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");
+			applyPropValue(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);
+		}
+	});
+	if (isBenchMetricScopeActive("coldCreate")) recordBenchCounter("reactivePropsMounted");
+	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
+	};
+}
+/**
+* Apply a prop value to an element (helper for reactive props)
+*/
+function applyPropValue(el, key, value, tagName, previousValue, descriptor) {
+	if (value === void 0 || value === null || value === false) {
+		if (key === "class" || key === "className") {
+			const previousTokens = descriptor?.lastClassTokens;
+			if (previousTokens && previousTokens.length > 0) {
+				el.classList.remove(...previousTokens);
+				incrementPerfMetric("classListPatchOps");
+			} else writeElementClassName(el, "");
+			if (descriptor) descriptor.lastClassTokens = [];
+		} else if (key === "value") applyFormControlProp(el, key, "", tagName);
+		else if (key === "checked") applyFormControlProp(el, key, false, tagName);
+		else if (key === "style") applyStylePropValue(el, null);
+		else el.removeAttribute(key);
+		return;
+	}
+	if (key === "class" || key === "className") applyClassPropValue(el, value, previousValue, descriptor);
+	else if (key === "style") applyStylePropValue(el, value);
+	else if (key === "value" || key === "checked") applyFormControlProp(el, key, value, tagName);
+	else el.setAttribute(key, String(value));
+}
+function normalizeStylePropertyName(propertyName) {
+	if (propertyName.startsWith("--")) return propertyName;
+	return propertyName.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`);
+}
+function collectCurrentStyleEntries(el) {
+	const entries = /* @__PURE__ */ new Map();
+	const style = el.style;
+	if (!style) return entries;
+	for (let index = 0; index < style.length; index += 1) {
+		const propertyName = style.item(index);
+		entries.set(propertyName, style.getPropertyValue(propertyName));
+	}
+	return entries;
+}
+function normalizeStyleEntries(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const entries = /* @__PURE__ */ new Map();
+	for (const [key, entryValue] of Object.entries(value)) {
+		if (entryValue === void 0 || entryValue === null || entryValue === false) continue;
+		entries.set(normalizeStylePropertyName(key), String(entryValue));
+	}
+	return entries;
+}
+function applyStylePropValue(el, value) {
+	const style = el.style;
+	if (!style) {
+		if (value === null || value === void 0 || value === false) {
+			el.removeAttribute("style");
+			return;
+		}
+		el.setAttribute("style", String(value));
+		return;
+	}
+	if (value === null || value === void 0 || value === false) {
+		if (!el.getAttribute("style")) {
+			incrementPerfMetric("skippedDomPropWrites");
+			return;
+		}
+		style.cssText = "";
+		el.removeAttribute("style");
+		return;
+	}
+	if (typeof value === "string") {
+		if ((el.getAttribute("style") ?? "") === value) {
+			incrementPerfMetric("skippedDomPropWrites");
+			return;
+		}
+		style.cssText = value;
+		return;
+	}
+	const nextEntries = normalizeStyleEntries(value);
+	if (!nextEntries) {
+		const nextText = String(value);
+		if ((el.getAttribute("style") ?? "") === nextText) {
+			incrementPerfMetric("skippedDomPropWrites");
+			return;
+		}
+		style.cssText = nextText;
+		return;
+	}
+	const previousEntries = collectCurrentStyleEntries(el);
+	let didWrite = false;
+	for (const [propertyName] of previousEntries) {
+		if (nextEntries.has(propertyName)) continue;
+		style.removeProperty(propertyName);
+		didWrite = true;
+	}
+	for (const [propertyName, propertyValue] of nextEntries) {
+		if (previousEntries.get(propertyName) === propertyValue) continue;
+		style.setProperty(propertyName, propertyValue);
+		didWrite = true;
+	}
+	if (!didWrite) incrementPerfMetric("skippedDomPropWrites");
+}
+function tokenizeClassValue(value) {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return [];
+	return trimmed.split(/\s+/);
+}
+function patchClassList(el, previousTokens, nextTokens) {
+	if (previousTokens.length === nextTokens.length) {
+		let identical = true;
+		for (let index = 0; index < previousTokens.length; index += 1) if (previousTokens[index] !== nextTokens[index]) {
+			identical = false;
+			break;
+		}
+		if (identical) return;
+	}
+	if (previousTokens.length === 0) {
+		if (nextTokens.length === 0) return;
+		el.classList.add(...nextTokens);
+		incrementPerfMetric("classListPatchOps");
+		return;
+	}
+	if (nextTokens.length === 0) {
+		el.classList.remove(...previousTokens);
+		incrementPerfMetric("classListPatchOps");
+		return;
+	}
+	if (previousTokens.length === 1 && nextTokens.length === 1) {
+		el.classList.remove(previousTokens[0]);
+		el.classList.add(nextTokens[0]);
+		incrementPerfMetric("classListPatchOps");
+		return;
+	}
+	const nextSet = new Set(nextTokens);
+	const previousSet = new Set(previousTokens);
+	for (const token of previousTokens) if (!nextSet.has(token)) el.classList.remove(token);
+	for (const token of nextTokens) if (!previousSet.has(token)) el.classList.add(token);
+	incrementPerfMetric("classListPatchOps");
+}
+function applyClassPropValue(el, value, previousValue, descriptor) {
+	const nextString = String(value);
+	const nextTokens = tokenizeClassValue(nextString);
+	const previousTokens = descriptor?.lastClassTokens ?? tokenizeClassValue(previousValue);
+	if (nextTokens && previousTokens) {
+		patchClassList(el, previousTokens, nextTokens);
+		if (descriptor) descriptor.lastClassTokens = nextTokens;
+		return;
+	}
+	writeElementClassName(el, nextString);
+	if (descriptor) descriptor.lastClassTokens = nextTokens;
+}
+/**
+* Apply attributes and event listeners to an element from props
+*/
+function applyPropsToElement(el, props, tagName) {
+	if (isHydrationSkipped(el)) return;
+	for (const key in props) {
+		const value = props[key];
+		if (key === "ref") {
+			applyRef(el, value);
+			continue;
+		}
+		if (isSkippedProp(key)) continue;
+		if (value === void 0 || value === null || value === false) continue;
+		const eventName = parseEventName(key);
+		if (eventName) {
+			addTrackedListener(el, eventName, value);
+			continue;
+		}
+		if (typeof value === "function" && !eventName && key !== "ref") {
+			const reactive = setupReactiveProp(el, key, value, tagName);
+			if (!elementReactivePropsCleanup.has(el)) elementReactivePropsCleanup.set(el, /* @__PURE__ */ new Map());
+			elementReactivePropsCleanup.get(el).set(key, {
+				cleanup: reactive.cleanup,
+				updateFn: (nextValue) => {
+					reactive.updateFn(nextValue);
+				},
+				fnRef: value
+			});
+			continue;
+		}
+		if (key === "class" || key === "className") writeElementClassName(el, String(value));
+		else if (key === "style") applyStylePropValue(el, value);
+		else if (key === "value" || key === "checked") applyFormControlProp(el, key, value, tagName);
+		else el.setAttribute(key, String(value));
+	}
+}
+function applyRef(el, ref) {
+	const r = ref;
+	if (!r) return;
+	if (typeof r === "function") {
+		r(el);
+		return;
+	}
+	if (Object.isExtensible(r)) r.current = el;
+}
+function getRenderedAttributeName(el, propName) {
+	let attributeName = propName;
+	if (propName === "className") attributeName = "class";
+	else if (propName === "htmlFor") attributeName = "for";
+	return el.namespaceURI === SVG_NAMESPACE ? attributeName : attributeName.toLowerCase();
+}
+function removeStaleAttributes(el, vnode, props) {
+	const desiredAttributes = /* @__PURE__ */ new Set();
+	if (extractKey(vnode) !== void 0) desiredAttributes.add("data-key");
+	for (const propName in props) {
+		if (isSkippedProp(propName)) continue;
+		if (parseEventName(propName)) continue;
+		const value = props[propName];
+		if (value === void 0 || value === null || value === false) continue;
+		desiredAttributes.add(getRenderedAttributeName(el, propName));
+	}
+	for (const attribute of Array.from(el.attributes)) if (!desiredAttributes.has(getRenderedAttributeName(el, attribute.name))) el.removeAttribute(attribute.name);
+}
+/**
+* Apply value/checked props to form controls
+*/
+function applyFormControlProp(el, key, value, tagName) {
+	if (key === "value") if (tagNamesEqualIgnoreCase(tagName, "input") || tagNamesEqualIgnoreCase(tagName, "textarea") || tagNamesEqualIgnoreCase(tagName, "select")) {
+		el.value = String(value);
+		el.setAttribute("value", String(value));
+	} else el.setAttribute("value", String(value));
+	else if (key === "checked") if (tagNamesEqualIgnoreCase(tagName, "input")) {
+		const checked = Boolean(value);
+		el.checked = checked;
+		if (checked) el.setAttribute("checked", "");
+		else el.removeAttribute("checked");
+	} else if (value) el.setAttribute("checked", "");
+	else el.removeAttribute("checked");
+}
+/**
+* Materialize vnode key as data-key attribute
+*/
+function materializeKey(el, vnode, props) {
+	const rawKey = vnode.key ?? props?.key;
+	const vnodeKey = rawKey === null || rawKey === void 0 ? void 0 : typeof rawKey === "symbol" ? String(rawKey) : rawKey;
+	if (vnodeKey !== void 0) {
+		const nextKey = String(vnodeKey);
+		if (el.getAttribute("data-key") !== nextKey) el.setAttribute("data-key", nextKey);
+	}
+}
+function inheritComponentKey(target, source) {
+	const inheritedKey = extractKey(source);
+	if (inheritedKey === void 0 || extractKey(target) !== void 0) return target;
+	target.key = inheritedKey;
+	if (typeof target.type === "string") {
+		if (!target.props) target.props = {};
+		const props = target.props;
+		if (props["data-key"] === void 0) props["data-key"] = String(inheritedKey);
+	}
+	return target;
+}
+/**
+* Warn about missing keys on dynamic lists (dev only)
+*/
+function warnMissingKeys(children) {
+	if (getRuntimeEnv().NODE_ENV === "production") return;
+	let hasElements = false;
+	let hasKeys = false;
+	for (const item of children) if (typeof item === "object" && item !== null && "type" in item) {
+		if (item.type === __FOR_BOUNDARY__) continue;
+		hasElements = true;
+		if ((item.key ?? item.props?.key) !== void 0) {
+			hasKeys = true;
+			break;
+		}
+	}
+	if (hasElements && !hasKeys) {
+		const inst = getCurrentInstance();
+		const warnings = inst ? inst.devWarningsEmitted ??= /* @__PURE__ */ new Set() : null;
+		if (warnings?.has("missing-keys")) return;
+		warnings?.add("missing-keys");
+		try {
+			const name = inst?.fn?.name || "<anonymous>";
+			logger.warn(`Missing keys on dynamic lists in ${name}. Each child in a list should have a unique "key" prop.`);
+		} catch {
+			logger.warn("Missing keys on dynamic lists. Each child in a list should have a unique \"key\" prop.");
+		}
+	}
+}
+function hasStaticChildrenMarker(children) {
+	return children[STATIC_CHILDREN] === true;
+}
+function maybeWarnMissingKeys(children) {
+	if (!hasStaticChildrenMarker(children)) warnMissingKeys(children);
+}
+/**
+* Create a DOM node from a VNode
+*/
+function createDOMNode(node, parentNamespace) {
+	if (!IS_DOM_AVAILABLE) {
+		if (getRuntimeEnv().NODE_ENV !== "production") try {
+			logger.warn("[Askr] createDOMNode called in non-DOM environment");
+		} catch {}
+		return null;
+	}
+	if (typeof node === "string") {
+		if (isBenchMetricScopeActive("coldCreate")) recordBenchCounter("domNodesCreated");
+		return document.createTextNode(node);
+	}
+	if (typeof node === "number") {
+		if (isBenchMetricScopeActive("coldCreate")) recordBenchCounter("domNodesCreated");
+		return document.createTextNode(String(node));
+	}
+	if (!node) return null;
+	if (Array.isArray(node)) {
+		maybeWarnMissingKeys(node);
+		const fragment = document.createDocumentFragment();
+		for (const child of node) {
+			const dom = createDOMNode(child, parentNamespace);
+			if (dom) fragment.appendChild(dom);
+		}
+		return fragment;
+	}
+	if (typeof node === "object" && node !== null && "type" in node) {
+		const type = node.type;
+		const props = node.props || {};
+		if (typeof type === "string") return createIntrinsicElement(node, type, props, parentNamespace);
+		if (typeof type === "function") return createComponentElement(node, type, props, parentNamespace);
+		if (type === __FOR_BOUNDARY__) return createForBoundary(node, props, parentNamespace);
+		if (typeof type === "symbol" && (type === Fragment || String(type) === "Symbol(Fragment)")) return createFragmentElement(node, props, parentNamespace);
+	}
+	return null;
+}
+function tryGetStaticCreateChildShape(children) {
+	if (children === null || children === void 0 || children === false) return { textContent: null };
+	if (typeof children === "string" || typeof children === "number") return { textContent: String(children) };
+	if (Array.isArray(children) && children.length === 1) {
+		const child = children[0];
+		if (child === null || child === void 0 || child === false) return { textContent: null };
+		if (typeof child === "string" || typeof child === "number") return { textContent: String(child) };
+	}
+	return null;
+}
+function isStaticCreateScalarValue(value) {
+	const valueType = typeof value;
+	return valueType === "string" || valueType === "number" || valueType === "boolean";
+}
+function tryGetStaticCreateFastPathShape(props, children) {
+	const childShape = tryGetStaticCreateChildShape(children);
+	if (!childShape) return null;
+	for (const key in props) {
+		if (key === "ref") return null;
+		if (isSkippedProp(key)) continue;
+		const value = props[key];
+		if (value === void 0 || value === null || value === false) continue;
+		if (parseEventName(key) || !isStaticCreateScalarValue(value)) return null;
+	}
+	return childShape;
+}
+function applyStaticScalarPropsToElement(el, props) {
+	for (const key in props) {
+		if (isSkippedProp(key)) continue;
+		const value = props[key];
+		if (value === void 0 || value === null || value === false) continue;
+		if (key === "class" || key === "className") writeElementClassName(el, String(value));
+		else if (key === "style") applyStylePropValue(el, value);
+		else if (key === "value" || key === "checked") el[key] = value;
+		else el.setAttribute(key, String(value));
+	}
+}
+/**
+* Create an intrinsic DOM element (div, span, etc.)
+*/
+function createIntrinsicElement(node, type, props, parentNamespace) {
+	const children = props.children ?? node.children;
+	const elementNamespace = resolveChildNamespace(type, parentNamespace);
+	const el = createElementForNamespace(type, parentNamespace);
+	if (isBenchMetricScopeActive("coldCreate")) recordBenchCounter("domNodesCreated");
+	materializeKey(el, node, props);
+	const staticCreateFastPath = tryGetStaticCreateFastPathShape(props, children);
+	if (staticCreateFastPath) {
+		applyStaticScalarPropsToElement(el, props);
+		if (staticCreateFastPath.textContent !== null) {
+			el.textContent = staticCreateFastPath.textContent;
+			if (isBenchMetricScopeActive("coldCreate")) recordBenchCounter("domNodesCreated");
+		}
+		return el;
+	}
+	applyPropsToElement(el, props, type);
+	if (children !== null && children !== void 0) {
+		const controlBoundaryVNode = getDirectControlBoundaryVNode(children);
+		if (controlBoundaryVNode) {
+			const controlState = getControlBoundaryState(controlBoundaryVNode);
+			if (!controlState) throw new Error("[createIntrinsicElement] Control boundary missing internal state");
+			registerControlBoundaryCommitOwner(el, controlState);
+		}
+		if (syncReactiveScalarChild(el, children)) return el;
+		if (Array.isArray(children)) {
+			maybeWarnMissingKeys(children);
+			if (children.length > 1) {
+				const childFrag = document.createDocumentFragment();
+				for (const child of children) {
+					const dom = createDOMNode(child, elementNamespace);
+					if (dom) childFrag.appendChild(dom);
+				}
+				el.appendChild(childFrag);
+			} else if (children.length === 1) {
+				const dom = createDOMNode(children[0], elementNamespace);
+				if (dom) el.appendChild(dom);
+			}
+		} else {
+			const dom = createDOMNode(children, elementNamespace);
+			if (dom) el.appendChild(dom);
+		}
+	}
+	return el;
+}
+function findHostInstanceByType(host, type) {
+	const instances = host.__ASKR_INSTANCES;
+	if (instances && instances.length > 0) for (let index = instances.length - 1; index >= 0; index -= 1) {
+		const instance = instances[index];
+		if (instance.fn === type) return instance;
+	}
+	return host.__ASKR_INSTANCE?.fn === type ? host.__ASKR_INSTANCE : null;
+}
+function materializeComponentResultNode(childInstance, result, parentNamespace) {
+	const dom = createDOMNode(result, parentNamespace);
+	if (dom instanceof Element) {
+		mountInstanceInline(childInstance, dom);
+		return dom;
+	}
+	if (!dom) {
+		const placeholder = document.createComment("");
+		try {
+			placeholder.__ASKR_INSTANCE = childInstance;
+		} catch {}
+		childInstance._placeholder = placeholder;
+		childInstance.mounted = true;
+		childInstance.notifyUpdate = childInstance._enqueueRun;
+		childInstance.target = null;
+		return placeholder;
+	}
+	const host = document.createElement("div");
+	host.appendChild(dom);
+	host.__ASKR_WRAPPER_HOST = true;
+	mountInstanceInline(childInstance, host);
+	return host;
+}
+function resolveNestedComponentResult(result, snapshot) {
+	let currentResult = result;
+	let activeSnapshot = snapshot;
+	let depth = 0;
+	while (_isDOMElement(currentResult) && typeof currentResult.type === "function" && depth < 16) {
+		const nestedSnapshot = getVNodeContextFrame(currentResult) ?? activeSnapshot;
+		const nestedInstance = createComponentInstance(nextComponentInstanceId(), currentResult.type, currentResult.props ?? {}, null);
+		if (nestedSnapshot) nestedInstance.ownerFrame = nestedSnapshot;
+		const nextResult = withContext(nestedSnapshot ?? null, () => renderComponentInline(nestedInstance));
+		cleanupComponent(nestedInstance);
+		if (nextResult instanceof Promise) throw new Error("Async components are not supported. Components must return synchronously.");
+		activeSnapshot = nestedSnapshot ?? null;
+		currentResult = nextResult;
+		depth += 1;
+	}
+	return currentResult;
+}
+function resolveWrapperHostResult(host, result, snapshot) {
+	let currentResult = result;
+	let activeSnapshot = snapshot;
+	let depth = 0;
+	while (_isDOMElement(currentResult) && typeof currentResult.type === "function" && depth < 16) {
+		const nestedSnapshot = getVNodeContextFrame(currentResult) ?? activeSnapshot;
+		const nestedInstance = findHostInstanceByType(host, currentResult.type);
+		if (!nestedInstance) break;
+		nestedInstance.props = (currentResult.props ?? {}) || {};
+		if (nestedSnapshot) nestedInstance.ownerFrame = nestedSnapshot;
+		const nextResult = withContext(nestedSnapshot ?? null, () => renderComponentInline(nestedInstance));
+		if (nextResult instanceof Promise) throw new Error("Async components are not supported. Components must return synchronously.");
+		warnUnusedStateReads(nestedInstance);
+		activeSnapshot = nestedSnapshot ?? null;
+		currentResult = nextResult;
+		depth += 1;
+	}
+	return markVNodeTreeWithContextFrame(currentResult, activeSnapshot);
+}
+function isFragmentVNode(node) {
+	return _isDOMElement(node) && typeof node.type === "symbol" && (node.type === Fragment || String(node.type) === "Symbol(askr.fragment)");
+}
+function normalizeComponentChildren(result) {
+	if (result === null || result === void 0 || result === false) return [];
+	if (Array.isArray(result)) return result;
+	if (isFragmentVNode(result)) {
+		const children = result.props?.children ?? result.children ?? [];
+		return Array.isArray(children) ? children : [children];
+	}
+	return [result];
+}
+function syncComponentElement(currentDom, node, type, props, parentNamespace) {
+	const existingHost = currentDom instanceof Element ? currentDom : null;
+	const existingInstance = existingHost ? findHostInstanceByType(existingHost, type) : null;
+	if (!existingHost || !existingInstance || existingInstance.fn !== type) return null;
+	const snapshot = getVNodeContextFrame(node) || getCurrentContextFrame() || existingInstance.ownerFrame || null;
+	existingInstance.props = props || {};
+	if (snapshot) existingInstance.ownerFrame = snapshot;
+	const result = withContext(snapshot, () => renderComponentInline(existingInstance));
+	if (result instanceof Promise) throw new Error("Async components are not supported. Components must return synchronously.");
+	const scopedResult = markVNodeTreeWithContextFrame(result, snapshot ?? null);
+	if (existingHost.__ASKR_WRAPPER_HOST) {
+		updateElementChildren(existingHost, normalizeComponentChildren(resolveWrapperHostResult(existingHost, scopedResult, snapshot ?? null)));
+		warnUnusedStateReads(existingInstance);
+		return existingHost;
+	}
+	if (scopedResult && typeof scopedResult === "object" && "type" in scopedResult && typeof scopedResult.type === "string" && tagNamesEqualIgnoreCase(existingHost.tagName, scopedResult.type)) {
+		withContext(snapshot, () => {
+			updateElementFromVnode(existingHost, inheritComponentKey(scopedResult, node), true);
+			materializeKey(existingHost, node, props);
+		});
+		warnUnusedStateReads(existingInstance);
+		return existingHost;
+	}
+	const resolvedResult = resolveNestedComponentResult(scopedResult, snapshot ?? null);
+	if (_isDOMElement(resolvedResult) && typeof resolvedResult.type === "string" && tagNamesEqualIgnoreCase(existingHost.tagName, resolvedResult.type)) {
+		withContext(snapshot, () => {
+			updateElementFromVnode(existingHost, inheritComponentKey(resolvedResult, node), true);
+			materializeKey(existingHost, node, props);
+		});
+		warnUnusedStateReads(existingInstance);
+		return existingHost;
+	}
+	const nextDom = materializeComponentResultNode(existingInstance, scopedResult, parentNamespace);
+	if (nextDom !== existingHost && existingHost.parentNode) {
+		existingHost.parentNode.replaceChild(nextDom, existingHost);
+		cleanupDetachedComponentHost(existingHost, existingInstance);
+	}
+	warnUnusedStateReads(existingInstance);
+	return nextDom;
+}
+function createComponentElement(node, type, props, parentNamespace) {
+	const snapshot = getVNodeContextFrame(node) || getCurrentContextFrame();
+	const componentFn = type;
+	if (componentFn.constructor.name === "AsyncFunction") throw new Error("Async components are not supported. Use resource() for async work.");
+	let childInstance = getVNodeComponentInstance(node);
+	if (!childInstance) {
+		childInstance = createComponentInstance(nextComponentInstanceId(), componentFn, props || {}, null);
+		setVNodeComponentInstance(node, childInstance);
+	}
+	childInstance.props = props || {};
+	if (snapshot) childInstance.ownerFrame = snapshot;
+	const result = withContext(snapshot, () => renderComponentInline(childInstance));
+	if (result instanceof Promise) throw new Error("Async components are not supported. Components must return synchronously.");
+	const scopedResult = markVNodeTreeWithContextFrame(result, snapshot ?? null);
+	const dom = withContext(snapshot, () => materializeComponentResultNode(childInstance, scopedResult, parentNamespace));
+	warnUnusedStateReads(childInstance);
+	if (dom instanceof Element) materializeKey(dom, node, props);
+	return dom;
+}
+/**
+* Create a document fragment from Fragment vnode
+*/
+function createFragmentElement(node, props, parentNamespace) {
+	const fragment = document.createDocumentFragment();
+	const children = props.children || node.children;
+	if (children) if (Array.isArray(children)) {
+		maybeWarnMissingKeys(children);
+		for (const child of children) {
+			const dom = createDOMNode(child, parentNamespace);
+			if (dom) fragment.appendChild(dom);
+		}
+	} else {
+		const dom = createDOMNode(children, parentNamespace);
+		if (dom) fragment.appendChild(dom);
+	}
+	return fragment;
+}
+/**
+* Check if a cached DOM node can be reused for a given vnode.
+*
+* Returns true if shape has changed (i.e., DOM cannot be reused).
+* Structural check: compares DOM tagName with vnode type.
+* Do NOT rely on vnode identity (===) — vnodes are mutable.
+*/
+function checkVNodeShapeChanged(dom, vnode) {
+	if (!_isDOMElement(vnode)) return true;
+	if (!(dom instanceof Element)) return true;
+	const vnodeType = vnode.type;
+	if (typeof vnodeType !== "string") return true;
+	return dom.tagName.toLowerCase() !== vnodeType.toLowerCase();
+}
+function materializeChildScopeDom(vnode, parentNamespace) {
+	if (vnode === null || vnode === void 0 || vnode === false) return document.createComment("");
+	const dom = createDOMNode(vnode, parentNamespace);
+	if (!(dom instanceof DocumentFragment)) return dom;
+	const firstChild = dom.firstChild;
+	const secondChild = firstChild?.nextSibling ?? null;
+	if (!firstChild) return document.createComment("");
+	if (secondChild) throw new Error("[askr] Child scopes must render a single DOM root node.");
+	return firstChild;
+}
+function evaluateControlBoundaryState(controlState) {
+	if (controlState.kind === "for") return evaluateForState(controlState);
+	if (controlState.kind === "show") return evaluateShowState(controlState);
+	return evaluateCaseState(controlState);
+}
+function clearControlBoundaryDomUpdateState(controlState) {
+	if (controlState.kind === "for") {
+		clearForDomUpdateState(controlState);
+		return;
+	}
+	if (controlState.kind === "show") {
+		clearShowDomUpdateState(controlState);
+		return;
+	}
+	clearCaseDomUpdateState(controlState);
+}
+function getControlBoundaryState(node) {
+	return node._controlState ?? node._forState ?? null;
+}
+function getDirectControlBoundaryVNode(children) {
+	if (!Array.isArray(children) && _isDOMElement(children) && children.type === __FOR_BOUNDARY__) return children;
+	if (Array.isArray(children) && children.length === 1 && _isDOMElement(children[0]) && children[0].type === __FOR_BOUNDARY__) return children[0];
+	return null;
+}
+function getControlBoundaryCommitChildren(controlState) {
+	if (controlState.kind === "for" && controlState._needsSourceReconcile) return evaluateForState(controlState);
+	if (controlState.kind !== "for") {
+		const activeVNode = controlState.activeScope?.vnode;
+		return activeVNode == null || activeVNode === false ? [] : [activeVNode];
+	}
+	if (controlState.orderedKeys.length === 0) {
+		const fallbackVNode = controlState.fallbackScope?.vnode;
+		return fallbackVNode == null || fallbackVNode === false ? [] : [fallbackVNode];
+	}
+	const childrenVNodes = [];
+	for (let index = 0; index < controlState.orderedKeys.length; index += 1) {
+		const itemKey = controlState.orderedKeys[index];
+		const itemInstance = controlState.items.get(itemKey);
+		childrenVNodes.push(itemInstance?.scope.vnode ?? null);
+	}
+	return childrenVNodes;
+}
+function clearControlBoundaryCommitOwner(parent) {
+	const owner = controlBoundaryOwners.get(parent);
+	if (owner) {
+		owner._enqueueBoundaryCommit = null;
+		owner._hasPendingBoundaryCommit = false;
+	}
+	controlBoundaryOwners.delete(parent);
+}
+function registerControlBoundaryCommitOwner(parent, controlState) {
+	const previousOwner = controlBoundaryOwners.get(parent);
+	if (previousOwner && previousOwner !== controlState) {
+		previousOwner._enqueueBoundaryCommit = null;
+		previousOwner._hasPendingBoundaryCommit = false;
+	}
+	controlBoundaryOwners.set(parent, controlState);
+	controlState._enqueueBoundaryCommit = () => {
+		if (controlState._hasPendingBoundaryCommit) return;
+		controlState._hasPendingBoundaryCommit = true;
+		globalScheduler.enqueue(() => {
+			controlState._hasPendingBoundaryCommit = false;
+			if (controlBoundaryOwners.get(parent) !== controlState) return;
+			commitForBoundaryChildren(parent, controlState, getControlBoundaryCommitChildren(controlState));
+		});
+	};
+}
+/**
+* Create DOM from For boundary - evaluates list and renders items
+*
+* CRITICAL INVARIANT:
+* DOM order MUST be reconstructed from the current vnode list on every render.
+* Reusing DOM nodes never implies preserving their position.
+*
+* This function ALWAYS returns a fragment whose child order exactly matches
+* the evaluated vnode list, even when all DOM nodes are reused.
+* Appending an existing node to the fragment is how we express reordering
+* (per DOM spec, appendChild moves already-attached nodes).
+*
+* Do NOT:
+* - Skip appending based on parentElement or existing attachment
+* - Rely on vnode identity (===) to decide DOM reuse (vnodes are mutable)
+* - Introduce fast-paths that might skip DOM reconstruction
+*/
+function createForBoundary(node, props, parentNamespace) {
+	const controlState = getControlBoundaryState(node);
+	if (!controlState) {
+		if (getRuntimeEnv().NODE_ENV !== "production") logger.warn("[Askr] Control boundary missing state");
+		return document.createDocumentFragment();
+	}
+	const childrenVNodes = evaluateControlBoundaryState(controlState);
+	const fragment = document.createDocumentFragment();
+	if (controlState.kind !== "for") {
+		const activeScope = controlState.activeScope;
+		const vnode = childrenVNodes[0];
+		if (activeScope && vnode !== void 0) {
+			const dom = materializeChildScopeDom(vnode, parentNamespace);
+			activeScope.dom = dom ?? void 0;
+			if (dom) fragment.appendChild(dom);
+		}
+		clearControlBoundaryDomUpdateState(controlState);
+		return fragment;
+	}
+	const forState = controlState;
+	if (forState.orderedKeys.length === 0) {
+		const fallbackScope = forState.fallbackScope;
+		const fallbackVNode = childrenVNodes[0];
+		if (fallbackScope && fallbackVNode !== void 0) {
+			const dom = materializeChildScopeDom(fallbackVNode, parentNamespace);
+			fallbackScope.dom = dom ?? void 0;
+			if (dom) fragment.appendChild(dom);
+		}
+		clearControlBoundaryDomUpdateState(controlState);
+		return fragment;
+	}
+	for (let i = 0; i < childrenVNodes.length; i++) {
+		const childVNode = childrenVNodes[i];
+		const itemKey = forState.orderedKeys[i];
+		const itemInstance = itemKey != null ? forState.items.get(itemKey) : null;
+		let dom = null;
+		if (itemInstance && itemInstance.scope.dom) {
+			const cachedDom = itemInstance.scope.dom;
+			if (!checkVNodeShapeChanged(cachedDom, childVNode)) dom = cachedDom;
+		}
+		if (!dom) {
+			dom = materializeChildScopeDom(childVNode, parentNamespace);
+			if (itemInstance) itemInstance.scope.dom = dom ?? void 0;
+		}
+		if (dom) fragment.appendChild(dom);
+	}
+	clearControlBoundaryDomUpdateState(controlState);
+	return fragment;
+}
+function syncForItemDom(parent, scope, vnode) {
+	let dom = scope.dom ?? null;
+	const parentNamespace = parent.namespaceURI === SVG_NAMESPACE ? SVG_NAMESPACE : void 0;
+	if (dom && !scope.needsDomUpdate) return dom;
+	if (_isDOMElement(vnode) && typeof vnode.type === "function") {
+		const syncedComponentDom = syncComponentElement(dom, vnode, vnode.type, vnode.props ?? {}, parentNamespace);
+		if (syncedComponentDom) {
+			scope.dom = syncedComponentDom ?? void 0;
+			return syncedComponentDom;
+		}
+	}
+	if (!dom) {
+		dom = materializeChildScopeDom(vnode, parentNamespace);
+		scope.dom = dom ?? void 0;
+		return dom;
+	}
+	if (dom.nodeType === 3 && (typeof vnode === "string" || typeof vnode === "number")) {
+		dom.data = String(vnode);
+		return dom;
+	}
+	if (dom.nodeType === 8 && (vnode === null || vnode === void 0 || vnode === false)) return dom;
+	if (dom instanceof Element && _isDOMElement(vnode) && typeof vnode.type === "string" && tagNamesEqualIgnoreCase(dom.tagName, vnode.type)) {
+		updateElementFromVnode(dom, vnode, true);
+		return dom;
+	}
+	const nextDom = materializeChildScopeDom(vnode, parentNamespace);
+	if (!nextDom) {
+		if (dom.parentNode === parent) dom.parentNode.removeChild(dom);
+		scope.dom = void 0;
+		return null;
+	}
+	if (dom.parentNode === parent) parent.replaceChild(nextDom, dom);
+	if (dom instanceof Element) teardownNodeSubtree(dom);
+	scope.dom = nextDom;
+	return nextDom;
+}
+function normalizeStableIntrinsicChildren(children) {
+	if (children === null || children === void 0 || children === false) return [];
+	return Array.isArray(children) ? children : [children];
+}
+function getStableIntrinsicChildren(vnode) {
+	return normalizeStableIntrinsicChildren(vnode.children || vnode.props?.children);
+}
+function patchStableIntrinsicText(domNode, nextVNode) {
+	if (domNode.nodeType !== 3 || typeof nextVNode !== "string" && typeof nextVNode !== "number") return false;
+	const nextText = String(nextVNode);
+	const textNode = domNode;
+	if (textNode.data !== nextText) {
+		recordBenchEvent("domTextSet");
+		textNode.data = nextText;
+	}
+	return true;
+}
+function patchStableIntrinsicElement(dom, nextVNode) {
+	if (typeof nextVNode.type !== "string" || !tagNamesEqualIgnoreCase(dom.tagName, nextVNode.type)) return false;
+	updateElementFromVnode(dom, nextVNode, false);
+	const nextChildren = getStableIntrinsicChildren(nextVNode);
+	if (dom.childNodes.length !== nextChildren.length) return false;
+	for (let index = 0; index < nextChildren.length; index += 1) {
+		const nextChild = nextChildren[index];
+		const currentChildNode = dom.childNodes[index];
+		if (!currentChildNode) return false;
+		if (patchStableIntrinsicText(currentChildNode, nextChild)) continue;
+		if (currentChildNode instanceof Element && _isDOMElement(nextChild) && typeof nextChild.type === "string" && patchStableIntrinsicElement(currentChildNode, nextChild)) continue;
+		return false;
+	}
+	return true;
+}
+function resolveStableIntrinsicPatchVNode(dom, vnode) {
+	if (!_isDOMElement(vnode)) return null;
+	if (typeof vnode.type === "string") return tagNamesEqualIgnoreCase(dom.tagName, vnode.type) ? vnode : null;
+	if (typeof vnode.type !== "function") return null;
+	const host = dom;
+	const existingInstance = findHostInstanceByType(host, vnode.type);
+	if (!existingInstance || existingInstance.fn !== vnode.type || host.__ASKR_WRAPPER_HOST) return null;
+	const snapshot = getVNodeContextFrame(vnode) || getCurrentContextFrame() || existingInstance.ownerFrame || null;
+	existingInstance.props = (vnode.props ?? {}) || {};
+	if (snapshot) existingInstance.ownerFrame = snapshot;
+	const result = withContext(snapshot, () => renderComponentInline(existingInstance));
+	if (result instanceof Promise) throw new Error("Async components are not supported. Components must return synchronously.");
+	const resolvedResult = resolveNestedComponentResult(result, snapshot ?? null);
+	if (_isDOMElement(resolvedResult) && typeof resolvedResult.type === "string" && tagNamesEqualIgnoreCase(dom.tagName, resolvedResult.type)) return inheritComponentKey(resolvedResult, vnode);
+	return null;
+}
+function tryPatchStableForDirtyItem(scope) {
+	if (!(scope.dom instanceof Element) || scope.vnode === void 0) return false;
+	const nextIntrinsic = resolveStableIntrinsicPatchVNode(scope.dom, scope.vnode);
+	if (!nextIntrinsic) return false;
+	const didPatch = patchStableIntrinsicElement(scope.dom, nextIntrinsic);
+	const existingInstance = scope.dom.__ASKR_INSTANCE;
+	if (didPatch && existingInstance) warnUnusedStateReads(existingInstance);
+	return didPatch;
+}
+function removeForBoundaryNodes(parent, removedNodes) {
+	if (removedNodes.length > 0 && removedNodes.length === parent.childNodes.length) {
+		let canBulkClear = true;
+		for (let i = 0; i < removedNodes.length; i++) if (removedNodes[i].parentNode !== parent) {
+			canBulkClear = false;
+			break;
+		}
+		if (canBulkClear) {
+			for (let i = 0; i < removedNodes.length; i++) recordBenchEvent("domRemove");
+			withBenchMetricScope("fullClear", () => {
+				recordBenchCounter("bulkClearCommits");
+				removeAllListeners(parent);
+				parent.textContent = "";
+			});
+			return;
+		}
+	}
+	for (let i = 0; i < removedNodes.length; i++) {
+		const node = removedNodes[i];
+		if (node.parentNode === parent) {
+			recordBenchEvent("domRemove");
+			parent.removeChild(node);
+		}
+	}
+}
+function syncKeyedMapFromForState(parent, forState, strategy, removedNodes) {
+	const existing = keyedElements.get(parent);
+	const ensureMapEntry = (map, key, element) => {
+		map.set(key, element);
+		const keyString = String(key);
+		map.set(keyString, element);
+		const keyNumber = Number(keyString);
+		if (!Number.isNaN(keyNumber)) map.set(keyNumber, element);
+	};
+	if (strategy === "SWAP") {
+		if (existing) return;
+	}
+	if (strategy === "NO_REORDER") {
+		if (existing && removedNodes.length === 0) return;
+		if (existing) {
+			for (const [mapKey, element] of existing) if (element.parentNode !== parent) existing.delete(mapKey);
+			if (existing.size > 0) keyedElements.set(parent, existing);
+			else keyedElements.delete(parent);
+			return;
+		}
+	}
+	if (strategy === "TRUNCATE" && forState.orderedKeys.length === 0) {
+		if (existing) existing.clear();
+		keyedElements.delete(parent);
+		return;
+	}
+	if (strategy === "APPEND" && existing) {
+		for (let i = 0; i < forState.orderedKeys.length; i++) {
+			const key = forState.orderedKeys[i];
+			if (key === null || existing.has(key)) continue;
+			const itemInstance = forState.items.get(key);
+			if (itemInstance?.scope.dom instanceof Element) ensureMapEntry(existing, key, itemInstance.scope.dom);
+		}
+		if (existing.size > 0) keyedElements.set(parent, existing);
+		else keyedElements.delete(parent);
+		return;
+	}
+	const nextMap = existing ?? /* @__PURE__ */ new Map();
+	nextMap.clear();
+	for (let i = 0; i < forState.orderedKeys.length; i++) {
+		const key = forState.orderedKeys[i];
+		if (key === null) continue;
+		const itemInstance = forState.items.get(key);
+		if (itemInstance?.scope.dom instanceof Element) ensureMapEntry(nextMap, key, itemInstance.scope.dom);
+	}
+	if (nextMap.size > 0) keyedElements.set(parent, nextMap);
+	else keyedElements.delete(parent);
+}
+function commitForBoundaryChildren(parent, controlState, childrenVNodes) {
+	if (controlState.kind !== "for") {
+		const activeScope = controlState.activeScope;
+		const activeVNode = childrenVNodes[0];
+		const nextDom = activeScope && activeVNode !== void 0 ? syncForItemDom(parent, activeScope, activeVNode) : null;
+		for (let i = 0; i < controlState.lastRemovedNodes.length; i++) {
+			const removedNode = controlState.lastRemovedNodes[i];
+			if (removedNode instanceof Element) teardownNodeSubtree(removedNode);
+			if (removedNode.parentNode === parent) {
+				recordBenchEvent("domRemove");
+				parent.removeChild(removedNode);
+			}
+		}
+		if (nextDom) {
+			if (parent.childNodes.length !== 1 || parent.firstChild !== nextDom || controlState.lastRemovedNodes.length > 0) parent.replaceChildren(nextDom);
+		} else if (parent.firstChild) parent.textContent = "";
+		keyedElements.delete(parent);
+		clearControlBoundaryDomUpdateState(controlState);
+		return;
+	}
+	const forState = controlState;
+	const domCommitStart = performance.now();
+	const hydrateExistingForDom = () => {
+		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 || checkVNodeShapeChanged(existingDom, childrenVNodes[i])) continue;
+			itemInstance.scope.dom = existingDom;
+		}
+	};
+	if (forState.orderedKeys.length === 0) {
+		removeForBoundaryNodes(parent, forState.lastRemovedNodes);
+		const fallbackScope = forState.fallbackScope;
+		const fallbackVNode = childrenVNodes[0];
+		const nextDom = fallbackScope && fallbackVNode !== void 0 ? syncForItemDom(parent, fallbackScope, fallbackVNode) : null;
+		if (nextDom) {
+			if (parent.childNodes.length !== 1 || parent.firstChild !== nextDom || forState.lastRemovedNodes.length > 0) parent.replaceChildren(nextDom);
+		} else if (parent.firstChild) parent.textContent = "";
+		keyedElements.delete(parent);
+		forState._hasResolvedItemDom = false;
+		recordBenchTiming("domCommit", performance.now() - domCommitStart);
+		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) {
+			const itemKey = forState.orderedKeys[index];
+			if (forState.items.get(itemKey)?.scope.needsDomUpdate) dirtyIndices.push(index);
+		}
+		return dirtyIndices;
+	};
+	let dirtyIndicesCache = null;
+	const ensureDirtyIndices = () => {
+		if (dirtyIndicesCache) return dirtyIndicesCache;
+		dirtyIndicesCache = getDirtyForIndices();
+		return dirtyIndicesCache;
+	};
+	const commitDirtyNoReorder = (dirtyIndices) => {
+		if (dirtyIndices.length === 0) return;
+		for (let dirtyIndex = 0; dirtyIndex < dirtyIndices.length; dirtyIndex++) {
+			const i = dirtyIndices[dirtyIndex];
+			const itemKey = forState.orderedKeys[i];
+			const itemInstance = forState.items.get(itemKey);
+			if (!itemInstance) continue;
+			if (tryPatchStableForDirtyItem(itemInstance.scope)) continue;
+			const dom = syncForItemDom(parent, itemInstance.scope, childrenVNodes[i]);
+			if (!dom) continue;
+			const anchor = parent.childNodes[i] ?? null;
+			if (dom.parentNode !== parent || dom !== anchor) {
+				recordBenchEvent("domInsert");
+				parent.insertBefore(dom, anchor);
+			}
+		}
+	};
+	const commitPositional = () => {
+		for (let i = 0; i < forState.orderedKeys.length; i++) {
+			const itemKey = forState.orderedKeys[i];
+			const itemInstance = forState.items.get(itemKey);
+			if (!itemInstance) continue;
+			const dom = syncForItemDom(parent, itemInstance.scope, childrenVNodes[i]);
+			if (!dom) continue;
+			if (dom.parentNode !== parent) {
+				const anchor = parent.childNodes[i] ?? null;
+				recordBenchEvent("domInsert");
+				parent.insertBefore(dom, anchor);
+			}
+		}
+	};
+	const commitAppend = () => {
+		withBenchMetricScope("coldCreate", () => {
+			const fragment = parent.ownerDocument.createDocumentFragment();
+			let hasPendingAppend = false;
+			for (let i = 0; i < forState.orderedKeys.length; i++) {
+				const itemKey = forState.orderedKeys[i];
+				const itemInstance = forState.items.get(itemKey);
+				if (!itemInstance) continue;
+				if (itemInstance.scope.dom?.parentNode === parent && !itemInstance.scope.needsDomUpdate) continue;
+				const dom = syncForItemDom(parent, itemInstance.scope, childrenVNodes[i]);
+				if (!dom) continue;
+				if (dom.parentNode !== parent) {
+					recordBenchEvent("domInsert");
+					fragment.appendChild(dom);
+					hasPendingAppend = true;
+				}
+			}
+			if (hasPendingAppend) parent.appendChild(fragment);
+		});
+	};
+	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 = syncForItemDom(parent, firstItem.scope, childrenVNodes[firstIndex]);
+		const secondDom = syncForItemDom(parent, secondItem.scope, 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) return;
+		const firstNextSibling = firstDom.nextSibling;
+		recordBenchEvent("domMove");
+		parent.insertBefore(firstDom, secondDom);
+		recordBenchEvent("domMove");
+		parent.insertBefore(secondDom, firstNextSibling);
+	};
+	const commitReorder = () => {
+		const keys = forState.orderedKeys;
+		const count = keys.length;
+		if (forState.pendingMoveOnly && forState.lastRemovedNodes.length === 0) {
+			const frag = parent.ownerDocument.createDocumentFragment();
+			for (let i = 0; i < count; i++) {
+				const itemKey = keys[i];
+				const dom = forState.items.get(itemKey)?.scope.dom;
+				if (!dom) return;
+				recordBenchEvent(dom.parentNode === parent ? "domMove" : "domInsert");
+				frag.appendChild(dom);
+			}
+			parent.replaceChildren(frag);
+			return;
+		}
+		let hasExistingChild = false;
+		for (let i = 0; i < count; i++) if (forState.items.get(keys[i])?.scope.dom?.parentNode === parent) {
+			hasExistingChild = true;
+			break;
+		}
+		if (!hasExistingChild) {
+			withBenchMetricScope("coldCreate", () => {
+				const frag = parent.ownerDocument.createDocumentFragment();
+				for (let i = 0; i < count; i++) {
+					const itemKey = keys[i];
+					const itemInstance = forState.items.get(itemKey);
+					if (!itemInstance) continue;
+					const dom = syncForItemDom(parent, itemInstance.scope, childrenVNodes[i]);
+					if (dom) {
+						recordBenchEvent("domInsert");
+						frag.appendChild(dom);
+					}
+				}
+				recordBenchCounter("replaceChildrenCommits");
+				parent.replaceChildren(frag);
+			});
+			return;
+		}
+		if (forState.lastRemovedNodes.length === 0) {
+			const frag = parent.ownerDocument.createDocumentFragment();
+			for (let i = 0; i < count; i++) {
+				const itemKey = keys[i];
+				const itemInstance = forState.items.get(itemKey);
+				if (!itemInstance) continue;
+				const dom = syncForItemDom(parent, itemInstance.scope, childrenVNodes[i]);
+				if (!dom) continue;
+				recordBenchEvent(dom.parentNode === parent ? "domMove" : "domInsert");
+				frag.appendChild(dom);
+			}
+			parent.replaceChildren(frag);
+			return;
+		}
+		for (let i = 0; i < count; i++) {
+			const itemKey = keys[i];
+			const itemInstance = forState.items.get(itemKey);
+			if (!itemInstance) continue;
+			const dom = syncForItemDom(parent, itemInstance.scope, childrenVNodes[i]);
+			if (!dom) continue;
+			const anchor = parent.childNodes[i] ?? null;
+			if (dom !== anchor) {
+				recordBenchEvent("domMove");
+				parent.insertBefore(dom, anchor);
+			}
+		}
+	};
+	const isCurrentForDomOrder = () => {
+		for (let index = 0; index < forState.orderedKeys.length; index += 1) {
+			const itemKey = forState.orderedKeys[index];
+			const itemInstance = forState.items.get(itemKey);
+			if (!itemInstance?.scope.dom) return false;
+			if (parent.childNodes[index] !== itemInstance.scope.dom) return false;
+		}
+		return true;
+	};
+	if (forState.lastCommitStrategy === "NO_REORDER" && ensureDirtyIndices().length > 0 && forState.pendingDirtyIndices === null && forState.pendingSwapIndices === null && !forState.pendingMoveOnly && forState.lastRemovedNodes.length === 0 && parent.childNodes.length === forState.orderedKeys.length) {
+		if (isCurrentForDomOrder()) {
+			commitDirtyNoReorder(ensureDirtyIndices());
+			syncKeyedMapFromForState(parent, forState, "NO_REORDER", []);
+		} else {
+			commitReorder();
+			syncKeyedMapFromForState(parent, forState, "FULL_KEYED", []);
+		}
+		recordBenchTiming("domCommit", performance.now() - domCommitStart);
+		clearForDomUpdateState(forState);
+		return;
+	}
+	switch (forState.lastCommitStrategy) {
+		case "NO_REORDER":
+			commitDirtyNoReorder(ensureDirtyIndices());
+			break;
+		case "TRUNCATE":
+			commitPositional();
+			break;
+		case "APPEND":
+			commitAppend();
+			break;
+		case "SWAP":
+			commitSwap();
+			break;
+		default:
+			commitReorder();
+			break;
+	}
+	removeForBoundaryNodes(parent, forState.lastRemovedNodes);
+	syncKeyedMapFromForState(parent, forState, forState.lastCommitStrategy, forState.lastRemovedNodes);
+	forState._hasResolvedItemDom = true;
+	recordBenchTiming("domCommit", performance.now() - domCommitStart);
+	clearForDomUpdateState(forState);
+}
+/**
+* Update an existing element's attributes and children from vnode
+*/
+function updateElementFromVnode(el, vnode, updateChildren = true) {
+	if (!_isDOMElement(vnode)) return;
+	const props = vnode.props || {};
+	const domVNode = vnode;
+	if (isHydrationSkipped(el)) {
+		clearHydrationDeferredSubtree(el);
+		return;
+	}
+	materializeKey(el, vnode, props);
+	const existingListeners = elementListeners.get(el);
+	const existingReactiveProps = elementReactivePropsCleanup.get(el);
+	if ((!existingListeners || existingListeners.size === 0) && (!existingReactiveProps || existingReactiveProps.size === 0)) {
+		if (hasMatchingStaticProps(el, props, vnode.type)) {
+			if (updateChildren) {
+				const children = vnode.children || props.children;
+				if (canReuseStaticSubtree(el, domVNode)) return;
+				updateElementChildren(el, children);
+			}
+			return;
+		}
+	}
+	let desiredEventNames = null;
+	let desiredReactivePropNames = null;
+	const usesReactiveChildren = syncReactiveScalarChild(el, props.children ?? domVNode.children);
+	if (usesReactiveChildren) (desiredReactivePropNames ??= /* @__PURE__ */ new Set()).add(REACTIVE_CHILDREN_KEY);
+	for (const key in props) {
+		const value = props[key];
+		if (isSkippedProp(key)) continue;
+		const eventName = parseEventName(key);
+		if (value === void 0 || value === null || value === false) {
+			if (key === "class" || key === "className") writeElementClassName(el, "");
+			else if (key === "value") applyFormControlProp(el, key, "", vnode.type);
+			else if (key === "checked") applyFormControlProp(el, key, false, vnode.type);
+			else if (eventName && existingListeners?.has(eventName)) {
+				const entry = existingListeners.get(eventName);
+				incDevCounter("listenerRemoves");
+				if (entry.isDelegated) removeDelegatedListener(el, eventName);
+				else if (entry.options !== void 0) el.removeEventListener(eventName, entry.handler, entry.options);
+				else el.removeEventListener(eventName, entry.handler);
+				existingListeners.delete(eventName);
+			} else {
+				const entry = existingReactiveProps?.get(key);
+				if (entry) {
+					entry.cleanup();
+					existingReactiveProps?.delete(key);
+				} else el.removeAttribute(key);
+			}
+			continue;
+		}
+		if (typeof value === "function" && !eventName && 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();
+			const reactive = setupReactiveProp(el, key, value, vnode.type);
+			if (!elementReactivePropsCleanup.has(el)) elementReactivePropsCleanup.set(el, /* @__PURE__ */ new Map());
+			elementReactivePropsCleanup.get(el).set(key, {
+				cleanup: reactive.cleanup,
+				updateFn: (nextValue) => {
+					reactive.updateFn(nextValue);
+				},
+				fnRef: value
+			});
+			continue;
+		}
+		const existingReactiveEntry = existingReactiveProps?.get(key);
+		if (existingReactiveEntry) {
+			existingReactiveEntry.cleanup();
+			existingReactiveProps?.delete(key);
+		}
+		if (key === "class" || key === "className") writeElementClassName(el, String(value));
+		else if (key === "style") applyStylePropValue(el, value);
+		else if (key === "value" || key === "checked") applyFormControlProp(el, key, value, vnode.type);
+		else if (eventName) {
+			const useDelegation = isEventDelegationEnabled() && isDelegatedEvent(eventName);
+			(desiredEventNames ??= /* @__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;
+			}
+			const existing = existingListeners?.get(eventName);
+			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, eventName);
+				else if (existing.options !== void 0) el.removeEventListener(eventName, existing.handler, existing.options);
+				else el.removeEventListener(eventName, existing.handler);
+			}
+			const options = getPassiveOptions(eventName);
+			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,
+				options,
+				isDelegated: false,
+				updateHandler: mutableHandler?.updateHandler
+			};
+			if (!elementListeners.has(el)) elementListeners.set(el, /* @__PURE__ */ new Map());
+			elementListeners.get(el).set(eventName, listenerEntry);
+		} else el.setAttribute(key, String(value));
+	}
+	removeStaleAttributes(el, domVNode, props);
+	if (existingListeners && existingListeners.size > 0) if (desiredEventNames === null) {
+		existingListeners.forEach((entry, eventName) => {
+			incDevCounter("listenerRemoves");
+			if (entry.isDelegated) removeDelegatedListener(el, eventName);
+			else if (entry.options !== void 0) el.removeEventListener(eventName, entry.handler, entry.options);
+			else el.removeEventListener(eventName, entry.handler);
+		});
+		elementListeners.delete(el);
+	} else {
+		existingListeners.forEach((entry, eventName) => {
+			if (!desiredEventNames.has(eventName)) {
+				incDevCounter("listenerRemoves");
+				if (entry.isDelegated) removeDelegatedListener(el, eventName);
+				else if (entry.options !== void 0) el.removeEventListener(eventName, entry.handler, entry.options);
+				else el.removeEventListener(eventName, entry.handler);
+				existingListeners.delete(eventName);
+			}
+		});
+		if (existingListeners.size === 0) elementListeners.delete(el);
+	}
+	const delegatedHandlers = getDelegatedHandlersForElement(el);
+	if (delegatedHandlers && delegatedHandlers.size > 0) {
+		if (desiredEventNames === null) for (const eventName of delegatedHandlers.keys()) removeDelegatedListener(el, eventName);
+		else for (const eventName of delegatedHandlers.keys()) if (!desiredEventNames.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);
+	}
+	if (updateChildren) {
+		const children = vnode.children || props.children;
+		if (usesReactiveChildren) return;
+		updateElementChildren(el, children);
+	}
+}
+function updateElementChildren(el, children) {
+	const directControlBoundary = getDirectControlBoundaryVNode(children);
+	if (directControlBoundary) {
+		const controlState = getControlBoundaryState(directControlBoundary);
+		if (!controlState) throw new Error("[updateElementChildren] Control boundary missing internal state");
+		registerControlBoundaryCommitOwner(el, controlState);
+		commitForBoundaryChildren(el, controlState, evaluateControlBoundaryState(controlState));
+		return;
+	}
+	clearControlBoundaryCommitOwner(el);
+	if (children === null || children === void 0) {
+		for (let n = el.firstChild; n;) {
+			const next = n.nextSibling;
+			if (n instanceof Element) teardownNodeSubtree(n);
+			n = next;
+		}
+		el.textContent = "";
+		return;
+	}
+	if (!Array.isArray(children) && isFragmentVNode(children)) {
+		updateUnkeyedChildren(el, normalizeComponentChildren(children));
+		return;
+	}
+	if (!Array.isArray(children) && (typeof children === "string" || typeof children === "number")) {
+		if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
+			const s = String(children);
+			const t = el.firstChild;
+			if (t.data !== s) t.data = s;
+		} else {
+			for (let n = el.firstChild; n;) {
+				const next = n.nextSibling;
+				if (n instanceof Element) teardownNodeSubtree(n);
+				n = next;
+			}
+			el.textContent = String(children);
+		}
+		return;
+	}
+	if (Array.isArray(children)) {
+		if (trySyncScalarChildSequenceInPlace(el, children)) {
+			keyedElements.delete(el);
+			return;
+		}
+		if (hasKeyedVNodeChildren(children)) {
+			const newKeyMap = reconcileKeyedChildren(el, children, getOrBuildDomKeyMap(el));
+			keyedElements.set(el, newKeyMap);
+			return;
+		}
+		if (isBulkTextFastPathEligible(el, children)) {
+			performBulkTextReplace(el, children);
+			keyedElements.delete(el);
+			return;
+		}
+		updateUnkeyedChildren(el, children);
+		return;
+	}
+	if (_isDOMElement(children)) {
+		updateUnkeyedChildren(el, [children]);
+		return;
+	}
+	for (let n = el.firstChild; n;) {
+		const next = n.nextSibling;
+		if (n instanceof Element) teardownNodeSubtree(n);
+		n = next;
+	}
+	el.textContent = "";
+	const dom = createDOMNode(children);
+	if (dom) el.appendChild(dom);
+}
+function hasKeyedVNodeChildren(children) {
+	for (let i = 0; i < children.length; i++) if (extractKey(children[i]) !== void 0) return true;
+	return false;
+}
+function isEmptyChild(child) {
+	return child === null || child === void 0 || child === false;
+}
+function getOrBuildDomKeyMap(parent) {
+	let keyMap = keyedElements.get(parent);
+	if (!keyMap) {
+		keyMap = /* @__PURE__ */ new Map();
+		for (let child = parent.firstElementChild; child; child = child.nextElementSibling) {
+			const key = child.getAttribute("data-key");
+			if (key !== null) {
+				keyMap.set(key, child);
+				const numericKey = Number(key);
+				if (!Number.isNaN(numericKey)) keyMap.set(numericKey, child);
+			}
+		}
+		if (keyMap.size > 0) keyedElements.set(parent, keyMap);
+	}
+	return keyMap.size > 0 ? keyMap : void 0;
+}
+function upperCommonTagName(tag) {
+	switch (tag) {
+		case "div": return "DIV";
+		case "span": return "SPAN";
+		case "p": return "P";
+		case "a": return "A";
+		case "button": return "BUTTON";
+		case "input": return "INPUT";
+		case "ul": return "UL";
+		case "ol": return "OL";
+		case "li": return "LI";
+		default: return null;
+	}
+}
+function tagsEqualIgnoreCase(elementTagName, vnodeType) {
+	const upperCommon = upperCommonTagName(vnodeType);
+	if (upperCommon !== null && elementTagName === upperCommon) return true;
+	return tagNamesEqualIgnoreCase(elementTagName, vnodeType);
+}
+function collectStaticChildSlots(children, slots) {
+	if (isFragmentVNode(children)) return collectStaticChildSlots(children.props?.children ?? children.children, slots);
+	if (Array.isArray(children)) {
+		for (const child of children) if (!collectStaticChildSlots(child, slots)) return false;
+		return true;
+	}
+	if (children === null || children === void 0 || children === false) return true;
+	if (typeof children === "string" || typeof children === "number") {
+		slots.push({
+			kind: "text",
+			value: String(children)
+		});
+		return true;
+	}
+	if (_isDOMElement(children) && typeof children.type === "string") {
+		slots.push({
+			kind: "element",
+			value: children
+		});
+		return true;
+	}
+	return false;
+}
+function getStaticChildSlots(children) {
+	const slots = [];
+	return collectStaticChildSlots(children, slots) ? slots : null;
+}
+function hasMatchingStaticProps(el, props, vnodeType) {
+	let staticPropCount = 0;
+	for (const key in props) {
+		if (isSkippedProp(key)) continue;
+		const value = props[key];
+		if (value === void 0 || value === null || value === false) return false;
+		if (parseEventName(key) || typeof value === "function") return false;
+		if (key === "class" || key === "className") {
+			if (readElementClassName(el) !== String(value)) return false;
+			staticPropCount += 1;
+			continue;
+		}
+		if (key === "style") {
+			const styleValue = typeof value === "string" ? value.trim().replace(/;$/, "") : null;
+			const domStyle = el.getAttribute("style")?.trim().replace(/;$/, "") ?? "";
+			if (styleValue === null || domStyle !== styleValue) return false;
+			staticPropCount += 1;
+			continue;
+		}
+		if (key === "value" || key === "checked") {
+			if (el[key] !== value) return false;
+			staticPropCount += 1;
+			continue;
+		}
+		if (key === "selected" && vnodeType === "option") {
+			if (el.selected !== Boolean(value)) return false;
+			staticPropCount += 1;
+			continue;
+		}
+		if (el.getAttribute(key) !== String(value)) return false;
+		staticPropCount += 1;
+	}
+	return el.attributes.length === staticPropCount;
+}
+function canReuseStaticSubtree(el, vnode) {
+	if (typeof vnode.type !== "string" || !tagsEqualIgnoreCase(el.tagName, vnode.type)) return false;
+	const props = vnode.props || {};
+	if (!hasMatchingStaticProps(el, props, vnode.type)) return false;
+	const slots = getStaticChildSlots(vnode.children || props.children);
+	if (!slots) return false;
+	if (el.childNodes.length !== slots.length) return false;
+	for (let index = 0; index < slots.length; index += 1) {
+		const slot = slots[index];
+		const current = el.childNodes[index];
+		if (!current) return false;
+		if (slot.kind === "text") {
+			if (current.nodeType !== 3 || current.data !== slot.value) return false;
+			continue;
+		}
+		if (!(current instanceof Element)) return false;
+		if (!canReuseStaticSubtree(current, slot.value)) return false;
+	}
+	return true;
+}
+function updateUnkeyedChildren(parent, newChildren) {
+	const parentNamespace = parent.namespaceURI === SVG_NAMESPACE ? SVG_NAMESPACE : void 0;
+	const trySyncComponentChild = (currentDom, next) => {
+		if (typeof next.type !== "function") return null;
+		return syncComponentElement(currentDom, next, next.type, (next.props ?? {}) || {}, parentNamespace);
+	};
+	const hasText = newChildren.some((c) => typeof c === "string" || typeof c === "number");
+	const hasElements = newChildren.some((c) => _isDOMElement(c));
+	const hasEmptyChildren = newChildren.some(isEmptyChild);
+	const hasComponentChildren = newChildren.some((c) => _isDOMElement(c) && typeof c.type === "function");
+	const hasNonElementDomChildren = parent.childNodes.length !== parent.children.length;
+	if (!hasEmptyChildren && !hasText && !hasComponentChildren && hasElements && parent.children.length === newChildren.length) {
+		const c = parent.children;
+		for (let i = 0; i < newChildren.length; i++) {
+			const next = newChildren[i];
+			const current = c[i];
+			if (!current || next === void 0) continue;
+			if (_isDOMElement(next) && typeof next.type === "string") if (tagsEqualIgnoreCase(current.tagName, next.type)) updateElementFromVnode(current, next);
+			else {
+				const dom = createDOMNode(next, parentNamespace);
+				if (dom) {
+					teardownNodeSubtree(current);
+					parent.replaceChild(dom, current);
+				}
+			}
+			else if (_isDOMElement(next)) {
+				const synced = trySyncComponentChild(current, next);
+				if (synced && synced !== current) teardownNodeSubtree(current);
+				else if (!synced) {
+					const dom = createDOMNode(next, parentNamespace);
+					if (dom) {
+						teardownNodeSubtree(current);
+						parent.replaceChild(dom, current);
+					}
+				}
+			} else {
+				const dom = createDOMNode(next, parentNamespace);
+				if (dom) {
+					teardownNodeSubtree(current);
+					parent.replaceChild(dom, current);
+				}
+			}
+		}
+		return;
+	}
+	const existing = Array.from(parent.children);
+	if (hasText || hasComponentChildren || hasEmptyChildren || hasNonElementDomChildren) {
+		const allNodes = Array.from(parent.childNodes);
+		const max = Math.max(allNodes.length, newChildren.length);
+		for (let i = 0; i < max; i++) {
+			const currentNode = allNodes[i];
+			const next = newChildren[i];
+			const nextIsEmpty = isEmptyChild(next);
+			if (nextIsEmpty && currentNode) {
+				teardownNodeSubtree(currentNode);
+				currentNode.remove();
+				continue;
+			}
+			if (!currentNode && !nextIsEmpty) {
+				const dom = createDOMNode(next, parentNamespace);
+				if (dom) parent.appendChild(dom);
+				continue;
+			}
+			if (!currentNode || nextIsEmpty) continue;
+			if (typeof next === "string" || typeof next === "number") if (currentNode.nodeType === 3) currentNode.data = String(next);
+			else {
+				const textNode = document.createTextNode(String(next));
+				parent.replaceChild(textNode, currentNode);
+			}
+			else if (_isDOMElement(next)) if (currentNode.nodeType === 1) {
+				const currentEl = currentNode;
+				if (typeof next.type === "string") if (tagsEqualIgnoreCase(currentEl.tagName, next.type)) updateElementFromVnode(currentEl, next);
+				else {
+					const dom = createDOMNode(next, parentNamespace);
+					if (dom) {
+						teardownNodeSubtree(currentEl);
+						parent.replaceChild(dom, currentNode);
+					}
+				}
+				else {
+					const synced = trySyncComponentChild(currentEl, next);
+					if (synced && synced !== currentNode) teardownNodeSubtree(currentEl);
+					else if (!synced) {
+						const dom = createDOMNode(next, parentNamespace);
+						if (dom) {
+							teardownNodeSubtree(currentEl);
+							parent.replaceChild(dom, currentNode);
+						}
+					}
+				}
+			} else {
+				const dom = createDOMNode(next, parentNamespace);
+				if (dom) parent.replaceChild(dom, currentNode);
+			}
+		}
+		return;
+	}
+	if (newChildren.length === 1 && existing.length === 0 && parent.childNodes.length === 1) {
+		const firstNewChild = newChildren[0];
+		const firstExisting = parent.firstChild;
+		if ((typeof firstNewChild === "string" || typeof firstNewChild === "number") && firstExisting?.nodeType === 3) {
+			firstExisting.data = String(firstNewChild);
+			return;
+		}
+	}
+	if (existing.length === 0 && parent.childNodes.length > 0) {
+		for (let n = parent.firstChild; n;) {
+			const next = n.nextSibling;
+			if (n instanceof Element) teardownNodeSubtree(n);
+			n = next;
+		}
+		parent.textContent = "";
+	}
+	const max = Math.max(existing.length, newChildren.length);
+	for (let i = 0; i < max; i++) {
+		const current = existing[i];
+		const next = newChildren[i];
+		const nextIsEmpty = isEmptyChild(next);
+		if (nextIsEmpty && current) {
+			teardownNodeSubtree(current);
+			current.remove();
+			continue;
+		}
+		if (!current && !nextIsEmpty) {
+			const dom = createDOMNode(next, parentNamespace);
+			if (dom) parent.appendChild(dom);
+			continue;
+		}
+		if (!current || nextIsEmpty) continue;
+		if (typeof next === "string" || typeof next === "number") {
+			const textNode = document.createTextNode(String(next));
+			teardownNodeSubtree(current);
+			parent.replaceChild(textNode, current);
+		} else if (_isDOMElement(next)) if (typeof next.type === "string") if (tagsEqualIgnoreCase(current.tagName, next.type)) updateElementFromVnode(current, next);
+		else {
+			const dom = createDOMNode(next, parentNamespace);
+			if (dom) {
+				teardownNodeSubtree(current);
+				parent.replaceChild(dom, current);
+			}
+		}
+		else {
+			const synced = trySyncComponentChild(current, next);
+			if (synced && synced !== current) teardownNodeSubtree(current);
+			else if (!synced) {
+				const dom = createDOMNode(next, parentNamespace);
+				if (dom) {
+					teardownNodeSubtree(current);
+					parent.replaceChild(dom, current);
+				}
+			}
+		}
+		else {
+			const dom = createDOMNode(next);
+			if (dom) {
+				teardownNodeSubtree(current);
+				parent.replaceChild(dom, current);
+			}
+		}
+	}
+}
+//#endregion
+export { IS_DOM_AVAILABLE, commitForBoundaryChildren, createDOMNode, createForBoundary, markReactivePropsDirtySource, syncComponentElement, tryPatchStableForDirtyItem, updateElementChildren, updateElementFromVnode, updateUnkeyedChildren };
+
+//# sourceMappingURL=dom.js.map