marko 6.0.0-next.3.51 → 6.0.0-next.3.53

package/dist/translator/index.js

@@ -656,6 +656,7 @@ var pureFunctions = [
   "createContent",
   "createTemplate",
   "dynamicClosure",
+  "dynamicClosureRead",
   "intersection",
   "loopClosure",
   "loopIn",
@@ -902,6 +903,9 @@ function find(data, cb) {
     }
   }
 }
+function map(data, cb) {
+  return data ? Array.isArray(data) ? data.map(cb) : [cb(data, 0)] : [];
+}
 function findSorted(compare, data, item) {
   let max = data.length;
   let pos = 0;
@@ -978,17 +982,17 @@ function joinRepeatable(compare, a, b) {
 
 // src/translator/util/state.ts
 var createProgramState = (init) => {
-  const map = /* @__PURE__ */ new WeakMap();
+  const map2 = /* @__PURE__ */ new WeakMap();
   return [
     () => {
-      let state = map.get(currentProgramPath);
+      let state = map2.get(currentProgramPath);
       if (!state) {
-        map.set(currentProgramPath, state = init());
+        map2.set(currentProgramPath, state = init());
       }
       return state;
     },
     (value) => {
-      map.set(currentProgramPath, value);
+      map2.set(currentProgramPath, value);
     }
   ];
 };
@@ -1125,6 +1129,9 @@ function analyzeExpressionTagName(name2, extra) {
 }
 
 // src/translator/util/sections.ts
+var sectionUtil = new Sorted(function compareSections(a, b) {
+  return a.id - b.id;
+});
 function startSection(path5) {
   const extra = path5.node.extra ??= {};
   let section = extra.section;
@@ -1146,7 +1153,8 @@ function startSection(path5) {
       parent: parentSection,
       sectionAccessor: void 0,
       params: void 0,
-      closures: void 0,
+      referencedClosures: void 0,
+      referencedHoists: void 0,
       bindings: void 0,
       hoisted: void 0,
       isHoistThrough: void 0,
@@ -1288,10 +1296,16 @@ var isSerializedSection = (section) => {
 };
 var checkStatefulClosures = (section, immediateOnly) => {
   return !!find(
-    section.closures,
+    section.referencedClosures,
     (closure) => (!immediateOnly || section.parent === closure.section) && isStatefulReferences(closure)
   );
 };
+function isImmediateOwner(section, binding) {
+  return section.parent?.id === binding.section.id;
+}
+function isDynamicClosure(section, closure) {
+  return !section.isBranch || !isImmediateOwner(section, closure);
+}
 function isSameOrChildSection(section, other) {
   do {
     if (other === section) {
@@ -2058,7 +2072,17 @@ var [getSerializedScopeProperties] = createSectionState("serializedScopeProperti
 function setSerializedProperty(section, key, value) {
   getSerializedScopeProperties(section).set(key, value);
 }
-var [getSectionSubscriberIdentifier, setSectionSubscriberIdentifiers] = createSectionState("sectionSubscriberIdentifiers");
+var [getSectionWriteScopeBuilder, setSectionWriteScopeBuilder] = createSectionState(
+  "sectionWriteScopeBuilder"
+);
+function addWriteScopeBuilder(section, builder) {
+  const prev = getSectionWriteScopeBuilder(section);
+  setSectionWriteScopeBuilder(
+    section,
+    prev ? (expr) => builder(prev(expr)) : builder
+  );
+}
+var htmlDynamicClosureInstancesIdentifier = /* @__PURE__ */ new WeakMap();
 var [getHTMLSectionStatements] = createSectionState(
   "htmlScopeStatements",
   () => []
@@ -2100,7 +2124,6 @@ function getSignal(section, referencedBindings, name2 = generateSignalName(refer
         effect: [],
         effectReferencedBindings: void 0,
         subscribers: [],
-        closures: /* @__PURE__ */ new Map(),
         hasDownstreamIntersections: () => {
           let hasDownstreamIntersections = !!signal.intersection;
           if (!hasDownstreamIntersections) {
@@ -2152,53 +2175,22 @@ function getSignal(section, referencedBindings, name2 = generateSignalName(refer
           scopeOffset && getScopeAccessorLiteral(scopeOffset)
         );
       };
-    } else if (referencedBindings.section !== section && bindingUtil.find(section.closures, referencedBindings)) {
-      getSignal(referencedBindings.section, referencedBindings).closures.set(
-        section,
-        signal
-      );
+    } else if (referencedBindings.section !== section && bindingUtil.find(section.referencedClosures, referencedBindings)) {
       signal.build = () => {
-        const builder = getClosureSignalBuilder(section);
-        const ownerScope = getScopeExpression(
-          section,
-          referencedBindings.section
-        );
-        const isImmediateOwner = ownerScope.object === scopeIdentifier;
-        const isDynamicClosure = !isImmediateOwner || !builder;
         const render = getSignalFn(signal, [
           scopeIdentifier,
           import_compiler17.types.identifier(referencedBindings.name)
         ]);
-        return isDynamicClosure ? isStatefulReferences(referencedBindings) ? callRuntime(
-          "registerDynamicClosure",
-          import_compiler17.types.stringLiteral(
-            getResumeRegisterId(
-              section,
-              signal.referencedBindings,
-              "subscriber"
-            )
-          ),
-          getScopeAccessorLiteral(referencedBindings),
-          render,
-          isImmediateOwner ? void 0 : import_compiler17.types.arrowFunctionExpression([scopeIdentifier], ownerScope)
-        ) : callRuntime(
-          "dynamicClosure",
+        return isDynamicClosure(section, referencedBindings) ? callRuntime(
+          "dynamicClosureRead",
           getScopeAccessorLiteral(referencedBindings),
           render,
-          isImmediateOwner ? void 0 : import_compiler17.types.arrowFunctionExpression([scopeIdentifier], ownerScope)
-        ) : builder(signal, render);
-      };
-      addStatement(
-        "render",
-        section,
-        void 0,
-        import_compiler17.types.expressionStatement(
-          import_compiler17.types.callExpression(
-            import_compiler17.types.memberExpression(signal.identifier, import_compiler17.types.identifier("_")),
-            [scopeIdentifier]
+          isImmediateOwner(section, referencedBindings) ? void 0 : import_compiler17.types.arrowFunctionExpression(
+            [scopeIdentifier],
+            getScopeExpression(section, referencedBindings.section)
           )
-        )
-      );
+        ) : getClosureSignalBuilder(section)(referencedBindings, render);
+      };
     }
   }
   return signal;
@@ -2283,17 +2275,47 @@ function getSignalFn(signal, params, referencedBindings) {
     );
   });
   if (isValueSignal) {
-    const closureEntries = Array.from(signal.closures.entries()).sort(
-      ([a], [b]) => a.id - b.id
-    );
-    for (const [_closureSection, closureSignal] of closureEntries) {
-      if (isStatefulReferences(closureSignal.referencedBindings)) {
-        signal.render.push(
-          import_compiler17.types.expressionStatement(
-            import_compiler17.types.callExpression(closureSignal.identifier, [scopeIdentifier2])
-          )
-        );
+    let dynamicClosureArgs;
+    let dynamicClosureSignalIdentifier;
+    forEach(binding.closureSections, (closureSection) => {
+      if (isStatefulReferences(binding)) {
+        if (isDynamicClosure(closureSection, binding)) {
+          if (!dynamicClosureArgs) {
+            dynamicClosureArgs = [];
+            dynamicClosureSignalIdentifier = currentProgramPath.scope.generateUidIdentifier(
+              signal.identifier.name + "_closure"
+            );
+            signal.render.push(
+              import_compiler17.types.expressionStatement(
+                import_compiler17.types.callExpression(dynamicClosureSignalIdentifier, [
+                  scopeIdentifier2
+                ])
+              )
+            );
+          }
+          dynamicClosureArgs.push(
+            getSignal(closureSection, binding).identifier
+          );
+        } else {
+          signal.render.push(
+            import_compiler17.types.expressionStatement(
+              import_compiler17.types.callExpression(getSignal(closureSection, binding).identifier, [
+                scopeIdentifier2
+              ])
+            )
+          );
+        }
       }
+    });
+    if (dynamicClosureSignalIdentifier) {
+      (signal.prependStatements ||= []).push(
+        import_compiler17.types.variableDeclaration("const", [
+          import_compiler17.types.variableDeclarator(
+            dynamicClosureSignalIdentifier,
+            callRuntime("dynamicClosure", ...dynamicClosureArgs)
+          )
+        ])
+      );
     }
   }
   if (signal.effect.length) {
@@ -2468,7 +2490,7 @@ function writeSignals(section) {
       while (currentSection && currentSection !== hoistedBinding.section) {
         const parentSection = currentSection.parent;
         if (parentSection) {
-          accessors.push(getSectionScopeAccessorLiteral(currentSection));
+          accessors.push(getSectionInstancesAccessorLiteral(currentSection));
         }
         currentSection = parentSection;
       }
@@ -2556,13 +2578,12 @@ function writeSignals(section) {
     if (signal.export) {
       signalDeclaration = import_compiler17.types.exportNamedDeclaration(signalDeclaration);
     }
-    currentProgramPath.pushContainer(
-      "body",
-      effectDeclarator ? [
-        import_compiler17.types.variableDeclaration("const", [effectDeclarator]),
-        signalDeclaration
-      ] : signalDeclaration
-    );
+    const signalStatements = signal.prependStatements || [];
+    if (effectDeclarator) {
+      signalStatements.push(import_compiler17.types.variableDeclaration("const", [effectDeclarator]));
+    }
+    signalStatements.push(signalDeclaration);
+    currentProgramPath.pushContainer("body", signalStatements);
   }
 }
 function writeRegisteredFns() {
@@ -2654,9 +2675,9 @@ function writeHTMLResumeStatements(path5) {
   if (!section) return;
   const allSignals = Array.from(getSignals(section).values());
   const scopeIdIdentifier = getScopeIdIdentifier(section);
-  forEach(section.assignments, (assignment) => {
+  const serializeOwnersUntilBindingSection = (binding) => {
     let currentSection = section;
-    while (currentSection !== assignment.section) {
+    while (currentSection !== binding.section) {
       const currentSerialized = getSerializedScopeProperties(currentSection);
       currentSection = currentSection.parent;
       if (!currentSerialized.has("_")) {
@@ -2669,38 +2690,45 @@ function writeHTMLResumeStatements(path5) {
         );
       }
     }
-  });
-  forEach(section.closures, (closure) => {
+  };
+  forEach(section.assignments, serializeOwnersUntilBindingSection);
+  forEach(section.referencedHoists, serializeOwnersUntilBindingSection);
+  forEach(section.referencedClosures, (closure) => {
     if (isStatefulReferences(closure)) {
-      let currentSection = section;
-      while (currentSection !== closure.section) {
-        const currentSerialized = getSerializedScopeProperties(currentSection);
-        currentSection = currentSection.parent;
-        if (!currentSerialized.has("_")) {
-          currentSerialized.set(
-            "_",
-            callRuntime(
-              "ensureScopeWithId",
-              getScopeIdIdentifier(currentSection)
+      serializeOwnersUntilBindingSection(closure);
+      setForceResumeScope(closure.section);
+      if (isDynamicClosure(section, closure)) {
+        const closureSignal = getSignal(closure.section, closure);
+        let identifier = htmlDynamicClosureInstancesIdentifier.get(closureSignal);
+        if (!identifier) {
+          htmlDynamicClosureInstancesIdentifier.set(
+            closureSignal,
+            identifier = currentProgramPath.scope.generateUidIdentifier(
+              closureSignal.identifier.name + "_closures"
             )
           );
-        }
-      }
-      setForceResumeScope(closure.section);
-      const isImmediateOwner = section.parent?.id === closure.section.id;
-      const isDynamicClosure = !getClosureSignalBuilder(section) || !isImmediateOwner;
-      if (isDynamicClosure) {
-        path5.pushContainer(
-          "body",
-          import_compiler17.types.expressionStatement(
-            callRuntime(
-              "writeEffect",
-              scopeIdIdentifier,
-              import_compiler17.types.stringLiteral(
-                getResumeRegisterId(section, closure, "subscriber")
+          getHTMLSectionStatements(closure.section).push(
+            import_compiler17.types.variableDeclaration("const", [
+              import_compiler17.types.variableDeclarator(
+                identifier,
+                import_compiler17.types.newExpression(import_compiler17.types.identifier("Set"), [])
               )
-            )
-          )
+            ])
+          );
+          setSerializedProperty(
+            closure.section,
+            getScopeAccessor(closure) + "!" /* ClosureScopes */,
+            identifier
+          );
+        }
+        setSerializedProperty(
+          section,
+          getScopeAccessor(closure) + "(" /* ClosureSignalIndex */,
+          import_compiler17.types.numericLiteral(getDynamicClosureIndex(closure, section))
+        );
+        addWriteScopeBuilder(
+          section,
+          (expr) => callRuntime("writeSubscribe", identifier, expr)
         );
       }
     }
@@ -2744,13 +2772,13 @@ function writeHTMLResumeStatements(path5) {
               )
             ])
           );
-          setSectionSubscriberIdentifiers(
+          addWriteScopeBuilder(
             currentSection,
-            subscribersIdentifier
+            (expr) => callRuntime("writeSubscribe", subscribersIdentifier, expr)
           );
           setSerializedProperty(
             parentSection,
-            getSectionScopeAccessor(currentSection),
+            getSectionInstancesAccessor(currentSection),
             subscribersIdentifier
           );
         }
@@ -2794,8 +2822,8 @@ function writeHTMLResumeStatements(path5) {
   for (const [key, value] of serializedLookup) {
     serializedProperties.push(toObjectProperty(key, value));
   }
-  const subscriberIdentifier = getSectionSubscriberIdentifier(section);
-  if (serializedProperties.length || forceResumeScope(section) || subscriberIdentifier) {
+  const writeScopeBuilder = getSectionWriteScopeBuilder(section);
+  if (writeScopeBuilder || serializedProperties.length || forceResumeScope(section)) {
     for (const prop of serializedProperties) {
       if (prop.key.type === "Identifier" && prop.value.type === "Identifier" && prop.key.name === prop.value.name) {
         prop.shorthand = true;
@@ -2842,15 +2870,11 @@ function writeHTMLResumeStatements(path5) {
     path5.pushContainer(
       "body",
       import_compiler17.types.expressionStatement(
-        subscriberIdentifier ? callRuntime(
-          "writeSubscribe",
-          subscriberIdentifier,
-          callRuntime("writeScope", ...writeScopeArgs)
-        ) : callRuntime("writeScope", ...writeScopeArgs)
+        writeScopeBuilder ? writeScopeBuilder(callRuntime("writeScope", ...writeScopeArgs)) : callRuntime("writeScope", ...writeScopeArgs)
       )
     );
   }
-  const resumeClosestBranch2 = !section.isBranch && (section.hasAbortSignal || !!section.closures || !!find(section.bindings, (binding) => binding.type === 1 /* let */));
+  const resumeClosestBranch2 = !section.isBranch && (section.hasAbortSignal || !!section.referencedClosures || !!find(section.bindings, (binding) => binding.type === 1 /* let */));
   if (resumeClosestBranch2) {
     path5.pushContainer(
       "body",
@@ -3040,6 +3064,17 @@ function getRegisteredFnExpression(node) {
     }
   }
 }
+function getDynamicClosureIndex(closure, closureSection) {
+  let index = 0;
+  find(closure.closureSections, (section) => {
+    if (section === closureSection) return true;
+    if (isDynamicClosure(section, closure)) {
+      index++;
+    }
+    return false;
+  });
+  return index;
+}
 
 // src/translator/visitors/program/dom.ts
 var dom_default = {
@@ -3062,15 +3097,32 @@ var dom_default = {
         if (childSection !== section) {
           const tagParamsSignal = childSection.params && initValue(childSection.params);
           const { walks: walks2, writes: writes2, setup: setup2 } = getSectionMeta(childSection);
-          const params = tagParamsSignal?.identifier && import_compiler18.types.arrowFunctionExpression([], tagParamsSignal.identifier);
           const identifier = import_compiler18.types.identifier(childSection.name);
+          const referencedClosures = childSection.referencedClosures ? import_compiler18.types.arrowFunctionExpression(
+            [scopeIdentifier],
+            toFirstExpressionOrBlock(
+              map(childSection.referencedClosures, (closure) => {
+                const closureSignal = getSignal(childSection, closure);
+                return import_compiler18.types.expressionStatement(
+                  import_compiler18.types.callExpression(
+                    isDynamicClosure(childSection, closure) ? closureSignal.identifier : import_compiler18.types.memberExpression(
+                      closureSignal.identifier,
+                      import_compiler18.types.identifier("_")
+                    ),
+                    [scopeIdentifier]
+                  )
+                );
+              })
+            )
+          ) : void 0;
           const renderer = getSectionParentIsOwner(childSection) ? callRuntime(
             "createRenderer",
             ...replaceNullishAndEmptyFunctionsWith0([
               writes2,
               walks2,
               setup2,
-              params
+              tagParamsSignal?.identifier,
+              referencedClosures
             ])
           ) : callRuntime(
             isSerializedSection(childSection) ? "registerContent" : "createContent",
@@ -3079,8 +3131,9 @@ var dom_default = {
               writes2,
               walks2,
               setup2,
-              params,
-              childSection.hoisted || childSection.isHoistThrough ? getSectionScopeAccessorLiteral(childSection) : void 0
+              tagParamsSignal?.identifier,
+              referencedClosures,
+              childSection.hoisted || childSection.isHoistThrough ? getSectionInstancesAccessorLiteral(childSection) : void 0
             ])
           );
           writeSignals(childSection);
@@ -3511,6 +3564,7 @@ function createBinding(name2, type, section, upstreamAlias, upstreamExpression,
     section,
     property,
     declared,
+    closureSections: void 0,
     excludeProperties: void 0,
     serialize: false,
     aliases: /* @__PURE__ */ new Set(),
@@ -3622,12 +3676,10 @@ function trackHoistedReference(referencePath, binding) {
   } else {
     trackReference(referencePath, hoistedBinding);
   }
-  if (referenceSection !== hoistSection) {
-    referenceSection.closures = bindingUtil.add(
-      referenceSection.closures,
-      hoistedBinding
-    );
-  }
+  referenceSection.referencedHoists = bindingUtil.add(
+    referenceSection.referencedHoists,
+    hoistedBinding
+  );
 }
 function trackReferencesForBinding(babelBinding) {
   const { identifier, referencePaths, constantViolations } = babelBinding;
@@ -3914,7 +3966,14 @@ function finalizeReferences() {
       section: section2
     } of binding.downstreamExpressions) {
       if (section2 !== binding.section) {
-        section2.closures = bindingUtil.add(section2.closures, binding);
+        binding.closureSections = sectionUtil.add(
+          binding.closureSections,
+          section2
+        );
+        section2.referencedClosures = bindingUtil.add(
+          section2.referencedClosures,
+          binding
+        );
       }
       if (isEffect) {
         forEach(referencedBindings, (bindingReference) => {
@@ -3944,7 +4003,7 @@ function finalizeReferences() {
         }
       }
     }
-    forEach(section.closures, (binding) => {
+    forEach(section.referencedClosures, (binding) => {
       if (!binding.serialize) {
         let serialize = false;
         const sourceSection = binding.section;
@@ -4102,11 +4161,11 @@ function getScopeAccessor(binding, includeId) {
   }
   return binding.name + (includeId || binding.type === 0 /* dom */ ? `/${binding.id}` : "");
 }
-function getSectionScopeAccessor(section) {
-  return section.sectionAccessor ? getScopeAccessor(section.sectionAccessor.binding) + section.sectionAccessor.suffix : section.id + "?" /* Dynamic */;
+function getSectionInstancesAccessor(section) {
+  return section.sectionAccessor ? getScopeAccessor(section.sectionAccessor.binding) + section.sectionAccessor.suffix : section.id + "!" /* ClosureScopes */;
 }
-function getSectionScopeAccessorLiteral(section) {
-  const accessor = getSectionScopeAccessor(section);
+function getSectionInstancesAccessorLiteral(section) {
+  const accessor = getSectionInstancesAccessor(section);
   return accessor ? typeof accessor === "number" ? import_compiler22.types.numericLiteral(accessor) : import_compiler22.types.stringLiteral(accessor) : void 0;
 }
 function getReadReplacement(node) {
@@ -5229,10 +5288,13 @@ var native_tag_default = {
       } else {
         tag.insertBefore(tag.node.body.body).forEach((child) => child.skip());
       }
+      const shouldMark = nodeRef2 && (extra[kSerializeMarker] || extra[kSerializeMarker] === void 0 && (isStatefulReferences(extra.referencedBindings) || tag.node.attributes.some(
+        (attr2) => isStatefulReferences(attr2.value.extra?.referencedBindings)
+      )));
       if (!openTagOnly && !selectArgs) {
         writeTo(
           tag,
-          isHTML && (tagName === "html" || tagName === "body")
+          isHTML && !shouldMark && (tagName === "html" || tagName === "body")
         )`</${tag.node.name}>`;
       }
       if (isHTML && extra.tagNameNullable) {
@@ -5240,9 +5302,7 @@ var native_tag_default = {
           import_compiler29.types.ifStatement(tag.node.name, consumeHTML(tag))
         )[0].skip();
       }
-      if (nodeRef2 && (extra[kSerializeMarker] || extra[kSerializeMarker] === void 0 && (isStatefulReferences(extra.referencedBindings) || tag.node.attributes.some(
-        (attr2) => isStatefulReferences(attr2.value.extra?.referencedBindings)
-      )))) {
+      if (shouldMark) {
         markNode(tag, nodeRef2);
       }
       exit2(tag);
@@ -5443,7 +5503,7 @@ var for_default = {
         const statements = [];
         const bodyStatements = node.body.body;
         const hasStatefulClosures = checkStatefulClosures(bodySection, true);
-        const hasHoists = bodySection.hoisted || bodySection.isHoistThrough;
+        const hasHoists = bodySection.hoisted || bodySection.isHoistThrough || bodySection.referencedHoists;
         const singleNodeOptimization = bodySection.content === null || bodySection.content.singleChild && bodySection.content.startType !== 4 /* Text */;
         let keyExpression;
         if (isStateful && onlyChildInParentOptimization) {
@@ -5536,8 +5596,6 @@ var for_default = {
           );
         }
         flushInto(tag);
-        setClosureSignalBuilder(tag, () => {
-        });
         writeHTMLResumeStatements(tagBody);
         const forTagArgs = getBaseArgsInForTag(forType, forAttrs);
         const forTagHTMLRuntime = isStateful ? forTypeToHTMLResumeRuntime(forType, singleNodeOptimization) : forTypeToRuntime(forType);
@@ -5585,12 +5643,10 @@ var for_default = {
         const tagExtra = node.extra;
         const { referencedBindings } = tagExtra;
         const nodeRef2 = getOptimizedOnlyChildNodeRef(tag, tagSection);
-        setClosureSignalBuilder(tag, (closureSignal, render) => {
+        setClosureSignalBuilder(tag, (closure, render) => {
           return callRuntime(
             "loopClosure",
-            getScopeAccessorLiteral(
-              closureSignal.referencedBindings
-            ),
+            getScopeAccessorLiteral(closure),
             getScopeAccessorLiteral(nodeRef2),
             render
           );
@@ -7339,14 +7395,12 @@ var IfTag = {
         const isStateful = isStatefulReferences(rootExtra.referencedBindings);
         const singleNodeOptimization = rootExtra.singleNodeOptimization;
         const hasStatefulClosures = bodySection && checkStatefulClosures(bodySection, true);
-        const hasHoists = bodySection && (bodySection.hoisted || bodySection.isHoistThrough);
+        const hasHoists = bodySection && (bodySection.hoisted || bodySection.isHoistThrough || bodySection.referencedHoists);
         if (bodySection) {
           if (isStateful || hasStatefulClosures || hasHoists) {
             setForceResumeScope(bodySection);
           }
           flushInto(tag);
-          setClosureSignalBuilder(tag, () => {
-          });
           writeHTMLResumeStatements(tagBody);
         }
         if (isLast) {
@@ -7367,6 +7421,7 @@ var IfTag = {
                 branchBodySection,
                 true
               );
+              const branchHasHoists = branchBodySection.hoisted || branchBodySection.isHoistThrough || branchBodySection.referencedHoists;
               if (isStateful) {
                 bodyStatements.push(
                   import_compiler40.types.expressionStatement(
@@ -7378,7 +7433,7 @@ var IfTag = {
                   )
                 );
               }
-              if (isStateful || branchHasStatefulClosures || hasHoists) {
+              if (isStateful || branchHasStatefulClosures || branchHasHoists) {
                 bodyStatements.push(
                   import_compiler40.types.expressionStatement(
                     import_compiler40.types.assignmentExpression(
@@ -7482,12 +7537,10 @@ var IfTag = {
             const consequent = import_compiler40.types.numericLiteral(branchBodySection ? i : -1);
             if (branchBodySection) {
               rendererIdentifiers.push(import_compiler40.types.identifier(branchBodySection.name));
-              setClosureSignalBuilder(branchTag, (closureSignal, render) => {
+              setClosureSignalBuilder(branchTag, (closure, render) => {
                 return callRuntime(
                   "conditionalClosure",
-                  getScopeAccessorLiteral(
-                    closureSignal.referencedBindings
-                  ),
+                  getScopeAccessorLiteral(closure),
                   getScopeAccessorLiteral(nodeRef2),
                   import_compiler40.types.numericLiteral(i),
                   render
@@ -8136,27 +8189,27 @@ var style_default = {
     const start = (0, import_babel_utils36.getStart)(file, markoText);
     const end = (0, import_babel_utils36.getEnd)(file, markoText);
     let code = markoText.value;
-    let map;
+    let map2;
     if (resolveVirtualDependency && sourceMaps && start !== null && end !== null) {
       const magicString = new import_magic_string.default(file.code, { filename });
       magicString.remove(0, start);
       magicString.remove(end, file.code.length);
-      map = magicString.generateMap({
+      map2 = magicString.generateMap({
         source: filename,
         includeContent: true
       });
       if (sourceMaps === "inline" || sourceMaps === "both") {
         code += `
-/*# sourceMappingURL=${map.toUrl()}*/`;
+/*# sourceMappingURL=${map2.toUrl()}*/`;
         if (sourceMaps === "inline") {
-          map = void 0;
+          map2 = void 0;
         }
       }
     }
     const importPath = resolveVirtualDependency?.(filename, {
       virtualPath: `./${import_path3.default.basename(filename) + ext}`,
       code,
-      map
+      map: map2
     });
     if (importPath) {
       if (!node.var) {

package/dist/translator/util/references.d.ts

@@ -19,6 +19,7 @@ export type Binding = {
     type: BindingType;
     loc: t.SourceLocation | null;
     section: Section;
+    closureSections: Opt<Section>;
     serialize: boolean;
     aliases: Set<Binding>;
     hoists: Map<Section, Binding>;
@@ -79,8 +80,8 @@ export declare function getCanonicalBinding(binding?: Binding): Binding | undefi
 export declare function getAllTagReferenceNodes(tag: t.MarkoTag, referenceNodes?: t.Node[]): t.Node[];
 export declare function getScopeAccessorLiteral(binding: Binding, includeId?: boolean): t.StringLiteral | t.NumericLiteral;
 export declare function getScopeAccessor(binding: Binding, includeId?: boolean): string;
-export declare function getSectionScopeAccessor(section: Section): string;
-export declare function getSectionScopeAccessorLiteral(section: Section): t.StringLiteral | t.NumericLiteral | undefined;
+export declare function getSectionInstancesAccessor(section: Section): string;
+export declare function getSectionInstancesAccessorLiteral(section: Section): t.StringLiteral | t.NumericLiteral | undefined;
 export declare function getReadReplacement(node: t.Identifier | t.MemberExpression): t.Node | undefined;
 export interface ReferencedExtra extends t.NodeExtra {
     section: Section;