marko 6.0.151 → 6.0.153

package/dist/debug/dom.js

@@ -417,11 +417,12 @@ function destroyBranch(branch) {
 function destroyNestedBranches(branch) {
   branch["#Destroyed" /* Destroyed */] = 1;
   branch["#BranchScopes" /* BranchScopes */]?.forEach(destroyNestedBranches);
-  branch["#AbortScopes" /* AbortScopes */]?.forEach((scope) => {
-    for (const id in scope["#AbortControllers" /* AbortControllers */]) {
-      $signalReset(scope, id);
-    }
-  });
+  branch["#AbortScopes" /* AbortScopes */]?.forEach(resetControllers);
+}
+function resetControllers(scope) {
+  for (const id in scope["#AbortControllers" /* AbortControllers */]) {
+    $signalReset(scope, id);
+  }
 }
 function removeAndDestroyBranch(branch) {
   destroyBranch(branch);
@@ -1707,172 +1708,6 @@ function toInsertNode(startNode, endNode) {
   return parent;
 }
 
-// src/dom/reconcile.ts
-var WRONG_POS = 2147483647;
-function reconcile(parent, oldBranches, newBranches, afterReference) {
-  let oldStart = 0;
-  let newStart = 0;
-  let oldEnd = oldBranches.length - 1;
-  let newEnd = newBranches.length - 1;
-  let oldStartBranch = oldBranches[oldStart];
-  let newStartBranch = newBranches[newStart];
-  let oldEndBranch = oldBranches[oldEnd];
-  let newEndBranch = newBranches[newEnd];
-  let i;
-  let j;
-  let k;
-  let nextSibling;
-  let oldBranch;
-  let newBranch;
-  outer: {
-    while (oldStartBranch === newStartBranch) {
-      ++oldStart;
-      ++newStart;
-      if (oldStart > oldEnd || newStart > newEnd) {
-        break outer;
-      }
-      oldStartBranch = oldBranches[oldStart];
-      newStartBranch = newBranches[newStart];
-    }
-    while (oldEndBranch === newEndBranch) {
-      --oldEnd;
-      --newEnd;
-      if (oldStart > oldEnd || newStart > newEnd) {
-        break outer;
-      }
-      oldEndBranch = oldBranches[oldEnd];
-      newEndBranch = newBranches[newEnd];
-    }
-  }
-  if (oldStart > oldEnd) {
-    if (newStart <= newEnd) {
-      k = newEnd + 1;
-      nextSibling = k < newBranches.length ? newBranches[k]["#StartNode" /* StartNode */] : afterReference;
-      do {
-        insertBranchBefore(newBranches[newStart++], parent, nextSibling);
-      } while (newStart <= newEnd);
-    }
-  } else if (newStart > newEnd) {
-    do {
-      removeAndDestroyBranch(oldBranches[oldStart++]);
-    } while (oldStart <= oldEnd);
-  } else {
-    const oldLength = oldEnd - oldStart + 1;
-    const newLength = newEnd - newStart + 1;
-    const aNullable = oldBranches;
-    const sources = new Array(newLength);
-    for (i = 0; i < newLength; ++i) {
-      sources[i] = -1;
-    }
-    let pos = 0;
-    let synced = 0;
-    const keyIndex = /* @__PURE__ */ new Map();
-    for (j = newStart; j <= newEnd; ++j) {
-      keyIndex.set(newBranches[j], j);
-    }
-    for (i = oldStart; i <= oldEnd && synced < newLength; ++i) {
-      oldBranch = oldBranches[i];
-      j = keyIndex.get(oldBranch);
-      if (j !== void 0) {
-        pos = pos > j ? WRONG_POS : j;
-        ++synced;
-        newBranch = newBranches[j];
-        sources[j - newStart] = i;
-        aNullable[i] = null;
-      }
-    }
-    if (oldLength === oldBranches.length && synced === 0) {
-      for (; newStart < newLength; ++newStart) {
-        insertBranchBefore(newBranches[newStart], parent, afterReference);
-      }
-      for (; oldStart < oldLength; ++oldStart) {
-        removeAndDestroyBranch(oldBranches[oldStart]);
-      }
-    } else {
-      i = oldLength - synced;
-      while (i > 0) {
-        oldBranch = aNullable[oldStart++];
-        if (oldBranch !== null) {
-          removeAndDestroyBranch(oldBranch);
-          i--;
-        }
-      }
-      if (pos === WRONG_POS) {
-        const seq = longestIncreasingSubsequence(sources);
-        j = seq.length - 1;
-        k = newBranches.length;
-        for (i = newLength - 1; i >= 0; --i) {
-          if (sources[i] === -1) {
-            pos = i + newStart;
-            newBranch = newBranches[pos++];
-            nextSibling = pos < k ? newBranches[pos]["#StartNode" /* StartNode */] : afterReference;
-            insertBranchBefore(newBranch, parent, nextSibling);
-          } else {
-            if (j < 0 || i !== seq[j]) {
-              pos = i + newStart;
-              newBranch = newBranches[pos++];
-              nextSibling = pos < k ? newBranches[pos]["#StartNode" /* StartNode */] : afterReference;
-              insertBranchBefore(newBranch, parent, nextSibling);
-            } else {
-              --j;
-            }
-          }
-        }
-      } else if (synced !== newLength) {
-        k = newBranches.length;
-        for (i = newLength - 1; i >= 0; --i) {
-          if (sources[i] === -1) {
-            pos = i + newStart;
-            newBranch = newBranches[pos++];
-            nextSibling = pos < k ? newBranches[pos]["#StartNode" /* StartNode */] : afterReference;
-            insertBranchBefore(newBranch, parent, nextSibling);
-          }
-        }
-      }
-    }
-  }
-}
-function longestIncreasingSubsequence(a) {
-  const p = a.slice();
-  const result = [0];
-  let u;
-  let v;
-  for (let i = 0, il = a.length; i < il; ++i) {
-    if (a[i] === -1) {
-      continue;
-    }
-    const j = result[result.length - 1];
-    if (a[j] < a[i]) {
-      p[i] = j;
-      result.push(i);
-      continue;
-    }
-    u = 0;
-    v = result.length - 1;
-    while (u < v) {
-      const c = (u + v) / 2 | 0;
-      if (a[result[c]] < a[i]) {
-        u = c + 1;
-      } else {
-        v = c;
-      }
-    }
-    if (a[i] < a[result[u]]) {
-      if (u > 0) {
-        p[i] = result[u - 1];
-      }
-      result[u] = i;
-    }
-  }
-  u = result.length;
-  v = result[u - 1];
-  while (u-- > 0) {
-    result[u] = v;
-    v = p[v];
-  }
-  return result;
-}
-
 // src/dom/control-flow.ts
 function _await_promise(nodeAccessor, params) {
   if (false) nodeAccessor = decodeAccessor4(nodeAccessor);
@@ -2253,52 +2088,151 @@ function loop(forEach) {
   return (nodeAccessor, template, walks, setup, params) => {
     if (false) nodeAccessor = decodeAccessor4(nodeAccessor);
     const scopesAccessor = "BranchScopes:" /* BranchScopes */ + nodeAccessor;
-    const scopesByKeyAccessor = "BranchScopes:" /* BranchScopes */ + scopesAccessor;
     const renderer = _content("", template, walks, setup)();
     enableBranches();
     return (scope, value) => {
       const referenceNode = scope[nodeAccessor];
       const oldScopes = toArray(scope[scopesAccessor]);
-      const oldScopesByKey = scope[scopesByKeyAccessor] || oldScopes.reduce(
-        (map, scope2, i) => map.set(scope2["#LoopKey" /* LoopKey */] ?? i, scope2),
-        /* @__PURE__ */ new Map()
-      );
       const newScopes = scope[scopesAccessor] = [];
-      const newScopesByKey = scope[scopesByKeyAccessor] = /* @__PURE__ */ new Map();
+      const oldLen = oldScopes.length;
       const parentNode = referenceNode.nodeType > 1 /* Element */ ? referenceNode.parentNode || oldScopes[0]?.["#StartNode" /* StartNode */].parentNode : referenceNode;
+      let oldScopesByKey;
+      let hasPotentialMoves;
+      if (true) {
+        var seenKeys = /* @__PURE__ */ new Set();
+      }
       forEach(value, (key, args) => {
         if (true) {
-          if (newScopesByKey.has(key)) {
+          if (seenKeys.has(key)) {
             console.error(
               `A <for> tag's \`by\` attribute must return a unique value for each item, but a duplicate was found matching:`,
               key
             );
+          } else {
+            seenKeys.add(key);
           }
         }
-        const branch = oldScopesByKey.get(key) || createAndSetupBranch(
-          scope["$global" /* Global */],
-          renderer,
-          scope,
-          parentNode
-        );
+        let branch = oldLen && (oldScopesByKey ||= oldScopes.reduce(
+          (map, scope2, i) => map.set(scope2["#LoopKey" /* LoopKey */] ?? i, scope2),
+          /* @__PURE__ */ new Map()
+        )).get(key);
+        if (branch) {
+          hasPotentialMoves = oldScopesByKey.delete(key);
+        } else {
+          branch = createAndSetupBranch(
+            scope["$global" /* Global */],
+            renderer,
+            scope,
+            parentNode
+          );
+        }
         branch["#LoopKey" /* LoopKey */] = key;
-        params?.(branch, args);
-        newScopesByKey.set(key, branch);
         newScopes.push(branch);
+        params?.(branch, args);
       });
+      const newLen = newScopes.length;
+      const hasSiblings = referenceNode !== parentNode;
       let afterReference = null;
-      if (referenceNode !== parentNode) {
-        if (oldScopes.length) {
-          afterReference = oldScopes[oldScopes.length - 1]["#EndNode" /* EndNode */].nextSibling;
-          if (!newScopes.length) {
+      let oldEnd = oldLen - 1;
+      let newEnd = newLen - 1;
+      let start = 0;
+      if (hasSiblings) {
+        if (oldLen) {
+          afterReference = oldScopes[oldEnd]["#EndNode" /* EndNode */].nextSibling;
+          if (!newLen) {
             parentNode.insertBefore(referenceNode, afterReference);
           }
-        } else if (newScopes.length) {
+        } else if (newLen) {
           afterReference = referenceNode.nextSibling;
           referenceNode.remove();
         }
       }
-      reconcile(parentNode, oldScopes, newScopes, afterReference);
+      if (!hasPotentialMoves) {
+        if (oldLen) {
+          oldScopes.forEach(
+            hasSiblings ? removeAndDestroyBranch : destroyBranch
+          );
+          if (!hasSiblings) {
+            parentNode.textContent = "";
+          }
+        }
+        for (const newScope of newScopes) {
+          insertBranchBefore(newScope, parentNode, afterReference);
+        }
+        return;
+      }
+      for (const branch of oldScopesByKey.values()) {
+        removeAndDestroyBranch(branch);
+      }
+      while (start < oldLen && start < newLen && oldScopes[start] === newScopes[start]) {
+        start++;
+      }
+      while (oldEnd >= start && newEnd >= start && oldScopes[oldEnd] === newScopes[newEnd]) {
+        oldEnd--;
+        newEnd--;
+      }
+      if (oldEnd + 1 < oldLen) {
+        afterReference = oldScopes[oldEnd + 1]["#StartNode" /* StartNode */];
+      }
+      if (start > oldEnd) {
+        if (start <= newEnd) {
+          for (let i = start; i <= newEnd; i++) {
+            insertBranchBefore(newScopes[i], parentNode, afterReference);
+          }
+        }
+        return;
+      } else if (start > newEnd) {
+        return;
+      }
+      const diffLen = newEnd - start + 1;
+      const oldPos = /* @__PURE__ */ new Map();
+      const sources = new Array(diffLen);
+      const pred = new Array(diffLen);
+      const tails = [];
+      let tail = -1;
+      let lo;
+      let hi;
+      let mid;
+      for (let i = start; i <= oldEnd; i++) {
+        oldPos.set(oldScopes[i], i);
+      }
+      for (let i = diffLen; i--; ) {
+        sources[i] = oldPos.get(newScopes[start + i]) ?? -1;
+      }
+      for (let i = 0; i < diffLen; i++) {
+        if (~sources[i]) {
+          if (tail < 0 || sources[tails[tail]] < sources[i]) {
+            if (~tail) pred[i] = tails[tail];
+            tails[++tail] = i;
+          } else {
+            lo = 0;
+            hi = tail;
+            while (lo < hi) {
+              mid = (lo + hi) / 2 | 0;
+              if (sources[tails[mid]] < sources[i]) lo = mid + 1;
+              else hi = mid;
+            }
+            if (sources[i] < sources[tails[lo]]) {
+              if (lo > 0) pred[i] = tails[lo - 1];
+              tails[lo] = i;
+            }
+          }
+        }
+      }
+      hi = tails[tail];
+      lo = tail + 1;
+      while (lo-- > 0) {
+        tails[lo] = hi;
+        hi = pred[hi];
+      }
+      for (let i = diffLen; i--; ) {
+        if (~tail && i === tails[tail]) {
+          tail--;
+        } else {
+          insertBranchBefore(newScopes[start + i], parentNode, afterReference);
+        }
+        afterReference = newScopes[start + i]["#StartNode" /* StartNode */];
+      }
     };
   };
 }

package/dist/debug/dom.mjs

@@ -303,11 +303,12 @@ function destroyBranch(branch) {
 function destroyNestedBranches(branch) {
   branch["#Destroyed" /* Destroyed */] = 1;
   branch["#BranchScopes" /* BranchScopes */]?.forEach(destroyNestedBranches);
-  branch["#AbortScopes" /* AbortScopes */]?.forEach((scope) => {
-    for (const id in scope["#AbortControllers" /* AbortControllers */]) {
-      $signalReset(scope, id);
-    }
-  });
+  branch["#AbortScopes" /* AbortScopes */]?.forEach(resetControllers);
+}
+function resetControllers(scope) {
+  for (const id in scope["#AbortControllers" /* AbortControllers */]) {
+    $signalReset(scope, id);
+  }
 }
 function removeAndDestroyBranch(branch) {
   destroyBranch(branch);
@@ -1593,172 +1594,6 @@ function toInsertNode(startNode, endNode) {
   return parent;
 }
 
-// src/dom/reconcile.ts
-var WRONG_POS = 2147483647;
-function reconcile(parent, oldBranches, newBranches, afterReference) {
-  let oldStart = 0;
-  let newStart = 0;
-  let oldEnd = oldBranches.length - 1;
-  let newEnd = newBranches.length - 1;
-  let oldStartBranch = oldBranches[oldStart];
-  let newStartBranch = newBranches[newStart];
-  let oldEndBranch = oldBranches[oldEnd];
-  let newEndBranch = newBranches[newEnd];
-  let i;
-  let j;
-  let k;
-  let nextSibling;
-  let oldBranch;
-  let newBranch;
-  outer: {
-    while (oldStartBranch === newStartBranch) {
-      ++oldStart;
-      ++newStart;
-      if (oldStart > oldEnd || newStart > newEnd) {
-        break outer;
-      }
-      oldStartBranch = oldBranches[oldStart];
-      newStartBranch = newBranches[newStart];
-    }
-    while (oldEndBranch === newEndBranch) {
-      --oldEnd;
-      --newEnd;
-      if (oldStart > oldEnd || newStart > newEnd) {
-        break outer;
-      }
-      oldEndBranch = oldBranches[oldEnd];
-      newEndBranch = newBranches[newEnd];
-    }
-  }
-  if (oldStart > oldEnd) {
-    if (newStart <= newEnd) {
-      k = newEnd + 1;
-      nextSibling = k < newBranches.length ? newBranches[k]["#StartNode" /* StartNode */] : afterReference;
-      do {
-        insertBranchBefore(newBranches[newStart++], parent, nextSibling);
-      } while (newStart <= newEnd);
-    }
-  } else if (newStart > newEnd) {
-    do {
-      removeAndDestroyBranch(oldBranches[oldStart++]);
-    } while (oldStart <= oldEnd);
-  } else {
-    const oldLength = oldEnd - oldStart + 1;
-    const newLength = newEnd - newStart + 1;
-    const aNullable = oldBranches;
-    const sources = new Array(newLength);
-    for (i = 0; i < newLength; ++i) {
-      sources[i] = -1;
-    }
-    let pos = 0;
-    let synced = 0;
-    const keyIndex = /* @__PURE__ */ new Map();
-    for (j = newStart; j <= newEnd; ++j) {
-      keyIndex.set(newBranches[j], j);
-    }
-    for (i = oldStart; i <= oldEnd && synced < newLength; ++i) {
-      oldBranch = oldBranches[i];
-      j = keyIndex.get(oldBranch);
-      if (j !== void 0) {
-        pos = pos > j ? WRONG_POS : j;
-        ++synced;
-        newBranch = newBranches[j];
-        sources[j - newStart] = i;
-        aNullable[i] = null;
-      }
-    }
-    if (oldLength === oldBranches.length && synced === 0) {
-      for (; newStart < newLength; ++newStart) {
-        insertBranchBefore(newBranches[newStart], parent, afterReference);
-      }
-      for (; oldStart < oldLength; ++oldStart) {
-        removeAndDestroyBranch(oldBranches[oldStart]);
-      }
-    } else {
-      i = oldLength - synced;
-      while (i > 0) {
-        oldBranch = aNullable[oldStart++];
-        if (oldBranch !== null) {
-          removeAndDestroyBranch(oldBranch);
-          i--;
-        }
-      }
-      if (pos === WRONG_POS) {
-        const seq = longestIncreasingSubsequence(sources);
-        j = seq.length - 1;
-        k = newBranches.length;
-        for (i = newLength - 1; i >= 0; --i) {
-          if (sources[i] === -1) {
-            pos = i + newStart;
-            newBranch = newBranches[pos++];
-            nextSibling = pos < k ? newBranches[pos]["#StartNode" /* StartNode */] : afterReference;
-            insertBranchBefore(newBranch, parent, nextSibling);
-          } else {
-            if (j < 0 || i !== seq[j]) {
-              pos = i + newStart;
-              newBranch = newBranches[pos++];
-              nextSibling = pos < k ? newBranches[pos]["#StartNode" /* StartNode */] : afterReference;
-              insertBranchBefore(newBranch, parent, nextSibling);
-            } else {
-              --j;
-            }
-          }
-        }
-      } else if (synced !== newLength) {
-        k = newBranches.length;
-        for (i = newLength - 1; i >= 0; --i) {
-          if (sources[i] === -1) {
-            pos = i + newStart;
-            newBranch = newBranches[pos++];
-            nextSibling = pos < k ? newBranches[pos]["#StartNode" /* StartNode */] : afterReference;
-            insertBranchBefore(newBranch, parent, nextSibling);
-          }
-        }
-      }
-    }
-  }
-}
-function longestIncreasingSubsequence(a) {
-  const p = a.slice();
-  const result = [0];
-  let u;
-  let v;
-  for (let i = 0, il = a.length; i < il; ++i) {
-    if (a[i] === -1) {
-      continue;
-    }
-    const j = result[result.length - 1];
-    if (a[j] < a[i]) {
-      p[i] = j;
-      result.push(i);
-      continue;
-    }
-    u = 0;
-    v = result.length - 1;
-    while (u < v) {
-      const c = (u + v) / 2 | 0;
-      if (a[result[c]] < a[i]) {
-        u = c + 1;
-      } else {
-        v = c;
-      }
-    }
-    if (a[i] < a[result[u]]) {
-      if (u > 0) {
-        p[i] = result[u - 1];
-      }
-      result[u] = i;
-    }
-  }
-  u = result.length;
-  v = result[u - 1];
-  while (u-- > 0) {
-    result[u] = v;
-    v = p[v];
-  }
-  return result;
-}
-
 // src/dom/control-flow.ts
 function _await_promise(nodeAccessor, params) {
   if (false) nodeAccessor = decodeAccessor4(nodeAccessor);
@@ -2139,52 +1974,151 @@ function loop(forEach) {
   return (nodeAccessor, template, walks, setup, params) => {
     if (false) nodeAccessor = decodeAccessor4(nodeAccessor);
     const scopesAccessor = "BranchScopes:" /* BranchScopes */ + nodeAccessor;
-    const scopesByKeyAccessor = "BranchScopes:" /* BranchScopes */ + scopesAccessor;
     const renderer = _content("", template, walks, setup)();
     enableBranches();
     return (scope, value) => {
       const referenceNode = scope[nodeAccessor];
       const oldScopes = toArray(scope[scopesAccessor]);
-      const oldScopesByKey = scope[scopesByKeyAccessor] || oldScopes.reduce(
-        (map, scope2, i) => map.set(scope2["#LoopKey" /* LoopKey */] ?? i, scope2),
-        /* @__PURE__ */ new Map()
-      );
       const newScopes = scope[scopesAccessor] = [];
-      const newScopesByKey = scope[scopesByKeyAccessor] = /* @__PURE__ */ new Map();
+      const oldLen = oldScopes.length;
       const parentNode = referenceNode.nodeType > 1 /* Element */ ? referenceNode.parentNode || oldScopes[0]?.["#StartNode" /* StartNode */].parentNode : referenceNode;
+      let oldScopesByKey;
+      let hasPotentialMoves;
+      if (true) {
+        var seenKeys = /* @__PURE__ */ new Set();
+      }
       forEach(value, (key, args) => {
         if (true) {
-          if (newScopesByKey.has(key)) {
+          if (seenKeys.has(key)) {
             console.error(
               `A <for> tag's \`by\` attribute must return a unique value for each item, but a duplicate was found matching:`,
               key
             );
+          } else {
+            seenKeys.add(key);
           }
         }
-        const branch = oldScopesByKey.get(key) || createAndSetupBranch(
-          scope["$global" /* Global */],
-          renderer,
-          scope,
-          parentNode
-        );
+        let branch = oldLen && (oldScopesByKey ||= oldScopes.reduce(
+          (map, scope2, i) => map.set(scope2["#LoopKey" /* LoopKey */] ?? i, scope2),
+          /* @__PURE__ */ new Map()
+        )).get(key);
+        if (branch) {
+          hasPotentialMoves = oldScopesByKey.delete(key);
+        } else {
+          branch = createAndSetupBranch(
+            scope["$global" /* Global */],
+            renderer,
+            scope,
+            parentNode
+          );
+        }
         branch["#LoopKey" /* LoopKey */] = key;
-        params?.(branch, args);
-        newScopesByKey.set(key, branch);
         newScopes.push(branch);
+        params?.(branch, args);
       });
+      const newLen = newScopes.length;
+      const hasSiblings = referenceNode !== parentNode;
       let afterReference = null;
-      if (referenceNode !== parentNode) {
-        if (oldScopes.length) {
-          afterReference = oldScopes[oldScopes.length - 1]["#EndNode" /* EndNode */].nextSibling;
-          if (!newScopes.length) {
+      let oldEnd = oldLen - 1;
+      let newEnd = newLen - 1;
+      let start = 0;
+      if (hasSiblings) {
+        if (oldLen) {
+          afterReference = oldScopes[oldEnd]["#EndNode" /* EndNode */].nextSibling;
+          if (!newLen) {
             parentNode.insertBefore(referenceNode, afterReference);
           }
-        } else if (newScopes.length) {
+        } else if (newLen) {
           afterReference = referenceNode.nextSibling;
           referenceNode.remove();
         }
       }
-      reconcile(parentNode, oldScopes, newScopes, afterReference);
+      if (!hasPotentialMoves) {
+        if (oldLen) {
+          oldScopes.forEach(
+            hasSiblings ? removeAndDestroyBranch : destroyBranch
+          );
+          if (!hasSiblings) {
+            parentNode.textContent = "";
+          }
+        }
+        for (const newScope of newScopes) {
+          insertBranchBefore(newScope, parentNode, afterReference);
+        }
+        return;
+      }
+      for (const branch of oldScopesByKey.values()) {
+        removeAndDestroyBranch(branch);
+      }
+      while (start < oldLen && start < newLen && oldScopes[start] === newScopes[start]) {
+        start++;
+      }
+      while (oldEnd >= start && newEnd >= start && oldScopes[oldEnd] === newScopes[newEnd]) {
+        oldEnd--;
+        newEnd--;
+      }
+      if (oldEnd + 1 < oldLen) {
+        afterReference = oldScopes[oldEnd + 1]["#StartNode" /* StartNode */];
+      }
+      if (start > oldEnd) {
+        if (start <= newEnd) {
+          for (let i = start; i <= newEnd; i++) {
+            insertBranchBefore(newScopes[i], parentNode, afterReference);
+          }
+        }
+        return;
+      } else if (start > newEnd) {
+        return;
+      }
+      const diffLen = newEnd - start + 1;
+      const oldPos = /* @__PURE__ */ new Map();
+      const sources = new Array(diffLen);
+      const pred = new Array(diffLen);
+      const tails = [];
+      let tail = -1;
+      let lo;
+      let hi;
+      let mid;
+      for (let i = start; i <= oldEnd; i++) {
+        oldPos.set(oldScopes[i], i);
+      }
+      for (let i = diffLen; i--; ) {
+        sources[i] = oldPos.get(newScopes[start + i]) ?? -1;
+      }
+      for (let i = 0; i < diffLen; i++) {
+        if (~sources[i]) {
+          if (tail < 0 || sources[tails[tail]] < sources[i]) {
+            if (~tail) pred[i] = tails[tail];
+            tails[++tail] = i;
+          } else {
+            lo = 0;
+            hi = tail;
+            while (lo < hi) {
+              mid = (lo + hi) / 2 | 0;
+              if (sources[tails[mid]] < sources[i]) lo = mid + 1;
+              else hi = mid;
+            }
+            if (sources[i] < sources[tails[lo]]) {
+              if (lo > 0) pred[i] = tails[lo - 1];
+              tails[lo] = i;
+            }
+          }
+        }
+      }
+      hi = tails[tail];
+      lo = tail + 1;
+      while (lo-- > 0) {
+        tails[lo] = hi;
+        hi = pred[hi];
+      }
+      for (let i = diffLen; i--; ) {
+        if (~tail && i === tails[tail]) {
+          tail--;
+        } else {
+          insertBranchBefore(newScopes[start + i], parentNode, afterReference);
+        }
+        afterReference = newScopes[start + i]["#StartNode" /* StartNode */];
+      }
     };
   };
 }

package/dist/dom.js

@@ -278,10 +278,11 @@ function destroyBranch(branch) {
   ), destroyNestedBranches(branch);
 }
 function destroyNestedBranches(branch) {
-  branch.I = 1, branch.D?.forEach(destroyNestedBranches), branch.B?.forEach((scope) => {
-    for (let id in scope.A)
-      $signalReset(scope, id);
-  });
+  branch.I = 1, branch.D?.forEach(destroyNestedBranches), branch.B?.forEach(resetControllers);
+}
+function resetControllers(scope) {
+  for (let id in scope.A)
+    $signalReset(scope, id);
 }
 function removeAndDestroyBranch(branch) {
   destroyBranch(branch), removeChildNodes(
@@ -1071,81 +1072,6 @@ function toInsertNode(startNode, endNode) {
   return parent;
 }
 
-// src/dom/reconcile.ts
-var WRONG_POS = 2147483647;
-function reconcile(parent, oldBranches, newBranches, afterReference) {
-  let oldStart = 0, newStart = 0, oldEnd = oldBranches.length - 1, newEnd = newBranches.length - 1, oldStartBranch = oldBranches[oldStart], newStartBranch = newBranches[newStart], oldEndBranch = oldBranches[oldEnd], newEndBranch = newBranches[newEnd], i, j, k, nextSibling, oldBranch, newBranch;
-  outer: {
-    for (; oldStartBranch === newStartBranch; ) {
-      if (++oldStart, ++newStart, oldStart > oldEnd || newStart > newEnd)
-        break outer;
-      oldStartBranch = oldBranches[oldStart], newStartBranch = newBranches[newStart];
-    }
-    for (; oldEndBranch === newEndBranch; ) {
-      if (--oldEnd, --newEnd, oldStart > oldEnd || newStart > newEnd)
-        break outer;
-      oldEndBranch = oldBranches[oldEnd], newEndBranch = newBranches[newEnd];
-    }
-  }
-  if (oldStart > oldEnd) {
-    if (newStart <= newEnd) {
-      k = newEnd + 1, nextSibling = k < newBranches.length ? newBranches[k].S : afterReference;
-      do
-        insertBranchBefore(newBranches[newStart++], parent, nextSibling);
-      while (newStart <= newEnd);
-    }
-  } else if (newStart > newEnd)
-    do
-      removeAndDestroyBranch(oldBranches[oldStart++]);
-    while (oldStart <= oldEnd);
-  else {
-    let oldLength = oldEnd - oldStart + 1, newLength = newEnd - newStart + 1, aNullable = oldBranches, sources = new Array(newLength);
-    for (i = 0; i < newLength; ++i)
-      sources[i] = -1;
-    let pos = 0, synced = 0, keyIndex = /* @__PURE__ */ new Map();
-    for (j = newStart; j <= newEnd; ++j)
-      keyIndex.set(newBranches[j], j);
-    for (i = oldStart; i <= oldEnd && synced < newLength; ++i)
-      oldBranch = oldBranches[i], j = keyIndex.get(oldBranch), j !== void 0 && (pos = pos > j ? WRONG_POS : j, ++synced, newBranch = newBranches[j], sources[j - newStart] = i, aNullable[i] = null);
-    if (oldLength === oldBranches.length && synced === 0) {
-      for (; newStart < newLength; ++newStart)
-        insertBranchBefore(newBranches[newStart], parent, afterReference);
-      for (; oldStart < oldLength; ++oldStart)
-        removeAndDestroyBranch(oldBranches[oldStart]);
-    } else {
-      for (i = oldLength - synced; i > 0; )
-        oldBranch = aNullable[oldStart++], oldBranch !== null && (removeAndDestroyBranch(oldBranch), i--);
-      if (pos === WRONG_POS) {
-        let seq = longestIncreasingSubsequence(sources);
-        for (j = seq.length - 1, k = newBranches.length, i = newLength - 1; i >= 0; --i)
-          sources[i] === -1 ? (pos = i + newStart, newBranch = newBranches[pos++], nextSibling = pos < k ? newBranches[pos].S : afterReference, insertBranchBefore(newBranch, parent, nextSibling)) : j < 0 || i !== seq[j] ? (pos = i + newStart, newBranch = newBranches[pos++], nextSibling = pos < k ? newBranches[pos].S : afterReference, insertBranchBefore(newBranch, parent, nextSibling)) : --j;
-      } else if (synced !== newLength)
-        for (k = newBranches.length, i = newLength - 1; i >= 0; --i)
-          sources[i] === -1 && (pos = i + newStart, newBranch = newBranches[pos++], nextSibling = pos < k ? newBranches[pos].S : afterReference, insertBranchBefore(newBranch, parent, nextSibling));
-    }
-  }
-}
-function longestIncreasingSubsequence(a) {
-  let p = a.slice(), result = [0], u, v;
-  for (let i = 0, il = a.length; i < il; ++i) {
-    if (a[i] === -1)
-      continue;
-    let j = result[result.length - 1];
-    if (a[j] < a[i]) {
-      p[i] = j, result.push(i);
-      continue;
-    }
-    for (u = 0, v = result.length - 1; u < v; ) {
-      let c = (u + v) / 2 | 0;
-      a[result[c]] < a[i] ? u = c + 1 : v = c;
-    }
-    a[i] < a[result[u]] && (u > 0 && (p[i] = result[u - 1]), result[u] = i);
-  }
-  for (u = result.length, v = result[u - 1]; u-- > 0; )
-    result[u] = v, v = p[v];
-  return result;
-}
-
 // src/dom/control-flow.ts
 function _await_promise(nodeAccessor, params) {
   nodeAccessor = decodeAccessor(nodeAccessor);
@@ -1399,23 +1325,63 @@ var _for_of = loop(([all, by = bySecondArg], cb) => {
 function loop(forEach) {
   return (nodeAccessor, template, walks, setup, params) => {
     nodeAccessor = decodeAccessor(nodeAccessor);
-    let scopesAccessor = "A" /* BranchScopes */ + nodeAccessor, scopesByKeyAccessor = "A" /* BranchScopes */ + scopesAccessor, renderer = _content("", template, walks, setup)();
+    let scopesAccessor = "A" /* BranchScopes */ + nodeAccessor, renderer = _content("", template, walks, setup)();
     return enableBranches(), (scope, value) => {
-      let referenceNode = scope[nodeAccessor], oldScopes = toArray(scope[scopesAccessor]), oldScopesByKey = scope[scopesByKeyAccessor] || oldScopes.reduce(
-        (map, scope2, i) => map.set(scope2.M ?? i, scope2),
-        /* @__PURE__ */ new Map()
-      ), newScopes = scope[scopesAccessor] = [], newScopesByKey = scope[scopesByKeyAccessor] = /* @__PURE__ */ new Map(), parentNode = referenceNode.nodeType > 1 /* Element */ ? referenceNode.parentNode || oldScopes[0]?.S.parentNode : referenceNode;
+      let referenceNode = scope[nodeAccessor], oldScopes = toArray(scope[scopesAccessor]), newScopes = scope[scopesAccessor] = [], oldLen = oldScopes.length, parentNode = referenceNode.nodeType > 1 /* Element */ ? referenceNode.parentNode || oldScopes[0]?.S.parentNode : referenceNode, oldScopesByKey, hasPotentialMoves;
+      if (0)
+        var seenKeys;
       forEach(value, (key, args) => {
-        let branch = oldScopesByKey.get(key) || createAndSetupBranch(
+        let branch = oldLen && (oldScopesByKey ||= oldScopes.reduce(
+          (map, scope2, i) => map.set(scope2.M ?? i, scope2),
+          /* @__PURE__ */ new Map()
+        )).get(key);
+        branch ? hasPotentialMoves = oldScopesByKey.delete(key) : branch = createAndSetupBranch(
           scope.$,
           renderer,
           scope,
           parentNode
-        );
-        branch.M = key, params?.(branch, args), newScopesByKey.set(key, branch), newScopes.push(branch);
+        ), branch.M = key, newScopes.push(branch), params?.(branch, args);
       });
-      let afterReference = null;
-      referenceNode !== parentNode && (oldScopes.length ? (afterReference = oldScopes[oldScopes.length - 1].K.nextSibling, newScopes.length || parentNode.insertBefore(referenceNode, afterReference)) : newScopes.length && (afterReference = referenceNode.nextSibling, referenceNode.remove())), reconcile(parentNode, oldScopes, newScopes, afterReference);
+      let newLen = newScopes.length, hasSiblings = referenceNode !== parentNode, afterReference = null, oldEnd = oldLen - 1, newEnd = newLen - 1, start = 0;
+      if (hasSiblings && (oldLen ? (afterReference = oldScopes[oldEnd].K.nextSibling, newLen || parentNode.insertBefore(referenceNode, afterReference)) : newLen && (afterReference = referenceNode.nextSibling, referenceNode.remove())), !hasPotentialMoves) {
+        oldLen && (oldScopes.forEach(
+          hasSiblings ? removeAndDestroyBranch : destroyBranch
+        ), hasSiblings || (parentNode.textContent = ""));
+        for (let newScope of newScopes)
+          insertBranchBefore(newScope, parentNode, afterReference);
+        return;
+      }
+      for (let branch of oldScopesByKey.values())
+        removeAndDestroyBranch(branch);
+      for (; start < oldLen && start < newLen && oldScopes[start] === newScopes[start]; )
+        start++;
+      for (; oldEnd >= start && newEnd >= start && oldScopes[oldEnd] === newScopes[newEnd]; )
+        oldEnd--, newEnd--;
+      if (oldEnd + 1 < oldLen && (afterReference = oldScopes[oldEnd + 1].S), start > oldEnd) {
+        if (start <= newEnd)
+          for (let i = start; i <= newEnd; i++)
+            insertBranchBefore(newScopes[i], parentNode, afterReference);
+        return;
+      } else if (start > newEnd)
+        return;
+      let diffLen = newEnd - start + 1, oldPos = /* @__PURE__ */ new Map(), sources = new Array(diffLen), pred = new Array(diffLen), tails = [], tail = -1, lo, hi, mid;
+      for (let i = start; i <= oldEnd; i++)
+        oldPos.set(oldScopes[i], i);
+      for (let i = diffLen; i--; )
+        sources[i] = oldPos.get(newScopes[start + i]) ?? -1;
+      for (let i = 0; i < diffLen; i++)
+        if (~sources[i])
+          if (tail < 0 || sources[tails[tail]] < sources[i])
+            ~tail && (pred[i] = tails[tail]), tails[++tail] = i;
+          else {
+            for (lo = 0, hi = tail; lo < hi; )
+              mid = (lo + hi) / 2 | 0, sources[tails[mid]] < sources[i] ? lo = mid + 1 : hi = mid;
+            sources[i] < sources[tails[lo]] && (lo > 0 && (pred[i] = tails[lo - 1]), tails[lo] = i);
+          }
+      for (hi = tails[tail], lo = tail + 1; lo-- > 0; )
+        tails[lo] = hi, hi = pred[hi];
+      for (let i = diffLen; i--; )
+        ~tail && i === tails[tail] ? tail-- : insertBranchBefore(newScopes[start + i], parentNode, afterReference), afterReference = newScopes[start + i].S;
     };
   };
 }

package/dist/dom.mjs

@@ -167,10 +167,11 @@ function destroyBranch(branch) {
   ), destroyNestedBranches(branch);
 }
 function destroyNestedBranches(branch) {
-  branch.I = 1, branch.D?.forEach(destroyNestedBranches), branch.B?.forEach((scope) => {
-    for (let id in scope.A)
-      $signalReset(scope, id);
-  });
+  branch.I = 1, branch.D?.forEach(destroyNestedBranches), branch.B?.forEach(resetControllers);
+}
+function resetControllers(scope) {
+  for (let id in scope.A)
+    $signalReset(scope, id);
 }
 function removeAndDestroyBranch(branch) {
   destroyBranch(branch), removeChildNodes(
@@ -960,81 +961,6 @@ function toInsertNode(startNode, endNode) {
   return parent;
 }
 
-// src/dom/reconcile.ts
-var WRONG_POS = 2147483647;
-function reconcile(parent, oldBranches, newBranches, afterReference) {
-  let oldStart = 0, newStart = 0, oldEnd = oldBranches.length - 1, newEnd = newBranches.length - 1, oldStartBranch = oldBranches[oldStart], newStartBranch = newBranches[newStart], oldEndBranch = oldBranches[oldEnd], newEndBranch = newBranches[newEnd], i, j, k, nextSibling, oldBranch, newBranch;
-  outer: {
-    for (; oldStartBranch === newStartBranch; ) {
-      if (++oldStart, ++newStart, oldStart > oldEnd || newStart > newEnd)
-        break outer;
-      oldStartBranch = oldBranches[oldStart], newStartBranch = newBranches[newStart];
-    }
-    for (; oldEndBranch === newEndBranch; ) {
-      if (--oldEnd, --newEnd, oldStart > oldEnd || newStart > newEnd)
-        break outer;
-      oldEndBranch = oldBranches[oldEnd], newEndBranch = newBranches[newEnd];
-    }
-  }
-  if (oldStart > oldEnd) {
-    if (newStart <= newEnd) {
-      k = newEnd + 1, nextSibling = k < newBranches.length ? newBranches[k].S : afterReference;
-      do
-        insertBranchBefore(newBranches[newStart++], parent, nextSibling);
-      while (newStart <= newEnd);
-    }
-  } else if (newStart > newEnd)
-    do
-      removeAndDestroyBranch(oldBranches[oldStart++]);
-    while (oldStart <= oldEnd);
-  else {
-    let oldLength = oldEnd - oldStart + 1, newLength = newEnd - newStart + 1, aNullable = oldBranches, sources = new Array(newLength);
-    for (i = 0; i < newLength; ++i)
-      sources[i] = -1;
-    let pos = 0, synced = 0, keyIndex = /* @__PURE__ */ new Map();
-    for (j = newStart; j <= newEnd; ++j)
-      keyIndex.set(newBranches[j], j);
-    for (i = oldStart; i <= oldEnd && synced < newLength; ++i)
-      oldBranch = oldBranches[i], j = keyIndex.get(oldBranch), j !== void 0 && (pos = pos > j ? WRONG_POS : j, ++synced, newBranch = newBranches[j], sources[j - newStart] = i, aNullable[i] = null);
-    if (oldLength === oldBranches.length && synced === 0) {
-      for (; newStart < newLength; ++newStart)
-        insertBranchBefore(newBranches[newStart], parent, afterReference);
-      for (; oldStart < oldLength; ++oldStart)
-        removeAndDestroyBranch(oldBranches[oldStart]);
-    } else {
-      for (i = oldLength - synced; i > 0; )
-        oldBranch = aNullable[oldStart++], oldBranch !== null && (removeAndDestroyBranch(oldBranch), i--);
-      if (pos === WRONG_POS) {
-        let seq = longestIncreasingSubsequence(sources);
-        for (j = seq.length - 1, k = newBranches.length, i = newLength - 1; i >= 0; --i)
-          sources[i] === -1 ? (pos = i + newStart, newBranch = newBranches[pos++], nextSibling = pos < k ? newBranches[pos].S : afterReference, insertBranchBefore(newBranch, parent, nextSibling)) : j < 0 || i !== seq[j] ? (pos = i + newStart, newBranch = newBranches[pos++], nextSibling = pos < k ? newBranches[pos].S : afterReference, insertBranchBefore(newBranch, parent, nextSibling)) : --j;
-      } else if (synced !== newLength)
-        for (k = newBranches.length, i = newLength - 1; i >= 0; --i)
-          sources[i] === -1 && (pos = i + newStart, newBranch = newBranches[pos++], nextSibling = pos < k ? newBranches[pos].S : afterReference, insertBranchBefore(newBranch, parent, nextSibling));
-    }
-  }
-}
-function longestIncreasingSubsequence(a) {
-  let p = a.slice(), result = [0], u, v;
-  for (let i = 0, il = a.length; i < il; ++i) {
-    if (a[i] === -1)
-      continue;
-    let j = result[result.length - 1];
-    if (a[j] < a[i]) {
-      p[i] = j, result.push(i);
-      continue;
-    }
-    for (u = 0, v = result.length - 1; u < v; ) {
-      let c = (u + v) / 2 | 0;
-      a[result[c]] < a[i] ? u = c + 1 : v = c;
-    }
-    a[i] < a[result[u]] && (u > 0 && (p[i] = result[u - 1]), result[u] = i);
-  }
-  for (u = result.length, v = result[u - 1]; u-- > 0; )
-    result[u] = v, v = p[v];
-  return result;
-}
-
 // src/dom/control-flow.ts
 function _await_promise(nodeAccessor, params) {
   nodeAccessor = decodeAccessor(nodeAccessor);
@@ -1288,23 +1214,63 @@ var _for_of = loop(([all, by = bySecondArg], cb) => {
 function loop(forEach) {
   return (nodeAccessor, template, walks, setup, params) => {
     nodeAccessor = decodeAccessor(nodeAccessor);
-    let scopesAccessor = "A" /* BranchScopes */ + nodeAccessor, scopesByKeyAccessor = "A" /* BranchScopes */ + scopesAccessor, renderer = _content("", template, walks, setup)();
+    let scopesAccessor = "A" /* BranchScopes */ + nodeAccessor, renderer = _content("", template, walks, setup)();
     return enableBranches(), (scope, value) => {
-      let referenceNode = scope[nodeAccessor], oldScopes = toArray(scope[scopesAccessor]), oldScopesByKey = scope[scopesByKeyAccessor] || oldScopes.reduce(
-        (map, scope2, i) => map.set(scope2.M ?? i, scope2),
-        /* @__PURE__ */ new Map()
-      ), newScopes = scope[scopesAccessor] = [], newScopesByKey = scope[scopesByKeyAccessor] = /* @__PURE__ */ new Map(), parentNode = referenceNode.nodeType > 1 /* Element */ ? referenceNode.parentNode || oldScopes[0]?.S.parentNode : referenceNode;
+      let referenceNode = scope[nodeAccessor], oldScopes = toArray(scope[scopesAccessor]), newScopes = scope[scopesAccessor] = [], oldLen = oldScopes.length, parentNode = referenceNode.nodeType > 1 /* Element */ ? referenceNode.parentNode || oldScopes[0]?.S.parentNode : referenceNode, oldScopesByKey, hasPotentialMoves;
+      if (0)
+        var seenKeys;
       forEach(value, (key, args) => {
-        let branch = oldScopesByKey.get(key) || createAndSetupBranch(
+        let branch = oldLen && (oldScopesByKey ||= oldScopes.reduce(
+          (map, scope2, i) => map.set(scope2.M ?? i, scope2),
+          /* @__PURE__ */ new Map()
+        )).get(key);
+        branch ? hasPotentialMoves = oldScopesByKey.delete(key) : branch = createAndSetupBranch(
           scope.$,
           renderer,
           scope,
           parentNode
-        );
-        branch.M = key, params?.(branch, args), newScopesByKey.set(key, branch), newScopes.push(branch);
+        ), branch.M = key, newScopes.push(branch), params?.(branch, args);
       });
-      let afterReference = null;
-      referenceNode !== parentNode && (oldScopes.length ? (afterReference = oldScopes[oldScopes.length - 1].K.nextSibling, newScopes.length || parentNode.insertBefore(referenceNode, afterReference)) : newScopes.length && (afterReference = referenceNode.nextSibling, referenceNode.remove())), reconcile(parentNode, oldScopes, newScopes, afterReference);
+      let newLen = newScopes.length, hasSiblings = referenceNode !== parentNode, afterReference = null, oldEnd = oldLen - 1, newEnd = newLen - 1, start = 0;
+      if (hasSiblings && (oldLen ? (afterReference = oldScopes[oldEnd].K.nextSibling, newLen || parentNode.insertBefore(referenceNode, afterReference)) : newLen && (afterReference = referenceNode.nextSibling, referenceNode.remove())), !hasPotentialMoves) {
+        oldLen && (oldScopes.forEach(
+          hasSiblings ? removeAndDestroyBranch : destroyBranch
+        ), hasSiblings || (parentNode.textContent = ""));
+        for (let newScope of newScopes)
+          insertBranchBefore(newScope, parentNode, afterReference);
+        return;
+      }
+      for (let branch of oldScopesByKey.values())
+        removeAndDestroyBranch(branch);
+      for (; start < oldLen && start < newLen && oldScopes[start] === newScopes[start]; )
+        start++;
+      for (; oldEnd >= start && newEnd >= start && oldScopes[oldEnd] === newScopes[newEnd]; )
+        oldEnd--, newEnd--;
+      if (oldEnd + 1 < oldLen && (afterReference = oldScopes[oldEnd + 1].S), start > oldEnd) {
+        if (start <= newEnd)
+          for (let i = start; i <= newEnd; i++)
+            insertBranchBefore(newScopes[i], parentNode, afterReference);
+        return;
+      } else if (start > newEnd)
+        return;
+      let diffLen = newEnd - start + 1, oldPos = /* @__PURE__ */ new Map(), sources = new Array(diffLen), pred = new Array(diffLen), tails = [], tail = -1, lo, hi, mid;
+      for (let i = start; i <= oldEnd; i++)
+        oldPos.set(oldScopes[i], i);
+      for (let i = diffLen; i--; )
+        sources[i] = oldPos.get(newScopes[start + i]) ?? -1;
+      for (let i = 0; i < diffLen; i++)
+        if (~sources[i])
+          if (tail < 0 || sources[tails[tail]] < sources[i])
+            ~tail && (pred[i] = tails[tail]), tails[++tail] = i;
+          else {
+            for (lo = 0, hi = tail; lo < hi; )
+              mid = (lo + hi) / 2 | 0, sources[tails[mid]] < sources[i] ? lo = mid + 1 : hi = mid;
+            sources[i] < sources[tails[lo]] && (lo > 0 && (pred[i] = tails[lo - 1]), tails[lo] = i);
+          }
+      for (hi = tails[tail], lo = tail + 1; lo-- > 0; )
+        tails[lo] = hi, hi = pred[hi];
+      for (let i = diffLen; i--; )
+        ~tail && i === tails[tail] ? tail-- : insertBranchBefore(newScopes[start + i], parentNode, afterReference), afterReference = newScopes[start + i].S;
     };
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "marko",
-  "version": "6.0.151",
+  "version": "6.0.153",
   "description": "Optimized runtime for Marko templates.",
   "keywords": [
     "api",
@@ -48,7 +48,7 @@
     "build": "node -r ~ts ./scripts/bundle.ts"
   },
   "dependencies": {
-    "@marko/compiler": "^5.39.57",
+    "@marko/compiler": "^5.39.58",
     "csstype": "^3.2.3",
     "magic-string": "^0.30.21"
   },

package/dist/dom/reconcile.d.ts

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