marko 6.0.0-next.3.37 → 6.0.0-next.3.39

package/dist/debug/dom.mjs

@@ -44,49 +44,6 @@ function forTo(to, from, step, cb) {
   }
 }
 
-// src/dom/schedule.ts
-var runTask;
-var port2 = /* @__PURE__ */ (() => {
-  const { port1, port2: port22 } = new MessageChannel();
-  port1.onmessage = () => {
-    isScheduled = false;
-    if (true) {
-      const run2 = runTask;
-      runTask = void 0;
-      run2();
-    } else {
-      run();
-    }
-  };
-  return port22;
-})();
-var isScheduled;
-function schedule() {
-  if (!isScheduled) {
-    if (true) {
-      if (console.createTask) {
-        const task = console.createTask("queue");
-        runTask = () => task.run(run);
-      } else {
-        runTask = run;
-      }
-    }
-    isScheduled = true;
-    queueMicrotask(flushAndWaitFrame);
-  }
-}
-function flushAndWaitFrame() {
-  if (true) {
-    runTask();
-  } else {
-    run();
-  }
-  requestAnimationFrame(triggerMacroTask);
-}
-function triggerMacroTask() {
-  port2.postMessage(0);
-}
-
 // src/common/helpers.ts
 function classValue(value2) {
   return toDelimitedString(value2, " ", stringifyClassObject);
@@ -417,10 +374,6 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
     });
   }
 }
-function registerSubscriber(id, signal) {
-  register(id, signal.___subscribe);
-  return signal;
-}
 function nodeRef(id, key) {
   return register(id, (scope) => () => scope[key]);
 }
