marko 6.0.0-next.3.22 → 6.0.0-next.3.23

package/dist/debug/html.mjs

@@ -104,6 +104,28 @@ function escapeStyle(val) {
   return val ? escapeStyleStr(val + "") : val === 0 ? "0" : "";
 }
 
+// src/common/for.ts
+function forIn(obj, cb) {
+  for (const key in obj) {
+    cb(key, obj[key]);
+  }
+}
+function forOf(list, cb) {
+  if (list) {
+    let i = 0;
+    for (const item of list) {
+      cb(item, i++);
+    }
+  }
+}
+function forTo(to, from, step, cb) {
+  const start = from || 0;
+  const delta = step || 1;
+  for (let steps = (to - start) / delta, i = 0; i <= steps; i++) {
+    cb(start + i * delta);
+  }
+}
+
 // src/html/inlined-runtimes.ts
 var WALKER_RUNTIME_CODE = true ? (
   /* js */
@@ -1413,23 +1435,143 @@ function nodeRef(scopeId, id) {
   };
   return id ? register2(getter, id, scopeId) : getter;
 }
-function markResumeScopeStart(scopeId, index) {
-  return $chunk.boundary.state.mark(
-    "[" /* SectionStart */,
-    scopeId + (index ? " " + index : "")
+function resumeClosestBranch(scopeId) {
+  const branchId = $chunk.context?.[branchIdKey];
+  if (branchId !== void 0 && branchId !== scopeId) {
+    $chunk.writeHTML(
+      $chunk.boundary.state.mark("$" /* ClosestBranch */, "" + scopeId)
+    );
+  }
+}
+var branchIdKey = Symbol();
+function resumeForOf(list, cb, scopeId, accessor) {
+  forOf(list, (item, i) => {
+    const branchId = peekNextScopeId();
+    $chunk.writeHTML(
+      $chunk.boundary.state.mark(
+        "[" /* BranchStart */,
+        branchId + (i ? " " : "")
+      )
+    );
+    withContext(branchIdKey, branchId, () => cb(item, i));
+  });
+  $chunk.writeHTML(
+    $chunk.boundary.state.mark(
+      "]" /* BranchEnd */,
+      scopeId + " " + accessor
+    )
   );
 }
-function markResumeControlEnd(scopeId, accessor) {
-  return $chunk.boundary.state.mark("]" /* SectionEnd */, scopeId + " " + accessor);
+function resumeSingleNodeForOf(list, cb, scopeId, accessor) {
+  let branchIds = "";
+  forOf(list, (item, index) => {
+    const branchId = peekNextScopeId();
+    branchIds = " " + branchId + branchIds;
+    withContext(branchIdKey, branchId, () => cb(item, index));
+  });
+  $chunk.writeHTML(
+    $chunk.boundary.state.mark(
+      "|" /* BranchSingleNode */,
+      scopeId + " " + accessor + branchIds
+    )
+  );
 }
-function markResumeControlSingleNodeEnd(scopeId, accessor, childScopeIds) {
-  return $chunk.boundary.state.mark(
-    "|" /* SectionSingleNodesEnd */,
-    scopeId + " " + accessor + " " + (childScopeIds ?? "")
+function resumeForIn(obj, cb, scopeId, accessor) {
+  let sep = "";
+  forIn(obj, (key, value) => {
+    const branchId = peekNextScopeId();
+    $chunk.writeHTML(
+      $chunk.boundary.state.mark("[" /* BranchStart */, branchId + sep)
+    );
+    sep = " ";
+    withContext(branchIdKey, branchId, () => cb(key, value));
+  });
+  $chunk.writeHTML(
+    $chunk.boundary.state.mark(
+      "]" /* BranchEnd */,
+      scopeId + " " + accessor
+    )
   );
 }
-function markResumeCleanup(scopeId) {
-  return $chunk.boundary.state.mark("$" /* Cleanup */, "" + scopeId);
+function resumeSingleNodeForIn(obj, cb, scopeId, accessor) {
+  let branchIds = "";
+  forIn(obj, (key, value) => {
+    const branchId = peekNextScopeId();
+    branchIds = " " + branchId + branchIds;
+    withContext(branchIdKey, branchId, () => cb(key, value));
+  });
+  $chunk.writeHTML(
+    $chunk.boundary.state.mark(
+      "|" /* BranchSingleNode */,
+      scopeId + " " + accessor + branchIds
+    )
+  );
+}
+function resumeForTo(to, from, step, cb, scopeId, accessor) {
+  let sep = "";
+  forTo(to, from, step, (index) => {
+    const branchId = peekNextScopeId();
+    $chunk.writeHTML(
+      $chunk.boundary.state.mark("[" /* BranchStart */, branchId + sep)
+    );
+    sep = " ";
+    withContext(branchIdKey, branchId, () => cb(index));
+  });
+  $chunk.writeHTML(
+    $chunk.boundary.state.mark(
+      "]" /* BranchEnd */,
+      scopeId + " " + accessor
+    )
+  );
+}
+function resumeSingleNodeForTo(to, from, step, cb, scopeId, accessor) {
+  let branchIds = "";
+  forTo(to, from, step, (index) => {
+    const branchId = peekNextScopeId();
+    branchIds = " " + branchId + branchIds;
+    withContext(branchIdKey, branchId, () => cb(index));
+  });
+  $chunk.writeHTML(
+    $chunk.boundary.state.mark(
+      "|" /* BranchSingleNode */,
+      scopeId + " " + accessor + branchIds
+    )
+  );
+}
+function resumeConditional(cb, scopeId, accessor) {
+  const branchId = peekNextScopeId();
+  $chunk.writeHTML(
+    $chunk.boundary.state.mark("[" /* BranchStart */, branchId + "")
+  );
+  withContext(branchIdKey, branchId, cb);
+  const rendered = peekNextScopeId() !== branchId;
+  if (rendered) {
+    writeScope(branchId, {});
+  } else {
+    nextScopeId();
+  }
+  $chunk.writeHTML(
+    $chunk.boundary.state.mark(
+      "]" /* BranchEnd */,
+      scopeId + " " + accessor
+    )
+  );
+}
+function resumeSingleNodeConditional(cb, scopeId, accessor) {
+  const branchId = peekNextScopeId();
+  withContext(branchIdKey, branchId, cb);
+  const rendered = peekNextScopeId() !== branchId;
+  if (rendered) {
+    writeScope(branchId, {});
+  } else {
+    nextScopeId();
+  }
+  $chunk.writeHTML(
+    $chunk.boundary.state.mark(
+      "|" /* BranchSingleNode */,
+      scopeId + " " + accessor + (rendered ? " " + branchId : "")
+    )
+  );
 }
 function writeScope(scopeId, partialScope) {
   const { state } = $chunk.boundary;
@@ -1747,7 +1889,7 @@ var Chunk = class {
       do {
         cur.flushPlaceholder();
         html += cur.html;
-        effects += cur.effects;
+        effects = concatEffects(effects, cur.effects);
         scripts = concatScripts(scripts, cur.scripts);
         cur.consumed = true;
         cur = cur.next;
@@ -2201,52 +2343,57 @@ var DEFAULT_RENDER_ID = "_";
 
 // src/html/dynamic-tag.ts
 var voidElementsReg = /^(?:area|b(?:ase|r)|col|embed|hr|i(?:mg|nput)|link|meta|param|source|track|wbr)$/;
-function dynamicTagInput(scope, tag, input, content, tagVar) {
-  if (!tag && !content) return void 0;
-  const scopeId = getScopeId(scope);
-  write(`${markResumeScopeStart(scopeId)}`);
-  writeScope(scopeId, scope);
+function dynamicTagInput(scopeId, accessor, tag, input, content, tagVar) {
+  if (!tag && !content) {
+    nextScopeId();
+    return;
+  }
   if (!tag) {
-    return content();
+    resumeConditional(content, scopeId, accessor);
+    return;
   }
   if (typeof tag === "string") {
-    nextScopeId();
-    write(
-      `<${tag}${attrs(input, true ? `#${tag}/0` : 0, scopeId, tag)}>`
-    );
-    if (!voidElementsReg.test(tag)) {
-      if (tag === "textarea") {
-        if (content) {
-          throw new Error(
-            "A dynamic tag rendering a `<textarea>` cannot have `content` and must use the `value` attribute instead."
-          );
-        }
-        write(
-          controllable_textarea_value(
-            scopeId,
-            true ? `#${tag}/0` : 0,
-            input.value,
-            input.valueChange
-          )
-        );
-      } else if (content) {
-        if (tag === "select" && ("value" in input || "valueChange" in input)) {
-          controllable_select_value(
-            scopeId,
-            true ? `#${tag}/0` : 0,
-            input.value,
-            input.valueChange,
-            content
-          );
-        } else {
-          content();
+    resumeSingleNodeConditional(
+      () => {
+        nextScopeId();
+        write(`<${tag}${attrs(input, accessor, scopeId, tag)}>`);
+        if (!voidElementsReg.test(tag)) {
+          if (tag === "textarea") {
+            if (content) {
+              throw new Error(
+                "A dynamic tag rendering a `<textarea>` cannot have `content` and must use the `value` attribute instead."
+              );
+            }
+            write(
+              controllable_textarea_value(
+                scopeId,
+                accessor,
+                input.value,
+                input.valueChange
+              )
+            );
+          } else if (content) {
+            if (tag === "select" && ("value" in input || "valueChange" in input)) {
+              controllable_select_value(
+                scopeId,
+                accessor,
+                input.value,
+                input.valueChange,
+                content
+              );
+            } else {
+              content();
+            }
+          }
+          write(`</${tag}>`);
+        } else if (content) {
+          throw new Error(`Body content is not supported for a "${tag}" tag.`);
         }
-      }
-      write(`</${tag}>`);
-    } else if (content) {
-      throw new Error(`Body content is not supported for a "${tag}" tag.`);
-    }
-    return null;
+      },
+      scopeId,
+      accessor
+    );
+    return;
   }
   const renderer = getDynamicRenderer(tag);
   if (true) {
@@ -2254,22 +2401,36 @@ function dynamicTagInput(scope, tag, input, content, tagVar) {
       throw new Error(`Invalid renderer passed for dynamic tag: ${tag}`);
     }
   }
-  return renderer(content ? { ...input, content } : input, tagVar);
+  let result;
+  resumeConditional(
+    () => {
+      result = renderer(content ? { ...input, content } : input, tagVar);
+    },
+    scopeId,
+    accessor
+  );
+  return result;
 }
-function dynamicTagArgs(scope, tag, args) {
-  if (!tag) return void 0;
-  const scopeId = getScopeId(scope);
-  write(`${markResumeScopeStart(scopeId)}`);
-  writeScope(scopeId, scope);
-  if (typeof tag === "string") {
+function dynamicTagArgs(scopeId, accessor, tag, args) {
+  if (!tag) {
     nextScopeId();
-    write(
-      `<${tag}${attrs(args[0], true ? `#${tag}/0` : 0, scopeId, tag)}>`
+    return;
+  }
+  if (typeof tag === "string") {
+    resumeSingleNodeConditional(
+      () => {
+        nextScopeId();
+        write(
+          `<${tag}${attrs(args[0], accessor, scopeId, tag)}>`
+        );
+        if (!voidElementsReg.test(tag)) {
+          write(`</${tag}>`);
+        }
+      },
+      scopeId,
+      accessor
     );
-    if (!voidElementsReg.test(tag)) {
-      write(`</${tag}>`);
-    }
-    return void 0;
+    return;
   }
   const renderer = getDynamicRenderer(tag);
   if (true) {
@@ -2277,7 +2438,15 @@ function dynamicTagArgs(scope, tag, args) {
       throw new Error(`Invalid renderer passed for dynamic tag: ${tag}`);
     }
   }
-  return renderer(...args);
+  let result;
+  resumeConditional(
+    () => {
+      result = renderer(...args);
+    },
+    scopeId,
+    accessor
+  );
+  return result;
 }
 var getDynamicRenderer = normalizeDynamicRenderer;
 var createRenderer = (fn) => fn;
@@ -2373,28 +2542,6 @@ var compat = {
   }
 };
 
-// src/common/for.ts
-function forIn(obj, cb) {
-  for (const key in obj) {
-    cb(key, obj[key]);
-  }
-}
-function forOf(list, cb) {
-  if (list) {
-    let i = 0;
-    for (const item of list) {
-      cb(item, i++);
-    }
-  }
-}
-function forTo(to, from, step, cb) {
-  const start = from || 0;
-  const delta = step || 1;
-  for (let steps = (to - start) / delta, i = 0; i <= steps; i++) {
-    cb(start + i * delta);
-  }
-}
-
 // src/html/for.ts
 function forOfBy(by, item, index) {
   if (by) {
@@ -2660,11 +2807,7 @@ export {
   forToBy,
   fork,
   getScopeById,
-  markResumeCleanup,
-  markResumeControlEnd,
-  markResumeControlSingleNodeEnd,
   markResumeNode,
-  markResumeScopeStart,
   nextScopeId,
   nextTagId,
   nodeRef,
@@ -2673,6 +2816,15 @@ export {
   partialAttrs,
   peekNextScope,
   register2 as register,
+  resumeClosestBranch,
+  resumeConditional,
+  resumeForIn,
+  resumeForOf,
+  resumeForTo,
+  resumeSingleNodeConditional,
+  resumeSingleNodeForIn,
+  resumeSingleNodeForOf,
+  resumeSingleNodeForTo,
   styleAttr,
   toString,
   tryContent,

package/dist/dom/abort-signal.d.ts

@@ -1,3 +1,3 @@
 import type { Scope } from "../common/types";
 export declare function resetAbortSignal(scope: Scope, id: string | number): void;
-export declare function getAbortSignal(scope: Scope, id: string | number): any;
+export declare function getAbortSignal(scope: Scope, id: string | number): AbortSignal;

package/dist/dom/compat.d.ts

@@ -11,6 +11,7 @@ export declare const compat: {
     getStartNode(scope: any): any;
     setScopeNodes(scope: any, startNode: Node, endNode: Node): void;
     runComponentEffects(this: any): void;
+    runComponentDestroy(this: any): void;
     resolveRegistered(value: any, { runtimeId, componentIdPrefix, }: {
         runtimeId: string;
         componentIdPrefix: string;

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

@@ -1,14 +1,12 @@
-import { type Accessor, type Scope } from "../common/types";
+import { type Accessor, type BranchScope, type Scope } from "../common/types";
 import { type Renderer } from "./renderer";
-import { type IntersectionSignal, type SignalOp, type ValueSignal } from "./signals";
+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?: () => IntersectionSignal) => ValueSignal<Renderer | string | undefined>;
-export declare function inConditionalScope<S extends Scope>(signal: IntersectionSignal, nodeAccessor: Accessor): IntersectionSignal;
-export declare function setConditionalRenderer<ChildScope extends Scope>(scope: Scope, nodeAccessor: Accessor, newRenderer: Renderer | string | undefined): void;
-export declare let conditionalOnlyChild: (nodeAccessor: Accessor, fn?: ((scope: Scope) => void) | 0, getIntersection?: () => IntersectionSignal) => ValueSignal<Renderer | string | undefined>;
+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 const emptyMarkerArray: Scope[];
+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;
 export declare function loopTo(nodeAccessor: Accessor, renderer: Renderer): (scope: Scope, valueOrOp: SignalOp | [to: number, from: number, step: number, by?: ((v: number) => unknown) | undefined]) => void;
-export declare function inLoopScope(signal: IntersectionSignal, loopNodeAccessor: Accessor): (scope: Scope, op: SignalOp) => void;

package/dist/dom/queue.d.ts

@@ -1,8 +1,10 @@
 import type { Scope } from "../common/types";
-import { type ValueSignal } from "./signals";
+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: ValueSignal, value: T): T;
+export declare function queueSource<T>(scope: Scope, signal: Signal<T>, value: T): T;
+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[];

package/dist/dom/reconcile.d.ts

@@ -1,2 +1,2 @@
-import type { Scope } from "../common/types";
-export declare function reconcile(parent: Node & ParentNode, oldScopes: Scope[], newScopes: Scope[], afterReference: Node | null): void;
+import type { BranchScope } from "../common/types";
+export declare function reconcile(parent: Node & ParentNode, oldBranches: BranchScope[], newBranches: BranchScope[], afterReference: Node | null): void;

package/dist/dom/renderer.d.ts

@@ -1,21 +1,20 @@
-import { type Accessor, type Scope } from "../common/types";
-import { type IntersectionSignal, type SignalOp, type ValueSignal } from "./signals";
+import { type Accessor, type BranchScope, type Scope } from "../common/types";
+import { type Signal, type SignalOp } from "./signals";
 export type Renderer = {
     ___id: symbol;
     ___template: string;
     ___walks: string;
     ___setup: SetupFn | undefined;
-    ___closureSignals: Set<IntersectionSignal>;
     ___clone: () => Node;
     ___sourceNode: Node | undefined;
-    ___args: ValueSignal | undefined;
+    ___args: Signal<unknown> | undefined;
     ___owner: Scope | undefined;
 };
 type SetupFn = (scope: Scope) => void;
-export declare function createScopeWithRenderer(renderer: Renderer, $global: Scope["___global"], ownerScope?: Scope): Scope;
-export declare function createScopeWithTagNameOrRenderer(tagNameOrRenderer: Renderer | string, $global: Scope["___global"], ownerScope?: Scope): Scope;
+export declare function createBranchScopeWithRenderer(renderer: Renderer, $global: Scope["$global"], parentScope: Scope): BranchScope;
+export declare function createBranchScopeWithTagNameOrRenderer(tagNameOrRenderer: Renderer | string, $global: Scope["$global"], parentScope: Scope): BranchScope;
 export declare function initRenderer(renderer: Renderer, scope: Scope): Node;
 export declare function dynamicTagAttrs(nodeAccessor: Accessor, getContent?: (scope: Scope) => Renderer, inputIsArgs?: boolean): (scope: Scope, attrsOrOp: (() => Record<string, unknown>) | SignalOp) => void;
-export declare function createRendererWithOwner(template: string, rawWalks?: string, setup?: SetupFn, getClosureSignals?: () => IntersectionSignal[], getArgs?: () => ValueSignal): (owner?: Scope) => Renderer;
-export declare function createRenderer(template: string, walks?: string, setup?: SetupFn, getClosureSignals?: () => IntersectionSignal[], getArgs?: () => ValueSignal): Renderer;
+export declare function createRendererWithOwner(template: string, rawWalks?: string, setup?: SetupFn, getArgs?: () => Signal<unknown>): (owner?: Scope) => Renderer;
+export declare function createRenderer(template: string, walks?: string, setup?: SetupFn, getArgs?: () => Signal<unknown>): Renderer;
 export {};

package/dist/dom/resume.d.ts

@@ -1,9 +1,9 @@
 import { type Scope } from "../common/types";
-import type { IntersectionSignal, ValueSignal } from "./signals";
+import type { Signal } from "./signals";
 export declare let isResuming: boolean;
 export declare function register<T>(id: string, obj: T): T;
-export declare function registerBoundSignal<T extends ValueSignal>(id: string, signal: 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: IntersectionSignal): IntersectionSignal;
+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,7 +1,7 @@
-import type { Scope } from "../common/types";
+import type { BranchScope, Scope } from "../common/types";
 export declare function createScope($global: Scope["$global"]): Scope;
+export declare function finishPendingScopes(): void;
 export declare function getEmptyScope(marker: Comment): Scope;
-export declare function destroyScope(scope: Scope): Scope;
-export declare function onDestroy(scope: Scope): void;
-export declare function removeAndDestroyScope(scope: Scope): void;
+export declare function destroyBranch(branch: BranchScope): void;
+export declare function removeAndDestroyBranch(branch: BranchScope): void;
 export declare function insertBefore(scope: Scope, parent: Node & ParentNode, nextSibling: Node | null): void;

package/dist/dom/signals.d.ts

@@ -1,39 +1,26 @@
 import { type Accessor, type Scope } from "../common/types";
 import type { Renderer } from "./renderer";
-export type Signal = ValueSignal | IntersectionSignal;
 export declare const MARK: unique symbol;
 export declare const CLEAN: unique symbol;
 export declare const DIRTY: unique symbol;
 export type SignalOp = typeof MARK | typeof CLEAN | typeof DIRTY;
-export type SignalFn<T = unknown> = (scope: Scope, value: T) => void;
-export type ValueSignal<T = unknown> = SignalFn<T | SignalOp>;
-export type BoundValueSignal<T = unknown> = (valueOrOp: T | SignalOp) => void;
-export type IntersectionSignal = SignalFn<SignalOp> & {
+export type SignalFn<T> = (scope: Scope, value: T) => void;
+export type Signal<T> = ((scope: Scope, value: T | SignalOp) => void) & {
     ___subscribe?(scope: Scope): void;
-    ___unsubscribe?(scope: Scope): void;
 };
-export type BoundIntersectionSignal = ((op?: SignalOp) => void) & {
-    ___subscribe?(scope: Scope): void;
-    ___unsubscribe?(scope: Scope): void;
-};
-export declare function state<T>(valueAccessor: Accessor, fn: ValueSignal<T>, getIntersection?: () => IntersectionSignal): (scope: Scope, valueOrOp: T | SignalOp, valueChange?: (v: T) => void) => SignalOp | T;
-export declare function value<T>(valueAccessor: Accessor, fn: SignalFn<T> | 0, getIntersection?: () => IntersectionSignal): ValueSignal<T>;
-export declare function intersection(count: number, fn: SignalFn<never>, getIntersection?: () => IntersectionSignal): IntersectionSignal;
-export declare function closure<T>(ownerValueAccessor: Accessor | ((scope: Scope) => Accessor), fn: SignalFn<T> | 0, getOwnerScope?: (scope: Scope) => Scope, getIntersection?: () => IntersectionSignal): IntersectionSignal;
-export declare function dynamicClosure<T>(ownerValueAccessor: Accessor | ((scope: Scope) => Accessor), fn: ValueSignal<T> | 0, getOwnerScope?: (scope: Scope) => Scope, getIntersection?: () => IntersectionSignal): IntersectionSignal;
-export declare function childClosures(closureSignals: IntersectionSignal[], childAccessor: Accessor): {
-    (scope: Scope, op: SignalOp): void;
-    ___subscribe(scope: Scope): void;
-    ___unsubscribe(scope: Scope): void;
-};
-export declare function dynamicSubscribers(valueAccessor: Accessor): (scope: Scope, op: SignalOp) => void;
-export declare function setTagVar(scope: Scope, childAccessor: Accessor, tagVarSignal: ValueSignal): 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 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>(ownerValueAccessor: Accessor, fn: Signal<T> | 0, getOwnerScope?: (scope: Scope) => Scope, getIntersection?: () => Signal<never>): SignalFn<T>;
+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;
 export declare const tagVarSignalChange: (scope: Scope, value: unknown) => any;
-export declare const contentClosures: (content: Renderer | string | undefined, childScope: Scope, op: SignalOp) => void;
-export declare const inMany: (scopes: Scope[], op: SignalOp, signal: IntersectionSignal) => void;
+export declare const inMany: (scopes: Scope[], op: SignalOp, signal: Signal<never>) => void;
 export declare function nextTagId({ $global }: Scope): string;
-export declare function inChild(childAccessor: Accessor, signal: ValueSignal): (scope: Scope, valueOrOp: unknown | SignalOp) => void;
-export declare function intersections(signals: IntersectionSignal[]): IntersectionSignal;
+export declare function inChild(childAccessor: Accessor, signal: Signal<unknown>): (scope: Scope, valueOrOp: unknown | SignalOp) => void;
+export declare function intersections(signals: Signal<never>[]): Signal<never>;
 export declare function effect(id: string, fn: (scope: Scope) => void): (scope: Scope) => void;

package/dist/dom/template.d.ts

@@ -1,3 +1,3 @@
-import type { Scope, Template } from "../common/types";
+import type { Template } from "../common/types";
 import { createRenderer } from "./renderer";
-export declare const createTemplate: (templateId: string, template: string, walks?: string | undefined, setup?: ((scope: Scope) => void) | undefined, getClosureSignals?: (() => import("./signals").IntersectionSignal[]) | undefined, getArgs?: (() => import("./signals").ValueSignal) | undefined) => Template;
+export declare const createTemplate: (templateId: string, template: string, walks?: string | undefined, setup?: ((scope: import("../dom").Scope) => void) | undefined, getArgs?: (() => import("./signals").Signal<unknown>) | undefined) => Template;

package/dist/dom.d.ts

@@ -3,7 +3,7 @@ export { forIn, forOf, forTo } from "./common/for";
 export type { Scope } from "./common/types";
 export { getAbortSignal, resetAbortSignal } from "./dom/abort-signal";
 export { compat } from "./dom/compat";
-export { conditional, conditionalOnlyChild, inConditionalScope, inLoopScope, loopIn, loopOf, loopTo, } from "./dom/control-flow";
+export { conditional, conditionalOnlyChild, loopIn, loopOf, loopTo, } from "./dom/control-flow";
 export { controllable_detailsOrDialog_open, controllable_detailsOrDialog_open_effect, controllable_input_checked, controllable_input_checked_effect, controllable_input_checkedValue, controllable_input_checkedValue_effect, controllable_input_value, controllable_input_value_effect, controllable_select_value, controllable_select_value_effect, controllable_textarea_value, controllable_textarea_value_effect, } from "./dom/controllable";
 export { attr, attrs, attrsEvents, classAttr, data, html, lifecycle, partialAttrs, props, styleAttr, textContent, } from "./dom/dom";
 export { on } from "./dom/event";
@@ -11,5 +11,5 @@ export { run } from "./dom/queue";
 export { createRenderer, createRendererWithOwner, dynamicTagAttrs, } from "./dom/renderer";
 export { init, nodeRef, register, registerBoundSignal, registerSubscriber, } from "./dom/resume";
 export { createScope } from "./dom/scope";
-export { childClosures, closure, dynamicClosure, dynamicSubscribers, effect, inChild, intersection, intersections, nextTagId, setTagVar, setTagVarChange, state, tagVarSignal, tagVarSignalChange, value, } from "./dom/signals";
+export { conditionalClosure, dynamicClosure, effect, inChild, intersection, intersections, loopClosure, nextTagId, setTagVar, setTagVarChange, state, tagVarSignal, tagVarSignalChange, value, } from "./dom/signals";
 export { createTemplate } from "./dom/template";