1 files changed, 260 insertions, 265 deletions

diff --git a/alpinejs/packages/morph/dist/module.cjs.js b/alpinejs/packages/morph/dist/module.cjs.js
index 260bf1f..5bf0fcf 100644
--- a/alpinejs/packages/morph/dist/module.cjs.js
+++ b/alpinejs/packages/morph/dist/module.cjs.js
@@ -4,12 +4,12 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {get: all[name], enumerable: true});
 };
-var __publicField = (obj, key2, value) => {
-  if (typeof key2 !== "symbol")
-    key2 += "";
-  if (key2 in obj)
-    return __defProp(obj, key2, {enumerable: true, configurable: true, writable: true, value});
-  return obj[key2] = value;
+var __publicField = (obj, key, value) => {
+  if (typeof key !== "symbol")
+    key += "";
+  if (key in obj)
+    return __defProp(obj, key, {enumerable: true, configurable: true, writable: true, value});
+  return obj[key] = value;
 };
 
 // packages/morph/builds/module.js
@@ -19,265 +19,7 @@ __export(exports, {
   morph: () => morph
 });
 
-// packages/morph/src/morph.js
-var resolveStep = () => {
-};
-var logger = () => {
-};
-var fromEl;
-var toEl;
-function breakpoint(message) {
-  if (!debug)
-    return;
-  logger((message || "").replace("\n", "\\n"), fromEl, toEl);
-  return new Promise((resolve) => resolveStep = () => resolve());
-}
-async function morph(from, toHtml, options) {
-  assignOptions(options);
-  fromEl = from;
-  toEl = createElement(toHtml);
-  if (window.Alpine && !from._x_dataStack) {
-    toEl._x_dataStack = window.Alpine.closestDataStack(from);
-    toEl._x_dataStack && window.Alpine.clone(from, toEl);
-  }
-  await breakpoint();
-  await patch(from, toEl);
-  fromEl = void 0;
-  toEl = void 0;
-  return from;
-}
-morph.step = () => resolveStep();
-morph.log = (theLogger) => {
-  logger = theLogger;
-};
-var key;
-var lookahead;
-var updating;
-var updated;
-var removing;
-var removed;
-var adding;
-var added;
-var debug;
-var noop = () => {
-};
-function assignOptions(options = {}) {
-  let defaultGetKey = (el) => el.getAttribute("key");
-  updating = options.updating || noop;
-  updated = options.updated || noop;
-  removing = options.removing || noop;
-  removed = options.removed || noop;
-  adding = options.adding || noop;
-  added = options.added || noop;
-  key = options.key || defaultGetKey;
-  lookahead = options.lookahead || false;
-  debug = options.debug || false;
-}
-function createElement(html) {
-  return document.createRange().createContextualFragment(html).firstElementChild;
-}
-async function patch(from, to) {
-  if (differentElementNamesTypesOrKeys(from, to)) {
-    let result = patchElement(from, to);
-    await breakpoint("Swap elements");
-    return result;
-  }
-  let updateChildrenOnly = false;
-  if (shouldSkip(updating, from, to, () => updateChildrenOnly = true))
-    return;
-  window.Alpine && initializeAlpineOnTo(from, to, () => updateChildrenOnly = true);
-  if (textOrComment(to)) {
-    await patchNodeValue(from, to);
-    updated(from, to);
-    return;
-  }
-  if (!updateChildrenOnly) {
-    await patchAttributes(from, to);
-  }
-  updated(from, to);
-  await patchChildren(from, to);
-}
-function differentElementNamesTypesOrKeys(from, to) {
-  return from.nodeType != to.nodeType || from.nodeName != to.nodeName || getKey(from) != getKey(to);
-}
-function textOrComment(el) {
-  return el.nodeType === 3 || el.nodeType === 8;
-}
-function patchElement(from, to) {
-  if (shouldSkip(removing, from))
-    return;
-  let toCloned = to.cloneNode(true);
-  if (shouldSkip(adding, toCloned))
-    return;
-  dom(from).replace(toCloned);
-  removed(from);
-  added(toCloned);
-}
-async function patchNodeValue(from, to) {
-  let value = to.nodeValue;
-  if (from.nodeValue !== value) {
-    from.nodeValue = value;
-    await breakpoint("Change text node to: " + value);
-  }
-}
-async function patchAttributes(from, to) {
-  if (from._x_isShown && !to._x_isShown) {
-    return;
-  }
-  if (!from._x_isShown && to._x_isShown) {
-    return;
-  }
-  let domAttributes = Array.from(from.attributes);
-  let toAttributes = Array.from(to.attributes);
-  for (let i = domAttributes.length - 1; i >= 0; i--) {
-    let name = domAttributes[i].name;
-    if (!to.hasAttribute(name)) {
-      from.removeAttribute(name);
-      await breakpoint("Remove attribute");
-    }
-  }
-  for (let i = toAttributes.length - 1; i >= 0; i--) {
-    let name = toAttributes[i].name;
-    let value = toAttributes[i].value;
-    if (from.getAttribute(name) !== value) {
-      from.setAttribute(name, value);
-      await breakpoint(`Set [${name}] attribute to: "${value}"`);
-    }
-  }
-}
-async function patchChildren(from, to) {
-  let domChildren = from.childNodes;
-  let toChildren = to.childNodes;
-  let toKeyToNodeMap = keyToMap(toChildren);
-  let domKeyDomNodeMap = keyToMap(domChildren);
-  let currentTo = dom(to).nodes().first();
-  let currentFrom = dom(from).nodes().first();
-  let domKeyHoldovers = {};
-  while (currentTo) {
-    let toKey = getKey(currentTo);
-    let domKey = getKey(currentFrom);
-    if (!currentFrom) {
-      if (toKey && domKeyHoldovers[toKey]) {
-        let holdover = domKeyHoldovers[toKey];
-        dom(from).append(holdover);
-        currentFrom = holdover;
-        await breakpoint("Add element (from key)");
-      } else {
-        let added2 = addNodeTo(currentTo, from) || {};
-        await breakpoint("Add element: " + added2.outerHTML || added2.nodeValue);
-        currentTo = dom(currentTo).nodes().next();
-        continue;
-      }
-    }
-    if (lookahead) {
-      let nextToElementSibling = dom(currentTo).next();
-      let found = false;
-      while (!found && nextToElementSibling) {
-        if (currentFrom.isEqualNode(nextToElementSibling)) {
-          found = true;
-          currentFrom = addNodeBefore(currentTo, currentFrom);
-          domKey = getKey(currentFrom);
-          await breakpoint("Move element (lookahead)");
-        }
-        nextToElementSibling = dom(nextToElementSibling).next();
-      }
-    }
-    if (toKey !== domKey) {
-      if (!toKey && domKey) {
-        domKeyHoldovers[domKey] = currentFrom;
-        currentFrom = addNodeBefore(currentTo, currentFrom);
-        domKeyHoldovers[domKey].remove();
-        currentFrom = dom(currentFrom).nodes().next();
-        currentTo = dom(currentTo).nodes().next();
-        await breakpoint('No "to" key');
-        continue;
-      }
-      if (toKey && !domKey) {
-        if (domKeyDomNodeMap[toKey]) {
-          currentFrom = dom(currentFrom).replace(domKeyDomNodeMap[toKey]);
-          await breakpoint('No "from" key');
-        }
-      }
-      if (toKey && domKey) {
-        domKeyHoldovers[domKey] = currentFrom;
-        let domKeyNode = domKeyDomNodeMap[toKey];
-        if (domKeyNode) {
-          currentFrom = dom(currentFrom).replace(domKeyNode);
-          await breakpoint('Move "from" key');
-        } else {
-          domKeyHoldovers[domKey] = currentFrom;
-          currentFrom = addNodeBefore(currentTo, currentFrom);
-          domKeyHoldovers[domKey].remove();
-          currentFrom = dom(currentFrom).next();
-          currentTo = dom(currentTo).next();
-          await breakpoint("I dont even know what this does");
-          continue;
-        }
-      }
-    }
-    await patch(currentFrom, currentTo);
-    currentTo = currentTo && dom(currentTo).nodes().next();
-    currentFrom = currentFrom && dom(currentFrom).nodes().next();
-  }
-  let removals = [];
-  while (currentFrom) {
-    if (!shouldSkip(removing, currentFrom))
-      removals.push(currentFrom);
-    currentFrom = dom(currentFrom).nodes().next();
-  }
-  while (removals.length) {
-    let domForRemoval = removals.pop();
-    domForRemoval.remove();
-    await breakpoint("remove el");
-    removed(domForRemoval);
-  }
-}
-function getKey(el) {
-  return el && el.nodeType === 1 && key(el);
-}
-function keyToMap(els) {
-  let map = {};
-  els.forEach((el) => {
-    let theKey = getKey(el);
-    if (theKey) {
-      map[theKey] = el;
-    }
-  });
-  return map;
-}
-function shouldSkip(hook, ...args) {
-  let skip = false;
-  hook(...args, () => skip = true);
-  return skip;
-}
-function addNodeTo(node, parent) {
-  if (!shouldSkip(adding, node)) {
-    let clone = node.cloneNode(true);
-    dom(parent).append(clone);
-    added(clone);
-    return clone;
-  }
-  return null;
-}
-function addNodeBefore(node, beforeMe) {
-  if (!shouldSkip(adding, node)) {
-    let clone = node.cloneNode(true);
-    dom(beforeMe).before(clone);
-    added(clone);
-    return clone;
-  }
-  return beforeMe;
-}
-function initializeAlpineOnTo(from, to, childrenOnly) {
-  if (from.nodeType !== 1)
-    return;
-  if (from._x_dataStack) {
-    window.Alpine.clone(from, to);
-  }
-}
-function dom(el) {
-  return new DomManager(el);
-}
+// packages/morph/src/dom.js
 var DomManager = class {
   constructor(el) {
     __publicField(this, "el");
@@ -329,6 +71,259 @@ var DomManager = class {
     return el;
   }
 };
+function dom(el) {
+  return new DomManager(el);
+}
+function createElement(html) {
+  return document.createRange().createContextualFragment(html).firstElementChild;
+}
+function textOrComment(el) {
+  return el.nodeType === 3 || el.nodeType === 8;
+}
+
+// packages/morph/src/morph.js
+var resolveStep = () => {
+};
+var logger = () => {
+};
+async function morph(from, toHtml, options) {
+  let fromEl;
+  let toEl;
+  let key, lookahead, updating, updated, removing, removed, adding, added, debug;
+  function breakpoint(message) {
+    if (!debug)
+      return;
+    logger((message || "").replace("\n", "\\n"), fromEl, toEl);
+    return new Promise((resolve) => resolveStep = () => resolve());
+  }
+  function assignOptions(options2 = {}) {
+    let defaultGetKey = (el) => el.getAttribute("key");
+    let noop = () => {
+    };
+    updating = options2.updating || noop;
+    updated = options2.updated || noop;
+    removing = options2.removing || noop;
+    removed = options2.removed || noop;
+    adding = options2.adding || noop;
+    added = options2.added || noop;
+    key = options2.key || defaultGetKey;
+    lookahead = options2.lookahead || false;
+    debug = options2.debug || false;
+  }
+  async function patch(from2, to) {
+    if (differentElementNamesTypesOrKeys(from2, to)) {
+      let result = patchElement(from2, to);
+      await breakpoint("Swap elements");
+      return result;
+    }
+    let updateChildrenOnly = false;
+    if (shouldSkip(updating, from2, to, () => updateChildrenOnly = true))
+      return;
+    window.Alpine && initializeAlpineOnTo(from2, to, () => updateChildrenOnly = true);
+    if (textOrComment(to)) {
+      await patchNodeValue(from2, to);
+      updated(from2, to);
+      return;
+    }
+    if (!updateChildrenOnly) {
+      await patchAttributes(from2, to);
+    }
+    updated(from2, to);
+    await patchChildren(from2, to);
+  }
+  function differentElementNamesTypesOrKeys(from2, to) {
+    return from2.nodeType != to.nodeType || from2.nodeName != to.nodeName || getKey(from2) != getKey(to);
+  }
+  function patchElement(from2, to) {
+    if (shouldSkip(removing, from2))
+      return;
+    let toCloned = to.cloneNode(true);
+    if (shouldSkip(adding, toCloned))
+      return;
+    dom(from2).replace(toCloned);
+    removed(from2);
+    added(toCloned);
+  }
+  async function patchNodeValue(from2, to) {
+    let value = to.nodeValue;
+    if (from2.nodeValue !== value) {
+      from2.nodeValue = value;
+      await breakpoint("Change text node to: " + value);
+    }
+  }
+  async function patchAttributes(from2, to) {
+    if (from2._x_isShown && !to._x_isShown) {
+      return;
+    }
+    if (!from2._x_isShown && to._x_isShown) {
+      return;
+    }
+    let domAttributes = Array.from(from2.attributes);
+    let toAttributes = Array.from(to.attributes);
+    for (let i = domAttributes.length - 1; i >= 0; i--) {
+      let name = domAttributes[i].name;
+      if (!to.hasAttribute(name)) {
+        from2.removeAttribute(name);
+        await breakpoint("Remove attribute");
+      }
+    }
+    for (let i = toAttributes.length - 1; i >= 0; i--) {
+      let name = toAttributes[i].name;
+      let value = toAttributes[i].value;
+      if (from2.getAttribute(name) !== value) {
+        from2.setAttribute(name, value);
+        await breakpoint(`Set [${name}] attribute to: "${value}"`);
+      }
+    }
+  }
+  async function patchChildren(from2, to) {
+    let domChildren = from2.childNodes;
+    let toChildren = to.childNodes;
+    let toKeyToNodeMap = keyToMap(toChildren);
+    let domKeyDomNodeMap = keyToMap(domChildren);
+    let currentTo = dom(to).nodes().first();
+    let currentFrom = dom(from2).nodes().first();
+    let domKeyHoldovers = {};
+    while (currentTo) {
+      let toKey = getKey(currentTo);
+      let domKey = getKey(currentFrom);
+      if (!currentFrom) {
+        if (toKey && domKeyHoldovers[toKey]) {
+          let holdover = domKeyHoldovers[toKey];
+          dom(from2).append(holdover);
+          currentFrom = holdover;
+          await breakpoint("Add element (from key)");
+        } else {
+          let added2 = addNodeTo(currentTo, from2) || {};
+          await breakpoint("Add element: " + (added2.outerHTML || added2.nodeValue));
+          currentTo = dom(currentTo).nodes().next();
+          continue;
+        }
+      }
+      if (lookahead) {
+        let nextToElementSibling = dom(currentTo).next();
+        let found = false;
+        while (!found && nextToElementSibling) {
+          if (currentFrom.isEqualNode(nextToElementSibling)) {
+            found = true;
+            currentFrom = addNodeBefore(currentTo, currentFrom);
+            domKey = getKey(currentFrom);
+            await breakpoint("Move element (lookahead)");
+          }
+          nextToElementSibling = dom(nextToElementSibling).next();
+        }
+      }
+      if (toKey !== domKey) {
+        if (!toKey && domKey) {
+          domKeyHoldovers[domKey] = currentFrom;
+          currentFrom = addNodeBefore(currentTo, currentFrom);
+          domKeyHoldovers[domKey].remove();
+          currentFrom = dom(currentFrom).nodes().next();
+          currentTo = dom(currentTo).nodes().next();
+          await breakpoint('No "to" key');
+          continue;
+        }
+        if (toKey && !domKey) {
+          if (domKeyDomNodeMap[toKey]) {
+            currentFrom = dom(currentFrom).replace(domKeyDomNodeMap[toKey]);
+            await breakpoint('No "from" key');
+          }
+        }
+        if (toKey && domKey) {
+          domKeyHoldovers[domKey] = currentFrom;
+          let domKeyNode = domKeyDomNodeMap[toKey];
+          if (domKeyNode) {
+            currentFrom = dom(currentFrom).replace(domKeyNode);
+            await breakpoint('Move "from" key');
+          } else {
+            domKeyHoldovers[domKey] = currentFrom;
+            currentFrom = addNodeBefore(currentTo, currentFrom);
+            domKeyHoldovers[domKey].remove();
+            currentFrom = dom(currentFrom).next();
+            currentTo = dom(currentTo).next();
+            await breakpoint("Swap elements with keys");
+            continue;
+          }
+        }
+      }
+      let currentFromNext = currentFrom && dom(currentFrom).nodes().next();
+      await patch(currentFrom, currentTo);
+      currentTo = currentTo && dom(currentTo).nodes().next();
+      currentFrom = currentFromNext;
+    }
+    let removals = [];
+    while (currentFrom) {
+      if (!shouldSkip(removing, currentFrom))
+        removals.push(currentFrom);
+      currentFrom = dom(currentFrom).nodes().next();
+    }
+    while (removals.length) {
+      let domForRemoval = removals.shift();
+      domForRemoval.remove();
+      await breakpoint("remove el");
+      removed(domForRemoval);
+    }
+  }
+  function getKey(el) {
+    return el && el.nodeType === 1 && key(el);
+  }
+  function keyToMap(els) {
+    let map = {};
+    els.forEach((el) => {
+      let theKey = getKey(el);
+      if (theKey) {
+        map[theKey] = el;
+      }
+    });
+    return map;
+  }
+  function addNodeTo(node, parent) {
+    if (!shouldSkip(adding, node)) {
+      let clone = node.cloneNode(true);
+      dom(parent).append(clone);
+      added(clone);
+      return clone;
+    }
+    return null;
+  }
+  function addNodeBefore(node, beforeMe) {
+    if (!shouldSkip(adding, node)) {
+      let clone = node.cloneNode(true);
+      dom(beforeMe).before(clone);
+      added(clone);
+      return clone;
+    }
+    return beforeMe;
+  }
+  assignOptions(options);
+  fromEl = from;
+  toEl = createElement(toHtml);
+  if (window.Alpine && window.Alpine.closestDataStack && !from._x_dataStack) {
+    toEl._x_dataStack = window.Alpine.closestDataStack(from);
+    toEl._x_dataStack && window.Alpine.clone(from, toEl);
+  }
+  await breakpoint();
+  await patch(from, toEl);
+  fromEl = void 0;
+  toEl = void 0;
+  return from;
+}
+morph.step = () => resolveStep();
+morph.log = (theLogger) => {
+  logger = theLogger;
+};
+function shouldSkip(hook, ...args) {
+  let skip = false;
+  hook(...args, () => skip = true);
+  return skip;
+}
+function initializeAlpineOnTo(from, to, childrenOnly) {
+  if (from.nodeType !== 1)
+    return;
+  if (from._x_dataStack) {
+    window.Alpine.clone(from, to);
+  }
+}
 
 // packages/morph/src/index.js
 function src_default(Alpine) {