marko 6.0.152 → 6.0.154

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);
@@ -719,8 +720,8 @@ function walk(startNode, walkCodes, branch) {
 }
 function walkInternal(currentWalkIndex, walkCodes, scope) {
   let value;
+  let currentMultiplier;
   let storedMultiplier = 0;
-  let currentMultiplier = 0;
   let currentScopeIndex = 0;
   for (; currentWalkIndex < walkCodes.length; ) {
     value = walkCodes.charCodeAt(currentWalkIndex++);
@@ -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 */];
+      }
     };
   };
 }