@@ -971,9 +924,10 @@ function toInsertNode(startNode, endNode) {
 // src/dom/scope.ts
 var pendingScopes = [];
 var debugID = 0;
-function createScope($global) {
+function createScope($global, closestBranch) {
   const scope = {
     ___pending: 1,
+    ___closestBranch: closestBranch,
     $global
   };
   if (true) {
@@ -1195,10 +1149,10 @@ function trimWalkString(walkString) {
 }
 function walk(startNode, walkCodes, branch) {
   walker.currentNode = startNode;
-  walkInternal(walkCodes, branch, 0);
+  walkInternal(0, walkCodes, branch);
   walker.currentNode = document;
 }
-function walkInternal(walkCodes, scope, currentWalkIndex) {
+function walkInternal(currentWalkIndex, walkCodes, scope) {
   let value2;
   let storedMultiplier = 0;
   let currentMultiplier = 0;
@@ -1225,9 +1179,11 @@ function walkInternal(walkCodes, scope, currentWalkIndex) {
         walker.nextNode();
       }
     } else if (value2 === 47 /* BeginChild */) {
-      const childScope = scope[true ? getDebugKey(currentScopeIndex++, "#childScope") : currentScopeIndex++] = createScope(scope.$global);
-      childScope.___closestBranch = scope.___closestBranch;
-      currentWalkIndex = walkInternal(walkCodes, childScope, currentWalkIndex);
+      currentWalkIndex = walkInternal(
+        currentWalkIndex,
+        walkCodes,
+        scope[true ? getDebugKey(currentScopeIndex++, "#childScope") : currentScopeIndex++] = createScope(scope.$global, scope.___closestBranch)
+      );
     } else if (value2 === 38 /* EndChild */) {
       return currentWalkIndex;
     } else if (value2 === 32 /* Get */) {
@@ -1304,9 +1260,14 @@ function createBranch($global, ownerScope, parentScope) {
 function initBranch(renderer, branch, parentNode) {
   const clone = renderer.___clone(parentNode.namespaceURI);
   const cloneParent = clone.parentNode;
-  walk(cloneParent?.firstChild || clone, renderer.___walks, branch);
-  branch.___startNode = cloneParent?.firstChild || clone;
-  branch.___endNode = cloneParent?.lastChild || clone;
+  if (cloneParent) {
+    walk(cloneParent.firstChild, renderer.___walks, branch);
+    branch.___startNode = cloneParent.firstChild;
+    branch.___endNode = cloneParent.lastChild;
+  } else {
+    walk(clone, renderer.___walks, branch);
+    branch.___startNode = branch.___endNode = clone;
+  }
   if (renderer.___setup) {
     queueRender(branch, renderer.___setup);
   }
@@ -1329,7 +1290,12 @@ function dynamicTagAttrs(nodeAccessor, getContent, inputIsArgs) {
           "A dynamic tag rendering a `<textarea>` cannot have `content` and must use the `value` attribute instead."
         );
       }
-      setConditionalRendererOnlyChild(childScope, nodeAccessor2, content);
+      setConditionalRendererOnlyChild(
+        childScope,
+        nodeAccessor2,
+        content,
+        createBranchScopeWithTagNameOrRenderer
+      );
       attrs(childScope, nodeAccessor2, attrsOrOp());
     } else if (renderer.___args) {
       const attributes = attrsOrOp();
@@ -1381,11 +1347,23 @@ function createCloneableHTML(html2, ns) {
 }
 
 // src/dom/control-flow.ts
-function patchConditionals(fn) {
-  conditional = fn(conditional);
-  conditionalOnlyChild = fn(conditionalOnlyChild);
+function conditional(nodeAccessor, ...branches) {
+  const branchAccessor = nodeAccessor + "(" /* ConditionalRenderer */;
+  return (scope, newBranchIndexOrOp) => {
+    if (newBranchIndexOrOp !== scope[branchAccessor] && newBranchIndexOrOp !== DIRTY && newBranchIndexOrOp !== MARK && newBranchIndexOrOp !== CLEAN) {
+      (scope[nodeAccessor].nodeType > 1 /* Element */ ? setConditionalRenderer : setConditionalRendererOnlyChild)(
+        scope,
+        nodeAccessor,
+        branches[scope[branchAccessor] = newBranchIndexOrOp],
+        createBranchScopeWithRenderer
+      );
+    }
+  };
+}
+function patchDynamicTag(fn) {
+  dynamicTag = fn(dynamicTag);
 }
-var conditional = function conditional2(nodeAccessor, fn, getIntersection) {
+var dynamicTag = function dynamicTag2(nodeAccessor, fn, getIntersection) {
   const rendererAccessor = nodeAccessor + "(" /* ConditionalRenderer */;
   let intersection2 = getIntersection && ((scope, op) => (intersection2 = getIntersection())(scope, op));
   return (scope, newRendererOrOp) => {
@@ -1396,7 +1374,12 @@ var conditional = function conditional2(nodeAccessor, fn, getIntersection) {
       const normalizedRenderer = normalizeDynamicRenderer(newRendererOrOp);
       if (isDifferentRenderer(normalizedRenderer, currentRenderer)) {
         scope[rendererAccessor] = normalizedRenderer;
-        setConditionalRenderer(scope, nodeAccessor, normalizedRenderer);
+        setConditionalRenderer(
+          scope,
+          nodeAccessor,
+          normalizedRenderer,
+          createBranchScopeWithTagNameOrRenderer
+        );
         fn && fn(scope);
         op = DIRTY;
       } else {
@@ -1406,56 +1389,28 @@ var conditional = function conditional2(nodeAccessor, fn, getIntersection) {
     intersection2?.(scope, op);
   };
 };
-function setConditionalRenderer(scope, nodeAccessor, newRenderer) {
+function setConditionalRenderer(scope, nodeAccessor, newRenderer, createBranch2) {
   const prevBranch = scope[nodeAccessor + "!" /* ConditionalScope */] || getEmptyBranch(scope[nodeAccessor]);
-  const newBranch = newRenderer ? createBranchScopeWithTagNameOrRenderer(
+  const newBranch = newRenderer ? createBranch2(
     newRenderer,
     scope.$global,
     scope,
     prevBranch.___endNode.parentNode
   ) : getEmptyBranch(scope[nodeAccessor]);
-  insertBranchBefore(
-    newBranch,
-    prevBranch.___endNode.parentNode,
-    prevBranch.___endNode.nextSibling
-  );
-  removeAndDestroyBranch(prevBranch);
-  scope[nodeAccessor + "!" /* ConditionalScope */] = newRenderer && newBranch;
+  if (prevBranch !== newBranch) {
+    insertBranchBefore(
+      newBranch,
+      prevBranch.___endNode.parentNode,
+      prevBranch.___endNode.nextSibling
+    );
+    removeAndDestroyBranch(prevBranch);
+    scope[nodeAccessor + "!" /* ConditionalScope */] = newRenderer && newBranch;
+  }
 }
-var conditionalOnlyChild = function conditional3(nodeAccessor, fn, getIntersection) {
-  const rendererAccessor = nodeAccessor + "(" /* ConditionalRenderer */;
-  let intersection2 = getIntersection && ((scope, op) => (intersection2 = getIntersection())(scope, op));
-  return (scope, newRendererOrOp) => {
-    if (newRendererOrOp === DIRTY) return;
-    let currentRenderer = scope[rendererAccessor];
-    let op = newRendererOrOp;
-    if (newRendererOrOp !== MARK && newRendererOrOp !== CLEAN) {
-      const normalizedRenderer = normalizeDynamicRenderer(newRendererOrOp);
-      if (isDifferentRenderer(normalizedRenderer, currentRenderer)) {
-        currentRenderer = scope[rendererAccessor] = normalizedRenderer;
-        setConditionalRendererOnlyChild(
-          scope,
-          nodeAccessor,
-          normalizedRenderer
-        );
-        fn && fn(scope);
-        op = DIRTY;
-      } else {
-        op = CLEAN;
-      }
-    }
-    intersection2?.(scope, op);
-  };
-};
-function setConditionalRendererOnlyChild(scope, nodeAccessor, newRenderer) {
+function setConditionalRendererOnlyChild(scope, nodeAccessor, newRenderer, createBranch2) {
   const prevBranch = scope[nodeAccessor + "!" /* ConditionalScope */];
   const referenceNode = scope[nodeAccessor];
-  const newBranch = newRenderer && createBranchScopeWithTagNameOrRenderer(
-    newRenderer,
-    scope.$global,
-    scope,
-    referenceNode
-  );
+  const newBranch = newRenderer && createBranch2(newRenderer, scope.$global, scope, referenceNode);
   referenceNode.textContent = "";
   if (newBranch) {
     insertBranchBefore(newBranch, referenceNode, null);
@@ -1585,6 +1540,49 @@ function isDifferentRenderer(a, b) {
   return a !== b && (a?.___id || 0) !== b?.___id;
 }
 
+// src/dom/schedule.ts
+var runTask;
+var port2 = /* @__PURE__ */ (() => {
+  const { port1, port2: port22 } = new MessageChannel();
+  port1.onmessage = () => {
+    isScheduled = false;
+    if (true) {
+      const run2 = runTask;
+      runTask = void 0;
+      run2();
+    } else {
+      run();
+    }
+  };
+  return port22;
+})();
+var isScheduled;
+function schedule() {
+  if (!isScheduled) {
+    if (true) {
+      if (console.createTask) {
+        const task = console.createTask("queue");
+        runTask = () => task.run(run);
+      } else {
+        runTask = run;
+      }
+    }
+    isScheduled = true;
+    queueMicrotask(flushAndWaitFrame);
+  }
+}
+function flushAndWaitFrame() {
+  if (true) {
+    runTask();
+  } else {
+    run();
+  }
+  requestAnimationFrame(triggerMacroTask);
+}
+function triggerMacroTask() {
+  port2.postMessage(0);
+}
+
 // src/dom/signals.ts
 var MARK = true ? Symbol("mark") : {};
 var CLEAN = true ? Symbol("clean") : {};
@@ -1603,6 +1601,7 @@ function state(valueAccessor, fn, getIntersection) {
     } else if (scope[valueChangeAccessor]) {
       scope[valueChangeAccessor](valueOrOp);
     } else {
+      schedule();
       queueSource(scope, valueSignal, valueOrOp);
     }
     return valueOrOp;
@@ -1610,21 +1609,21 @@ function state(valueAccessor, fn, getIntersection) {
 }
 function value(valueAccessor, fn, getIntersection) {
   const markAccessor = valueAccessor + "#" /* Mark */;
-  let intersection2 = getIntersection && ((scope, op) => (intersection2 = getIntersection())(scope, op));
+  let intersection2;
   return (scope, valueOrOp) => {
     if (valueOrOp === MARK) {
       if ((scope[markAccessor] = (scope[markAccessor] ?? 0) + 1) === 1) {
-        intersection2?.(scope, MARK);
+        getIntersection && (intersection2 ||= getIntersection())(scope, MARK);
       }
     } else if (valueOrOp !== DIRTY) {
       const existing = scope[markAccessor] !== void 0;
       if ((scope[markAccessor] ||= 1) === 1) {
         if (valueOrOp === CLEAN || existing && scope[valueAccessor] === valueOrOp) {
-          intersection2?.(scope, CLEAN);
+          getIntersection && (intersection2 ||= getIntersection())(scope, CLEAN);
         } else {
           scope[valueAccessor] = valueOrOp;
           fn && fn(scope, valueOrOp);
-          intersection2?.(scope, DIRTY);
+          getIntersection && (intersection2 ||= getIntersection())(scope, DIRTY);
         }
       }
       scope[markAccessor]--;
@@ -1635,11 +1634,11 @@ var accessorId = 0;
 function intersection(count, fn, getIntersection) {
   const dirtyAccessor = "?" /* Dynamic */ + accessorId++;
   const markAccessor = dirtyAccessor + "#" /* Mark */;
-  let intersection2 = getIntersection && ((scope, op) => (intersection2 = getIntersection())(scope, op));
+  let intersection2;
   return (scope, op) => {
     if (op === MARK) {
       if ((scope[markAccessor] = (scope[markAccessor] ?? 0) + 1) === 1) {
-        intersection2?.(scope, MARK);
+        getIntersection && (intersection2 ||= getIntersection())(scope, MARK);
       }
     } else if (scope[markAccessor] === void 0) {
       scope[markAccessor] = count - 1;
@@ -1647,84 +1646,101 @@ function intersection(count, fn, getIntersection) {
     } else if (--scope[markAccessor] === 0) {
       if (op === DIRTY || scope[dirtyAccessor]) {
         scope[dirtyAccessor] = false;
-        fn(scope, 0);
-        intersection2?.(scope, DIRTY);
+        fn(scope);
+        getIntersection && (intersection2 ||= getIntersection())(scope, DIRTY);
       } else {
-        intersection2?.(scope, CLEAN);
+        getIntersection && (intersection2 ||= getIntersection())(scope, CLEAN);
       }
     } else {
       scope[dirtyAccessor] ||= op === DIRTY;
     }
   };
 }
-function closure(fn, getIntersection) {
-  let intersection2 = getIntersection && ((scope, op) => (intersection2 = getIntersection())(scope, op));
-  return (scope, valueOrOp) => {
-    if (valueOrOp === MARK) {
-      intersection2?.(scope, MARK);
-    } else {
-      fn && fn(scope, valueOrOp);
-      intersection2?.(scope, DIRTY);
-    }
-  };
-}
-function loopClosure(ownerLoopNodeAccessor, fn, getIntersection) {
-  const signal = closure(fn, getIntersection);
+function loopClosure(valueAccessor, ownerLoopNodeAccessor, fn, getIntersection) {
+  const childSignal = closure(valueAccessor, fn, getIntersection);
   const loopScopeAccessor = ownerLoopNodeAccessor + "!" /* LoopScopeArray */;
   const loopScopeMapAccessor = ownerLoopNodeAccessor + "(" /* LoopScopeMap */;
-  const helperSignal = (ownerScope, value2) => {
+  const ownerSignal = (ownerScope) => {
     const loopScopes = ownerScope[loopScopeAccessor] ?? ownerScope[loopScopeMapAccessor]?.values() ?? [];
     if (loopScopes !== emptyMarkerArray) {
       for (const scope of loopScopes) {
         if (!scope.___pending) {
-          queueSource(scope, signal, value2);
+          queueSource(scope, childSignal);
         }
       }
     }
   };
-  helperSignal._ = signal;
-  return helperSignal;
+  ownerSignal._ = childSignal;
+  return ownerSignal;
 }
-function conditionalClosure(ownerConditionalNodeAccessor, getRenderer, fn, getIntersection) {
-  const signal = closure(fn, getIntersection);
+function conditionalClosure(valueAccessor, ownerConditionalNodeAccessor, branch, fn, getIntersection) {
+  const childSignal = closure(valueAccessor, fn, getIntersection);
   const scopeAccessor = ownerConditionalNodeAccessor + "!" /* ConditionalScope */;
-  const rendererAccessor = ownerConditionalNodeAccessor + "(" /* ConditionalRenderer */;
-  const helperSignal = (scope, value2) => {
-    const conditionalScope = scope[scopeAccessor];
-    if (conditionalScope && !conditionalScope.___pending && scope[rendererAccessor]?.___id === getRenderer().___id) {
-      queueSource(conditionalScope, signal, value2);
+  const branchAccessor = ownerConditionalNodeAccessor + "(" /* ConditionalRenderer */;
+  const ownerSignal = (scope) => {
+    const ifScope = scope[scopeAccessor];
+    if (ifScope && !ifScope.___pending && scope[branchAccessor] === branch) {
+      queueSource(ifScope, childSignal);
     }
   };
-  helperSignal._ = signal;
-  return helperSignal;
-}
-var defaultGetOwnerScope = (scope) => scope._;
-function dynamicClosure(fn, getOwnerScope = defaultGetOwnerScope, getIntersection) {
-  const ownerSubscribersAccessor = "?" /* Dynamic */ + accessorId++;
-  const _signal = closure(fn, getIntersection);
-  const helperSignal = (ownerScope, value2) => {
-    const subscribers = ownerScope[ownerSubscribersAccessor];
+  ownerSignal._ = childSignal;
+  return ownerSignal;
+}
+function dynamicClosure(valueAccessor, fn, getIntersection, getOwnerScope) {
+  const subscribersAccessor = "?" /* Dynamic */ + accessorId++;
+  const childSignal = closure(
+    valueAccessor,
+    fn,
+    getIntersection,
+    getOwnerScope
+  );
+  const ownerSignal = (ownerScope) => {
+    const subscribers = ownerScope[subscribersAccessor];
     if (subscribers) {
       for (const subscriber of subscribers) {
         if (!subscriber.___pending) {
-          queueSource(subscriber, _signal, value2);
+          queueSource(subscriber, childSignal);
         }
       }
     }
   };
-  const setupSignal = (scope, value2) => {
-    _signal(scope, value2);
+  const subscribe = (scope) => {
+    const owner = getOwnerScope ? getOwnerScope(scope) : scope._;
+    const subscribers = owner[subscribersAccessor] ||= /* @__PURE__ */ new Set();
+    if (!subscribers.has(scope)) {
+      subscribers.add(scope);
+      getAbortSignal(scope, -1).addEventListener(
+        "abort",
+        () => owner[subscribersAccessor].delete(scope)
+      );
+    }
+  };
+  ownerSignal.___subscribe = subscribe;
+  ownerSignal._ = (scope) => {
+    childSignal(scope);
     subscribe(scope);
   };
-  const subscribe = (scope) => {
-    (getOwnerScope(scope)[ownerSubscribersAccessor] ||= /* @__PURE__ */ new Set()).add(scope);
-    getAbortSignal(scope, -1).addEventListener("abort", () => {
-      getOwnerScope(scope)[ownerSubscribersAccessor].delete(scope);
-    });
+  return ownerSignal;
+}
+function registerDynamicClosure(id, valueAccessor, fn, getIntersection, getOwnerScope) {
+  const signal = dynamicClosure(
+    valueAccessor,
+    fn,
+    getIntersection,
+    getOwnerScope
+  );
+  register(id, signal.___subscribe);
+  return signal;
+}
+function closure(valueAccessor, fn, getIntersection, getOwnerScope) {
+  let intersection2;
+  return (scope, op) => {
+    op || fn && fn(
+      scope,
+      (getOwnerScope ? getOwnerScope(scope) : scope._)[valueAccessor]
+    );
+    getIntersection && (intersection2 ||= getIntersection())(scope, op ? MARK : DIRTY);
   };
-  helperSignal._ = setupSignal;
-  helperSignal.___subscribe = subscribe;
-  return helperSignal;
 }
 function setTagVar(scope, childAccessor, tagVarSignal2) {
   scope[childAccessor]["/" /* TagVariable */] = (valueOrOp) => tagVarSignal2(scope, valueOrOp);
@@ -1764,13 +1780,11 @@ var pendingRenders = [];
 var pendingEffects = [];
 var rendering = false;
 function queueSource(scope, signal, value2) {
-  schedule();
   const prevRendering = rendering;
   rendering = true;
   signal(scope, MARK);
   rendering = prevRendering;
   queueRender(scope, signal, value2);
-  return value2;
 }
 function queueRender(scope, signal, value2) {
   let i = pendingRenders.length;
@@ -1778,6 +1792,7 @@ function queueRender(scope, signal, value2) {
     ___scope: scope,
     ___signal: signal,
     ___value: value2,
+    ___depth: scope.___closestBranch?.___branchDepth || 0,
     ___index: i
   };
   pendingRenders.push(render);
@@ -1821,7 +1836,7 @@ function prepareEffects(fn) {
   }
   return preparedEffects;
 }
-function runEffects(effects = pendingEffects) {
+function runEffects(effects) {
   for (let i = 0; i < effects.length; i += 2 /* Total */) {
     const scope = effects[i];
     const fn = effects[i + 1];
@@ -1861,10 +1876,7 @@ function runRenders() {
   finishPendingScopes();
 }
 function comparePendingRenders(a, b) {
-  return getBranchDepth(a) - getBranchDepth(b) || a.___index - b.___index;
-}
-function getBranchDepth(render) {
-  return render.___scope.___closestBranch?.___branchDepth || 0;
+  return a.___depth - b.___depth || a.___index - b.___index;
 }
 
 // src/dom/abort-signal.ts
@@ -1894,7 +1906,7 @@ var RENDER_BODY_ID = prefix + (true ? "renderBody" : "b");
 // src/dom/compat.ts
 var classIdToBranch = /* @__PURE__ */ new Map();
 var compat = {
-  patchConditionals,
+  patchConditionals: patchDynamicTag,
   queueEffect,
   init(warp10Noop) {
     register(SET_SCOPE_REGISTER_ID, (branch) => {
@@ -2039,7 +2051,7 @@ function mount(input = {}, reference, position) {
   );
   runEffects(effects);
   return {
-    update: (newInput) => {
+    update(newInput) {
       if (args) {
         runEffects(
           prepareEffects(() => {
@@ -2049,7 +2061,7 @@ function mount(input = {}, reference, position) {
         );
       }
     },
-    destroy: () => {
+    destroy() {
       removeAndDestroyBranch(branch);
     }
   };
@@ -2064,7 +2076,6 @@ export {
   compat,
   conditional,
   conditionalClosure,
-  conditionalOnlyChild,
   controllable_detailsOrDialog_open,
   controllable_detailsOrDialog_open_effect,
   controllable_input_checked,
@@ -2082,6 +2093,7 @@ export {
   createTemplate,
   data,
   dynamicClosure,
+  dynamicTag,
   dynamicTagAttrs,
   effect,
   forIn,
@@ -2105,7 +2117,7 @@ export {
   props,
   register,
   registerBoundSignal,
-  registerSubscriber,
+  registerDynamicClosure,
   resetAbortSignal,
   run,
   setTagVar,

package/dist/dom/compat.d.ts

@@ -1,8 +1,8 @@
-import { patchConditionals } from "./control-flow";
+import { patchDynamicTag } from "./control-flow";
 import { queueEffect } from "./queue";
 import { type Renderer } from "./renderer";
 export declare const compat: {
-    patchConditionals: typeof patchConditionals;
+    patchConditionals: typeof patchDynamicTag;
     queueEffect: typeof queueEffect;
     init(warp10Noop: any): void;
     registerRenderer(fn: any): void;

package/dist/dom/control-flow.d.ts

@@ -1,11 +1,10 @@
 import { type Accessor, type BranchScope, type Scope } from "../common/types";
 import { type Renderer } from "./renderer";
 import { type Signal, type SignalOp } from "./signals";
-export declare function patchConditionals(fn: <T extends typeof conditional | typeof conditionalOnlyChild>(cond: T) => T): void;
-export declare let conditional: (nodeAccessor: Accessor, fn?: ((scope: Scope) => void) | 0, getIntersection?: () => Signal<never>) => Signal<Renderer | string | undefined>;
-export declare function setConditionalRenderer(scope: Scope, nodeAccessor: Accessor, newRenderer: Renderer | string | undefined): void;
-export declare let conditionalOnlyChild: (nodeAccessor: Accessor, fn?: ((scope: Scope) => void) | 0, getIntersection?: () => Signal<never>) => Signal<Renderer | string | undefined>;
-export declare function setConditionalRendererOnlyChild(scope: Scope, nodeAccessor: Accessor, newRenderer: Renderer | string | undefined): void;
+export declare function conditional(nodeAccessor: Accessor, ...branches: Renderer[]): Signal<number>;
+export declare function patchDynamicTag(fn: <T extends typeof dynamicTag>(cond: T) => T): void;
+export declare let dynamicTag: (nodeAccessor: Accessor, fn?: ((scope: Scope) => void) | 0, getIntersection?: () => Signal<never>) => Signal<Renderer | string | undefined>;
+export declare function setConditionalRendererOnlyChild<T>(scope: Scope, nodeAccessor: Accessor, newRenderer: T, createBranch: (renderer: NonNullable<T>, $global: Scope["$global"], parentScope: Scope, parentNode: ParentNode) => BranchScope): void;
 export declare const emptyMarkerArray: BranchScope[];
 export declare function loopOf(nodeAccessor: Accessor, renderer: Renderer): (scope: Scope, valueOrOp: SignalOp | [all: unknown[], by?: ((item: unknown, index: number) => unknown) | undefined]) => void;
 export declare function loopIn(nodeAccessor: Accessor, renderer: Renderer): (scope: Scope, valueOrOp: SignalOp | [obj: {}, by?: ((key: string, v: unknown) => unknown) | undefined]) => void;

package/dist/dom/queue.d.ts

@@ -3,10 +3,10 @@ import { type Signal } from "./signals";
 type ExecFn<S extends Scope = Scope> = (scope: S, arg?: any) => void;
 export declare let pendingEffects: unknown[];
 export declare let rendering: boolean;
-export declare function queueSource<T>(scope: Scope, signal: Signal<T>, value: T): T;
+export declare function queueSource<T>(scope: Scope, signal: Signal<T>, value?: T): void;
 export declare function queueRender(scope: Scope, signal: Signal<any>, value?: unknown): void;
 export declare function queueEffect<S extends Scope, T extends ExecFn<S>>(scope: S, fn: T): void;
 export declare function run(): void;
 export declare function prepareEffects(fn: () => void): unknown[];
-export declare function runEffects(effects?: unknown[]): void;
+export declare function runEffects(effects: unknown[]): void;
 export {};

package/dist/dom/resume.d.ts

@@ -5,5 +5,4 @@ export declare function register<T>(id: string, obj: T): T;
 export declare function registerBoundSignal<T extends Signal<unknown>>(id: string, signal: T): T;
 export declare function getRegisteredWithScope(id: string, scope?: Scope): unknown;
 export declare function init(runtimeId?: string): void;
-export declare function registerSubscriber(id: string, signal: Signal<never>): Signal<never>;
 export declare function nodeRef(id: string, key: string): (scope: Scope) => () => any;

package/dist/dom/scope.d.ts

@@ -1,5 +1,5 @@
 import type { BranchScope, Scope } from "../common/types";
-export declare function createScope($global: Scope["$global"]): Scope;
+export declare function createScope($global: Scope["$global"], closestBranch?: BranchScope): Scope;
 export declare function finishPendingScopes(): void;
 export declare function getEmptyBranch(marker: Comment): BranchScope;
 export declare function destroyBranch(branch: BranchScope): void;

package/dist/dom/signals.d.ts

@@ -1,5 +1,4 @@
 import { type Accessor, type Scope } from "../common/types";
-import type { Renderer } from "./renderer";
 export declare const MARK: unique symbol;
 export declare const CLEAN: unique symbol;
 export declare const DIRTY: unique symbol;
@@ -8,13 +7,21 @@ export type SignalFn<T> = (scope: Scope, value: T) => void;
 export type Signal<T> = ((scope: Scope, value: T | SignalOp) => void) & {
     ___subscribe?(scope: Scope): void;
 };
-export declare function state<T>(valueAccessor: Accessor, fn: Signal<T>, getIntersection?: () => Signal<never>): (scope: Scope, valueOrOp: T | SignalOp, valueChange?: (v: T) => void) => SignalOp | T;
-export declare function value<T>(valueAccessor: Accessor, fn: SignalFn<T> | 0, getIntersection?: () => Signal<never>): Signal<T>;
+export declare function state<T>(valueAccessor: Accessor, fn: 0 | undefined | Signal<T>, getIntersection?: () => Signal<never>): (scope: Scope, valueOrOp: T | SignalOp, valueChange?: (v: T) => void) => SignalOp | T;
+export declare function value<T>(valueAccessor: Accessor, fn: 0 | undefined | SignalFn<T>, getIntersection?: () => Signal<never>): Signal<T>;
 export declare function intersection(count: number, fn: SignalFn<never>, getIntersection?: () => Signal<never>): Signal<never>;
-export declare function closure<T>(fn: SignalFn<T> | 0, getIntersection?: () => Signal<never>): Signal<T>;
-export declare function loopClosure<T>(ownerLoopNodeAccessor: Accessor, fn: SignalFn<T> | 0, getIntersection?: () => Signal<never>): SignalFn<T>;
-export declare function conditionalClosure<T>(ownerConditionalNodeAccessor: Accessor, getRenderer: () => Renderer, fn: SignalFn<T> | 0, getIntersection?: () => Signal<never>): SignalFn<T>;
-export declare function dynamicClosure<T>(fn: Signal<T> | 0, getOwnerScope?: (scope: Scope) => Scope, getIntersection?: () => Signal<never>): SignalFn<T>;
+export declare function loopClosure<T>(valueAccessor: Accessor, ownerLoopNodeAccessor: Accessor, fn: 0 | SignalFn<T>, getIntersection?: 0 | (() => Signal<never>)): SignalFn<T>;
+export declare function conditionalClosure<T>(valueAccessor: Accessor, ownerConditionalNodeAccessor: Accessor, branch: number, fn: 0 | SignalFn<T>, getIntersection?: 0 | (() => Signal<never>)): SignalFn<T>;
+export declare function dynamicClosure<T>(valueAccessor: Accessor, fn: 0 | Signal<T>, getIntersection?: 0 | (() => Signal<never>), getOwnerScope?: (scope: Scope) => Scope): {
+    (ownerScope: Scope): void;
+    ___subscribe: (scope: Scope) => void;
+    _(scope: Scope): void;
+};
+export declare function registerDynamicClosure<T>(id: string, valueAccessor: Accessor, fn: 0 | Signal<T>, getIntersection?: 0 | (() => Signal<never>), getOwnerScope?: (scope: Scope) => Scope): {
+    (ownerScope: Scope): void;
+    ___subscribe: (scope: Scope) => void;
+    _(scope: Scope): void;
+};
 export declare function setTagVar(scope: Scope, childAccessor: Accessor, tagVarSignal: Signal<unknown>): void;
 export declare const tagVarSignal: (scope: Scope, valueOrOp: unknown | SignalOp) => any;
 export declare function setTagVarChange(scope: Scope, changeHandler: (value: unknown) => void): void;