@marko/runtime-tags 6.0.112 → 6.0.114

package/README.md

@@ -1,6 +1,6 @@
 <div align="center">
 
-# [<img alt="Marko" src="https://raw.githubusercontent.com/marko-js/website-next/refs/heads/main/public/logo.svg" width="250">](https://markojs.com/)
+# [<img alt="Marko" src="https://raw.githubusercontent.com/marko-js/website/refs/heads/main/public/assets/logo.svg" width="250">](https://markojs.com/)
 
 **A declarative, HTML-based language that makes building web apps fun 🔥**
 

package/dist/common/accessor.d.ts

@@ -18,6 +18,7 @@ export declare enum AccessorProp {
     Owner = "_",
     AbortControllers = "A",
     AbortScopes = "B",
+    AwaitCounter = "O",
     BranchAccessor = "C",
     BranchScopes = "D",
     CatchContent = "E",
@@ -25,12 +26,11 @@ export declare enum AccessorProp {
     ClosestBranchId = "G",
     Creating = "H",
     Destroyed = "I",
-    PendingEffects = "J",
     EndNode = "K",
     Id = "L",
     LoopKey = "M",
     ParentBranch = "N",
-    PendingAsyncCount = "O",
+    PendingEffects = "J",
     PlaceholderBranch = "P",
     PlaceholderContent = "Q",
     Renderer = "R",

package/dist/common/accessor.debug.d.ts

@@ -18,6 +18,7 @@ export declare enum AccessorProp {
     Owner = "_",
     AbortControllers = "#AbortControllers",
     AbortScopes = "#AbortScopes",
+    AwaitCounter = "#AwaitCounter",
     BranchAccessor = "#BranchAccessor",
     BranchScopes = "#BranchScopes",
     CatchContent = "#CatchContent",
@@ -25,12 +26,11 @@ export declare enum AccessorProp {
     ClosestBranchId = "#ClosestBranchId",
     Creating = "#Creating",
     Destroyed = "#Destroyed",
-    PendingEffects = "#PendingEffects",
     EndNode = "#EndNode",
     Id = "#Id",
     LoopKey = "#LoopKey",
     ParentBranch = "#ParentBranch",
-    PendingAsyncCount = "#PendingAsyncCount",
+    PendingEffects = "#PendingEffects",
     PlaceholderBranch = "#PlaceholderBranch",
     PlaceholderContent = "#PlaceholderContent",
     Renderer = "#Renderer",

package/dist/common/types.d.ts

@@ -10,7 +10,7 @@ export interface BranchScope extends Scope {
     [AccessorProp.AbortScopes]: Set<Scope> | undefined;
     [AccessorProp.BranchScopes]: Set<BranchScope> | undefined;
     [AccessorProp.Renderer]: ClientRenderer | string;
-    [AccessorProp.PendingAsyncCount]: number | undefined;
+    [AccessorProp.AwaitCounter]: AwaitCounter | undefined;
     [AccessorProp.PendingEffects]: unknown[] | undefined;
 }
 export interface Scope {
@@ -33,6 +33,11 @@ export declare enum ResumeSymbol {
     BranchEndOnlyChildInParent = ")",
     BranchEndSingleNodeOnlyChildInParent = "}"
 }
+export interface AwaitCounter {
+    d?: 1;
+    i: number;
+    c: () => void;
+}
 export { AccessorPrefix, AccessorProp } from "./accessor.debug";
 export declare enum NodeType {
     Element = 1,

package/dist/debug/dom.js

@@ -50,7 +50,8 @@ __export(dom_exports, {
   _attrs_partial: () => _attrs_partial,
   _attrs_partial_content: () => _attrs_partial_content,
   _attrs_script: () => _attrs_script,
-  _await: () => _await,
+  _await_content: () => _await_content,
+  _await_promise: () => _await_promise,
   _call: () => _call,
   _child_setup: () => _child_setup,
   _closure: () => _closure,
@@ -615,60 +616,64 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
         let lastScopeId = 0;
         const nextToken = () => lastToken = visitText.slice(
           lastTokenIndex,
-          // eslint-disable-next-line no-cond-assign
-          (lastTokenIndex = visitText.indexOf(" ", lastTokenIndex) + 1) ? lastTokenIndex - 1 : visitText.length
+          (lastTokenIndex = visitText.indexOf(" ", lastTokenIndex) + 1 || visitText.length + 1) - 1
         );
-        render.w = (effects = []) => {
-          try {
-            walk2();
-            isResuming = 1;
-            for (const serialized of resumes = render.r || []) {
-              if (typeof serialized === "string") {
-                lastEffect = serialized;
-              } else if (typeof serialized === "number") {
-                effects.push(
-                  registeredValues[lastEffect],
-                  scopeLookup[serialized] ||= {
-                    ["#Id" /* Id */]: serialized
-                  }
-                );
-              } else {
-                for (const scope of serialized(serializeContext)) {
-                  if (!$global) {
-                    $global = scope || {};
-                    $global.runtimeId = runtimeId;
-                    $global.renderId = renderId;
-                  } else if (typeof scope === "number") {
-                    lastScopeId += scope;
-                  } else {
-                    scopeLookup[scope["#Id" /* Id */] = ++lastScopeId] = scope;
-                    scope["$global" /* Global */] = $global;
-                    if (branchesEnabled) {
-                      scope["#ClosestBranch" /* ClosestBranch */] = scopeLookup[scope["#ClosestBranchId" /* ClosestBranchId */]];
+        render.m = (effects = []) => {
+          for (const serialized of resumes = render.r || []) {
+            if (typeof serialized === "string") {
+              lastTokenIndex = 0;
+              visitText = serialized;
+              while (nextToken()) {
+                if (/\D/.test(lastToken)) {
+                  lastEffect = registeredValues[lastToken];
+                } else {
+                  effects.push(
+                    lastEffect,
+                    scopeLookup[lastToken] ||= {
+                      ["#Id" /* Id */]: +lastToken
                     }
+                  );
+                }
+              }
+            } else {
+              for (const scope of serialized(serializeContext)) {
+                if (!$global) {
+                  $global = scope || {};
+                  $global.runtimeId = runtimeId;
+                  $global.renderId = renderId;
+                } else if (typeof scope === "number") {
+                  lastScopeId += scope;
+                } else {
+                  scopeLookup[scope["#Id" /* Id */] = ++lastScopeId] = scope;
+                  scope["$global" /* Global */] = $global;
+                  if (branchesEnabled) {
+                    scope["#ClosestBranch" /* ClosestBranch */] = scopeLookup[scope["#ClosestBranchId" /* ClosestBranchId */]];
                   }
                 }
               }
             }
-            for (visit of visits = render.v) {
-              lastTokenIndex = render.i.length;
-              visitText = visit.data;
-              visitType = visitText[lastTokenIndex++];
-              visitScope = scopeLookup[+nextToken(
-                /* read scope id */
-              )] ||= {
-                ["#Id" /* Id */]: +lastToken
-              };
-              if (visitType === "*" /* Node */) {
-                visitScope["Getter:" /* Getter */ + nextToken()] = /* @__PURE__ */ ((node) => () => node)(visitScope[lastToken] = visit.previousSibling);
-              } else if (branchesEnabled) {
-                visitBranches();
-              }
+          }
+          for (visit of visits = render.v) {
+            lastTokenIndex = render.i.length;
+            visitText = visit.data;
+            visitType = visitText[lastTokenIndex++];
+            visitScope = scopeLookup[+nextToken(
+              /* read scope id */
+            )] ||= {
+              ["#Id" /* Id */]: +lastToken
+            };
+            if (visitType === "*" /* Node */) {
+              visitScope["Getter:" /* Getter */ + nextToken()] = /* @__PURE__ */ ((node) => () => node)(visitScope[lastToken] = visit.previousSibling);
+            } else if (branchesEnabled) {
+              visitBranches();
             }
-            runEffects(effects);
-          } finally {
-            isResuming = visits.length = resumes.length = 0;
           }
+          visits.length = resumes.length = 0;
+          return effects;
+        };
+        render.w = () => {
+          walk2();
+          runResumeEffects(render);
         };
         return render;
       })
@@ -677,7 +682,7 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
   if (renders) {
     initRuntime(renders);
     for (const renderId in renders) {
-      resumeRender(renderId).w();
+      runResumeEffects(resumeRender(renderId));
     }
   } else {
     defineRuntime({
@@ -687,6 +692,14 @@ function init(runtimeId = DEFAULT_RUNTIME_ID) {
   }
 }
 var isResuming;
+function runResumeEffects(render) {
+  try {
+    isResuming = 1;
+    runEffects(render.m(), 1);
+  } finally {
+    isResuming = 0;
+  }
+}
 function getRegisteredWithScope(id, scope) {
   const val = registeredValues[id];
   return scope ? val(scope) : val;
@@ -1773,24 +1786,52 @@ function longestIncreasingSubsequence(a) {
 }
 
 // src/dom/control-flow.ts
-function _await(nodeAccessor, template, walks, setup, params) {
+function _await_promise(nodeAccessor, params) {
   if (false) nodeAccessor = decodeAccessor4(nodeAccessor);
   const promiseAccessor = "Promise:" /* Promise */ + nodeAccessor;
   const branchAccessor = "BranchScopes:" /* BranchScopes */ + nodeAccessor;
-  const renderer = _content("", template, walks, setup)();
-  enableBranches();
+  const rendererAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + nodeAccessor;
+  _enable_catch();
   return (scope, promise) => {
-    const referenceNode = scope[nodeAccessor];
+    let awaitCounter;
+    let renderData;
     const tryWithPlaceholder = findBranchWithKey(
       scope,
       "#PlaceholderContent" /* PlaceholderContent */
     );
-    let awaitBranch = scope[branchAccessor];
     if (tryWithPlaceholder) {
+      renderData = self[tryWithPlaceholder["$global" /* Global */].runtimeId]?.[tryWithPlaceholder["$global" /* Global */].renderId];
+      awaitCounter = tryWithPlaceholder["#AwaitCounter" /* AwaitCounter */] ||= renderData?.p?.[tryWithPlaceholder["#Id" /* Id */]];
+      if (!awaitCounter?.i) {
+        awaitCounter = tryWithPlaceholder["#AwaitCounter" /* AwaitCounter */] = {
+          d: 1,
+          i: 0,
+          c() {
+            if (!--awaitCounter.i) {
+              const placeholderBranch = tryWithPlaceholder["#PlaceholderBranch" /* PlaceholderBranch */];
+              tryWithPlaceholder["#PlaceholderBranch" /* PlaceholderBranch */] = 0;
+              if (placeholderBranch) {
+                placeholderBranch["#StartNode" /* StartNode */].parentNode.insertBefore(
+                  tryWithPlaceholder["#StartNode" /* StartNode */].parentNode,
+                  placeholderBranch["#StartNode" /* StartNode */]
+                );
+                removeAndDestroyBranch(placeholderBranch);
+              }
+              queueEffect(tryWithPlaceholder, (scope2) => {
+                const pendingEffects2 = scope2["#PendingEffects" /* PendingEffects */];
+                if (pendingEffects2) {
+                  scope2["#PendingEffects" /* PendingEffects */] = [];
+                  runEffects(pendingEffects2, true);
+                }
+              });
+            }
+          }
+        };
+      }
       placeholderShown.add(pendingEffects);
-      if (!scope[promiseAccessor] && (tryWithPlaceholder["#PendingAsyncCount" /* PendingAsyncCount */] = (tryWithPlaceholder["#PendingAsyncCount" /* PendingAsyncCount */] || 0) + 1) === 1) {
+      if (!scope[promiseAccessor] && !awaitCounter.i++) {
         requestAnimationFrame(
-          () => tryWithPlaceholder["#PendingAsyncCount" /* PendingAsyncCount */] && runEffects(
+          () => awaitCounter.i && runEffects(
             prepareEffects(
               () => queueRender(
                 tryWithPlaceholder,
@@ -1813,12 +1854,12 @@ function _await(nodeAccessor, template, walks, setup, params) {
           )
         );
       }
-    } else if (awaitBranch && !scope[promiseAccessor]) {
-      awaitBranch["#StartNode" /* StartNode */].parentNode.insertBefore(
-        referenceNode,
-        awaitBranch["#StartNode" /* StartNode */]
+    } else if (scope[branchAccessor] && !scope[promiseAccessor]) {
+      scope[branchAccessor]["#StartNode" /* StartNode */].parentNode.insertBefore(
+        scope[nodeAccessor],
+        scope[branchAccessor]["#StartNode" /* StartNode */]
       );
-      tempDetachBranch(awaitBranch);
+      tempDetachBranch(scope[branchAccessor]);
     }
     const thisPromise = scope[promiseAccessor] = promise.then(
       (data) => {
@@ -1828,45 +1869,47 @@ function _await(nodeAccessor, template, walks, setup, params) {
           queueRender(
             scope,
             () => {
-              if (awaitBranch) {
+              if (scope[branchAccessor]) {
                 if (!tryWithPlaceholder) {
-                  referenceNode.replaceWith(
-                    awaitBranch["#StartNode" /* StartNode */].parentNode
+                  scope[nodeAccessor].replaceWith(
+                    scope[branchAccessor]["#StartNode" /* StartNode */].parentNode
                   );
                 }
               } else {
                 insertBranchBefore(
-                  awaitBranch = scope[branchAccessor] = createAndSetupBranch(
+                  scope[branchAccessor] = createAndSetupBranch(
                     scope["$global" /* Global */],
-                    renderer,
+                    scope[rendererAccessor],
                     scope,
-                    referenceNode.parentNode
+                    scope[nodeAccessor].parentNode
                   ),
-                  referenceNode.parentNode,
-                  referenceNode
+                  scope[nodeAccessor].parentNode,
+                  scope[nodeAccessor]
                 );
-                referenceNode.remove();
+                scope[nodeAccessor].remove();
               }
-              params?.(awaitBranch, [data]);
-              if (tryWithPlaceholder) {
+              params?.(scope[branchAccessor], [data]);
+              if (awaitCounter) {
                 placeholderShown.add(pendingEffects);
-                if (!--tryWithPlaceholder["#PendingAsyncCount" /* PendingAsyncCount */]) {
-                  const placeholderBranch = tryWithPlaceholder["#PlaceholderBranch" /* PlaceholderBranch */];
-                  tryWithPlaceholder["#PlaceholderBranch" /* PlaceholderBranch */] = 0;
-                  if (placeholderBranch) {
-                    placeholderBranch["#StartNode" /* StartNode */].parentNode.insertBefore(
-                      tryWithPlaceholder["#StartNode" /* StartNode */].parentNode,
-                      placeholderBranch["#StartNode" /* StartNode */]
-                    );
-                    removeAndDestroyBranch(placeholderBranch);
+                awaitCounter.c();
+                if (!awaitCounter.d) {
+                  const fnScopes = /* @__PURE__ */ new Map();
+                  const effects = renderData.m();
+                  for (let i = 0; i < pendingEffects.length; ) {
+                    const fn = pendingEffects[i++];
+                    let scopes = fnScopes.get(fn);
+                    if (!scopes) {
+                      fnScopes.set(fn, scopes = /* @__PURE__ */ new Set());
+                    }
+                    scopes.add(pendingEffects[i++]);
                   }
-                  queueEffect(tryWithPlaceholder, (scope2) => {
-                    const pendingEffects2 = scope2["#PendingEffects" /* PendingEffects */];
-                    if (pendingEffects2) {
-                      scope2["#PendingEffects" /* PendingEffects */] = [];
-                      runEffects(pendingEffects2, true);
+                  for (let i = 0; i < effects.length; ) {
+                    const fn = effects[i++];
+                    const scope2 = effects[i++];
+                    if (!fnScopes.get(fn)?.has(scope2)) {
+                      queueEffect(scope2, fn);
                     }
-                  });
+                  }
                 }
               }
             },
@@ -1876,8 +1919,7 @@ function _await(nodeAccessor, template, walks, setup, params) {
       },
       (error) => {
         if (thisPromise === scope[promiseAccessor]) {
-          if (tryWithPlaceholder)
-            tryWithPlaceholder["#PendingAsyncCount" /* PendingAsyncCount */] = 0;
+          if (awaitCounter) awaitCounter.i = 0;
           scope[promiseAccessor] = 0;
           schedule();
           queueRender(scope, renderCatch, -1, error);
@@ -1886,6 +1928,13 @@ function _await(nodeAccessor, template, walks, setup, params) {
     );
   };
 }
+function _await_content(nodeAccessor, template, walks, setup) {
+  const rendererAccessor = "ConditionalRenderer:" /* ConditionalRenderer */ + (true ? nodeAccessor : decodeAccessor4(nodeAccessor));
+  const renderer = _content("", template, walks, setup)();
+  return (scope) => {
+    scope[rendererAccessor] = renderer;
+  };
+}
 function _try(nodeAccessor, template, walks, setup) {
   if (false) nodeAccessor = decodeAccessor4(nodeAccessor);
   const branchAccessor = "BranchScopes:" /* BranchScopes */ + nodeAccessor;
@@ -1917,7 +1966,8 @@ function renderCatch(scope, error) {
     const owner = tryWithCatch["_" /* Owner */];
     const placeholderBranch = tryWithCatch["#PlaceholderBranch" /* PlaceholderBranch */];
     if (placeholderBranch) {
-      tryWithCatch["#PendingAsyncCount" /* PendingAsyncCount */] = 0;
+      if (tryWithCatch["#AwaitCounter" /* AwaitCounter */])
+        tryWithCatch["#AwaitCounter" /* AwaitCounter */].i = 0;
       owner["BranchScopes:" /* BranchScopes */ + tryWithCatch["#BranchAccessor" /* BranchAccessor */]] = placeholderBranch;
       destroyBranch(tryWithCatch);
     }
@@ -2294,7 +2344,7 @@ var _enable_catch = () => {
   enableBranches();
   const handlePendingTry = (fn, scope, branch) => {
     while (branch) {
-      if (branch["#PendingAsyncCount" /* PendingAsyncCount */]) {
+      if (branch["#AwaitCounter" /* AwaitCounter */]?.i) {
         return (branch["#PendingEffects" /* PendingEffects */] ||= []).push(fn, scope);
       }
       branch = branch["#ParentBranch" /* ParentBranch */];