jails-js 6.0.1 → 6.0.2

package/dist/index.js

@@ -19,9 +19,10 @@ const safe = (execute, val) => {
     return val || "";
   }
 };
-var Idiomorph = /* @__PURE__ */ function() {
-  let EMPTY_SET = /* @__PURE__ */ new Set();
-  let defaults = {
+var Idiomorph = function() {
+  const noOp = () => {
+  };
+  const defaults = {
     morphStyle: "outerHTML",
     callbacks: {
       beforeNodeAdded: noOp,
@@ -30,309 +31,422 @@ var Idiomorph = /* @__PURE__ */ function() {
       afterNodeMorphed: noOp,
       beforeNodeRemoved: noOp,
       afterNodeRemoved: noOp,
-      beforeAttributeUpdated: noOp,
-      beforeNodePantried: noOp
+      beforeAttributeUpdated: noOp
     },
     head: {
       style: "merge",
-      shouldPreserve: function(elt) {
-        return elt.getAttribute("im-preserve") === "true";
-      },
-      shouldReAppend: function(elt) {
-        return elt.getAttribute("im-re-append") === "true";
-      },
+      shouldPreserve: (elt) => elt.getAttribute("im-preserve") === "true",
+      shouldReAppend: (elt) => elt.getAttribute("im-re-append") === "true",
       shouldRemove: noOp,
       afterHeadMorphed: noOp
-    }
+    },
+    restoreFocus: true
   };
   function morph(oldNode, newContent, config2 = {}) {
-    if (oldNode instanceof Document) {
-      oldNode = oldNode.documentElement;
+    oldNode = normalizeElement(oldNode);
+    const newNode = normalizeParent(newContent);
+    const ctx = createMorphContext(oldNode, newNode, config2);
+    const morphedNodes = saveAndRestoreFocus(ctx, () => {
+      return withHeadBlocking(
+        ctx,
+        oldNode,
+        newNode,
+        /** @param {MorphContext} ctx */
+        (ctx2) => {
+          if (ctx2.morphStyle === "innerHTML") {
+            morphChildren(ctx2, oldNode, newNode);
+            return Array.from(oldNode.childNodes);
+          } else {
+            return morphOuterHTML(ctx2, oldNode, newNode);
+          }
+        }
+      );
+    });
+    ctx.pantry.remove();
+    return morphedNodes;
+  }
+  function morphOuterHTML(ctx, oldNode, newNode) {
+    const oldParent = normalizeParent(oldNode);
+    let childNodes = Array.from(oldParent.childNodes);
+    const index = childNodes.indexOf(oldNode);
+    const rightMargin = childNodes.length - (index + 1);
+    morphChildren(
+      ctx,
+      oldParent,
+      newNode,
+      // these two optional params are the secret sauce
+      oldNode,
+      // start point for iteration
+      oldNode.nextSibling
+      // end point for iteration
+    );
+    childNodes = Array.from(oldParent.childNodes);
+    return childNodes.slice(index, childNodes.length - rightMargin);
+  }
+  function saveAndRestoreFocus(ctx, fn) {
+    var _a;
+    if (!ctx.config.restoreFocus) return fn();
+    let activeElement = (
+      /** @type {HTMLInputElement|HTMLTextAreaElement|null} */
+      document.activeElement
+    );
+    if (!(activeElement instanceof HTMLInputElement || activeElement instanceof HTMLTextAreaElement)) {
+      return fn();
+    }
+    const { id: activeElementId, selectionStart, selectionEnd } = activeElement;
+    const results = fn();
+    if (activeElementId && activeElementId !== ((_a = document.activeElement) == null ? void 0 : _a.id)) {
+      activeElement = ctx.target.querySelector(`#${activeElementId}`);
+      activeElement == null ? void 0 : activeElement.focus();
     }
-    if (typeof newContent === "string") {
-      newContent = parseContent(newContent);
+    if (activeElement && !activeElement.selectionEnd && selectionEnd) {
+      activeElement.setSelectionRange(selectionStart, selectionEnd);
     }
-    let normalizedContent = normalizeContent(newContent);
-    let ctx = createMorphContext(oldNode, normalizedContent, config2);
-    return morphNormalizedContent(oldNode, normalizedContent, ctx);
+    return results;
   }
-  function morphNormalizedContent(oldNode, normalizedNewContent, ctx) {
-    var _a, _b;
-    if (ctx.head.block) {
-      let oldHead = oldNode.querySelector("head");
-      let newHead = normalizedNewContent.querySelector("head");
-      if (oldHead && newHead) {
-        let promises = handleHeadElement(newHead, oldHead, ctx);
-        Promise.all(promises).then(function() {
-          morphNormalizedContent(
-            oldNode,
-            normalizedNewContent,
-            Object.assign(ctx, {
-              head: {
-                block: false,
-                ignore: true
-              }
-            })
+  const morphChildren = /* @__PURE__ */ function() {
+    function morphChildren2(ctx, oldParent, newParent, insertionPoint = null, endPoint = null) {
+      if (oldParent instanceof HTMLTemplateElement && newParent instanceof HTMLTemplateElement) {
+        oldParent = oldParent.content;
+        newParent = newParent.content;
+      }
+      insertionPoint || (insertionPoint = oldParent.firstChild);
+      for (const newChild of newParent.childNodes) {
+        if (insertionPoint && insertionPoint != endPoint) {
+          const bestMatch = findBestMatch(
+            ctx,
+            newChild,
+            insertionPoint,
+            endPoint
           );
-        });
-        return;
+          if (bestMatch) {
+            if (bestMatch !== insertionPoint) {
+              removeNodesBetween(ctx, insertionPoint, bestMatch);
+            }
+            morphNode(bestMatch, newChild, ctx);
+            insertionPoint = bestMatch.nextSibling;
+            continue;
+          }
+        }
+        if (newChild instanceof Element && ctx.persistentIds.has(newChild.id)) {
+          const movedChild = moveBeforeById(
+            oldParent,
+            newChild.id,
+            insertionPoint,
+            ctx
+          );
+          morphNode(movedChild, newChild, ctx);
+          insertionPoint = movedChild.nextSibling;
+          continue;
+        }
+        const insertedNode = createNode(
+          oldParent,
+          newChild,
+          insertionPoint,
+          ctx
+        );
+        if (insertedNode) {
+          insertionPoint = insertedNode.nextSibling;
+        }
+      }
+      while (insertionPoint && insertionPoint != endPoint) {
+        const tempNode = insertionPoint;
+        insertionPoint = insertionPoint.nextSibling;
+        removeNode(ctx, tempNode);
       }
     }
-    if (ctx.morphStyle === "innerHTML") {
-      morphChildren(normalizedNewContent, oldNode, ctx);
-      if (ctx.config.twoPass) {
-        restoreFromPantry(oldNode, ctx);
+    function createNode(oldParent, newChild, insertionPoint, ctx) {
+      if (ctx.callbacks.beforeNodeAdded(newChild) === false) return null;
+      if (ctx.idMap.has(newChild)) {
+        const newEmptyChild = document.createElement(
+          /** @type {Element} */
+          newChild.tagName
+        );
+        oldParent.insertBefore(newEmptyChild, insertionPoint);
+        morphNode(newEmptyChild, newChild, ctx);
+        ctx.callbacks.afterNodeAdded(newEmptyChild);
+        return newEmptyChild;
+      } else {
+        const newClonedChild = document.importNode(newChild, true);
+        oldParent.insertBefore(newClonedChild, insertionPoint);
+        ctx.callbacks.afterNodeAdded(newClonedChild);
+        return newClonedChild;
       }
-      return Array.from(oldNode.children);
-    } else if (ctx.morphStyle === "outerHTML" || ctx.morphStyle == null) {
-      let bestMatch = findBestNodeMatch(normalizedNewContent, oldNode, ctx);
-      let previousSibling = (_a = bestMatch == null ? void 0 : bestMatch.previousSibling) != null ? _a : null;
-      let nextSibling = (_b = bestMatch == null ? void 0 : bestMatch.nextSibling) != null ? _b : null;
-      let morphedNode = morphOldNodeTo(oldNode, bestMatch, ctx);
-      if (bestMatch) {
-        if (morphedNode) {
-          const elements = insertSiblings(
-            previousSibling,
-            morphedNode,
-            nextSibling
-          );
-          if (ctx.config.twoPass) {
-            restoreFromPantry(morphedNode.parentNode, ctx);
+    }
+    const findBestMatch = /* @__PURE__ */ function() {
+      function findBestMatch2(ctx, node, startPoint, endPoint) {
+        let softMatch = null;
+        let nextSibling = node.nextSibling;
+        let siblingSoftMatchCount = 0;
+        let cursor = startPoint;
+        while (cursor && cursor != endPoint) {
+          if (isSoftMatch(cursor, node)) {
+            if (isIdSetMatch(ctx, cursor, node)) {
+              return cursor;
+            }
+            if (softMatch === null) {
+              if (!ctx.idMap.has(cursor)) {
+                softMatch = cursor;
+              }
+            }
+          }
+          if (softMatch === null && nextSibling && isSoftMatch(cursor, nextSibling)) {
+            siblingSoftMatchCount++;
+            nextSibling = nextSibling.nextSibling;
+            if (siblingSoftMatchCount >= 2) {
+              softMatch = void 0;
+            }
+          }
+          if (cursor.contains(document.activeElement)) break;
+          cursor = cursor.nextSibling;
+        }
+        return softMatch || null;
+      }
+      function isIdSetMatch(ctx, oldNode, newNode) {
+        let oldSet = ctx.idMap.get(oldNode);
+        let newSet = ctx.idMap.get(newNode);
+        if (!newSet || !oldSet) return false;
+        for (const id of oldSet) {
+          if (newSet.has(id)) {
+            return true;
           }
-          return elements;
         }
+        return false;
+      }
+      function isSoftMatch(oldNode, newNode) {
+        const oldElt = (
+          /** @type {Element} */
+          oldNode
+        );
+        const newElt = (
+          /** @type {Element} */
+          newNode
+        );
+        return oldElt.nodeType === newElt.nodeType && oldElt.tagName === newElt.tagName && // If oldElt has an `id` with possible state and it doesn't match newElt.id then avoid morphing.
+        // We'll still match an anonymous node with an IDed newElt, though, because if it got this far,
+        // its not persistent, and new nodes can't have any hidden state.
+        (!oldElt.id || oldElt.id === newElt.id);
+      }
+      return findBestMatch2;
+    }();
+    function removeNode(ctx, node) {
+      var _a;
+      if (ctx.idMap.has(node)) {
+        moveBefore(ctx.pantry, node, null);
       } else {
-        return [];
+        if (ctx.callbacks.beforeNodeRemoved(node) === false) return;
+        (_a = node.parentNode) == null ? void 0 : _a.removeChild(node);
+        ctx.callbacks.afterNodeRemoved(node);
       }
-    } else {
-      throw "Do not understand how to morph style " + ctx.morphStyle;
     }
-  }
-  function ignoreValueOfActiveElement(possibleActiveElement, ctx) {
-    return !!ctx.ignoreActiveValue && possibleActiveElement === document.activeElement && possibleActiveElement !== document.body;
-  }
-  function morphOldNodeTo(oldNode, newContent, ctx) {
-    var _a, _b;
-    if (ctx.ignoreActive && oldNode === document.activeElement) ;
-    else if (newContent == null) {
-      if (ctx.callbacks.beforeNodeRemoved(oldNode) === false) return oldNode;
-      (_a = oldNode.parentNode) == null ? void 0 : _a.removeChild(oldNode);
-      ctx.callbacks.afterNodeRemoved(oldNode);
-      return null;
-    } else if (!isSoftMatch(oldNode, newContent)) {
-      if (ctx.callbacks.beforeNodeRemoved(oldNode) === false) return oldNode;
-      if (ctx.callbacks.beforeNodeAdded(newContent) === false) return oldNode;
-      (_b = oldNode.parentNode) == null ? void 0 : _b.replaceChild(newContent, oldNode);
-      ctx.callbacks.afterNodeAdded(newContent);
-      ctx.callbacks.afterNodeRemoved(oldNode);
-      return newContent;
-    } else {
-      if (ctx.callbacks.beforeNodeMorphed(oldNode, newContent) === false)
+    function removeNodesBetween(ctx, startInclusive, endExclusive) {
+      let cursor = startInclusive;
+      while (cursor && cursor !== endExclusive) {
+        let tempNode = (
+          /** @type {Node} */
+          cursor
+        );
+        cursor = cursor.nextSibling;
+        removeNode(ctx, tempNode);
+      }
+      return cursor;
+    }
+    function moveBeforeById(parentNode, id, after, ctx) {
+      const target = (
+        /** @type {Element} - will always be found */
+        ctx.target.querySelector(`#${id}`) || ctx.pantry.querySelector(`#${id}`)
+      );
+      removeElementFromAncestorsIdMaps(target, ctx);
+      moveBefore(parentNode, target, after);
+      return target;
+    }
+    function removeElementFromAncestorsIdMaps(element, ctx) {
+      const id = element.id;
+      while (element = element.parentNode) {
+        let idSet = ctx.idMap.get(element);
+        if (idSet) {
+          idSet.delete(id);
+          if (!idSet.size) {
+            ctx.idMap.delete(element);
+          }
+        }
+      }
+    }
+    function moveBefore(parentNode, element, after) {
+      if (parentNode.moveBefore) {
+        try {
+          parentNode.moveBefore(element, after);
+        } catch (e) {
+          parentNode.insertBefore(element, after);
+        }
+      } else {
+        parentNode.insertBefore(element, after);
+      }
+    }
+    return morphChildren2;
+  }();
+  const morphNode = /* @__PURE__ */ function() {
+    function morphNode2(oldNode, newContent, ctx) {
+      if (ctx.ignoreActive && oldNode === document.activeElement) {
+        return null;
+      }
+      if (ctx.callbacks.beforeNodeMorphed(oldNode, newContent) === false) {
         return oldNode;
+      }
       if (oldNode instanceof HTMLHeadElement && ctx.head.ignore) ;
       else if (oldNode instanceof HTMLHeadElement && ctx.head.style !== "morph") {
         handleHeadElement(
+          oldNode,
           /** @type {HTMLHeadElement} */
           newContent,
-          oldNode,
           ctx
         );
       } else {
-        syncNodeFrom(newContent, oldNode, ctx);
+        morphAttributes(oldNode, newContent, ctx);
         if (!ignoreValueOfActiveElement(oldNode, ctx)) {
-          morphChildren(newContent, oldNode, ctx);
+          morphChildren(ctx, oldNode, newContent);
         }
       }
       ctx.callbacks.afterNodeMorphed(oldNode, newContent);
       return oldNode;
     }
-    return null;
-  }
-  function morphChildren(newParent, oldParent, ctx) {
-    if (newParent instanceof HTMLTemplateElement && oldParent instanceof HTMLTemplateElement) {
-      newParent = newParent.content;
-      oldParent = oldParent.content;
-    }
-    let nextNewChild = newParent.firstChild;
-    let insertionPoint = oldParent.firstChild;
-    let newChild;
-    while (nextNewChild) {
-      newChild = nextNewChild;
-      nextNewChild = newChild.nextSibling;
-      if (insertionPoint == null) {
-        if (ctx.config.twoPass && ctx.persistentIds.has(
+    function morphAttributes(oldNode, newNode, ctx) {
+      let type = newNode.nodeType;
+      if (type === 1) {
+        const oldElt = (
           /** @type {Element} */
-          newChild.id
-        )) {
-          oldParent.appendChild(newChild);
-        } else {
-          if (ctx.callbacks.beforeNodeAdded(newChild) === false) continue;
-          oldParent.appendChild(newChild);
-          ctx.callbacks.afterNodeAdded(newChild);
+          oldNode
+        );
+        const newElt = (
+          /** @type {Element} */
+          newNode
+        );
+        const oldAttributes = oldElt.attributes;
+        const newAttributes = newElt.attributes;
+        for (const newAttribute of newAttributes) {
+          if (ignoreAttribute(newAttribute.name, oldElt, "update", ctx)) {
+            continue;
+          }
+          if (oldElt.getAttribute(newAttribute.name) !== newAttribute.value) {
+            oldElt.setAttribute(newAttribute.name, newAttribute.value);
+          }
         }
-        removeIdsFromConsideration(ctx, newChild);
-        continue;
-      }
-      if (isIdSetMatch(newChild, insertionPoint, ctx)) {
-        morphOldNodeTo(insertionPoint, newChild, ctx);
-        insertionPoint = insertionPoint.nextSibling;
-        removeIdsFromConsideration(ctx, newChild);
-        continue;
-      }
-      let idSetMatch = findIdSetMatch(
-        newParent,
-        oldParent,
-        newChild,
-        insertionPoint,
-        ctx
-      );
-      if (idSetMatch) {
-        insertionPoint = removeNodesBetween(insertionPoint, idSetMatch, ctx);
-        morphOldNodeTo(idSetMatch, newChild, ctx);
-        removeIdsFromConsideration(ctx, newChild);
-        continue;
-      }
-      let softMatch = findSoftMatch(
-        newParent,
-        oldParent,
-        newChild,
-        insertionPoint,
-        ctx
-      );
-      if (softMatch) {
-        insertionPoint = removeNodesBetween(insertionPoint, softMatch, ctx);
-        morphOldNodeTo(softMatch, newChild, ctx);
-        removeIdsFromConsideration(ctx, newChild);
-        continue;
-      }
-      if (ctx.config.twoPass && ctx.persistentIds.has(
-        /** @type {Element} */
-        newChild.id
-      )) {
-        oldParent.insertBefore(newChild, insertionPoint);
-      } else {
-        if (ctx.callbacks.beforeNodeAdded(newChild) === false) continue;
-        oldParent.insertBefore(newChild, insertionPoint);
-        ctx.callbacks.afterNodeAdded(newChild);
-      }
-      removeIdsFromConsideration(ctx, newChild);
-    }
-    while (insertionPoint !== null) {
-      let tempNode = insertionPoint;
-      insertionPoint = insertionPoint.nextSibling;
-      removeNode(tempNode, ctx);
-    }
-  }
-  function ignoreAttribute(attr, to, updateType, ctx) {
-    if (attr === "value" && ctx.ignoreActiveValue && to === document.activeElement) {
-      return true;
-    }
-    return ctx.callbacks.beforeAttributeUpdated(attr, to, updateType) === false;
-  }
-  function syncNodeFrom(from, to, ctx) {
-    let type = from.nodeType;
-    if (type === 1) {
-      const fromEl = (
-        /** @type {Element} */
-        from
-      );
-      const toEl = (
-        /** @type {Element} */
-        to
-      );
-      const fromAttributes = fromEl.attributes;
-      const toAttributes = toEl.attributes;
-      for (const fromAttribute of fromAttributes) {
-        if (ignoreAttribute(fromAttribute.name, toEl, "update", ctx)) {
-          continue;
+        for (let i = oldAttributes.length - 1; 0 <= i; i--) {
+          const oldAttribute = oldAttributes[i];
+          if (!oldAttribute) continue;
+          if (!newElt.hasAttribute(oldAttribute.name)) {
+            if (ignoreAttribute(oldAttribute.name, oldElt, "remove", ctx)) {
+              continue;
+            }
+            oldElt.removeAttribute(oldAttribute.name);
+          }
         }
-        if (toEl.getAttribute(fromAttribute.name) !== fromAttribute.value) {
-          toEl.setAttribute(fromAttribute.name, fromAttribute.value);
+        if (!ignoreValueOfActiveElement(oldElt, ctx)) {
+          syncInputValue(oldElt, newElt, ctx);
         }
       }
-      for (let i = toAttributes.length - 1; 0 <= i; i--) {
-        const toAttribute = toAttributes[i];
-        if (!toAttribute) continue;
-        if (!fromEl.hasAttribute(toAttribute.name)) {
-          if (ignoreAttribute(toAttribute.name, toEl, "remove", ctx)) {
-            continue;
-          }
-          toEl.removeAttribute(toAttribute.name);
+      if (type === 8 || type === 3) {
+        if (oldNode.nodeValue !== newNode.nodeValue) {
+          oldNode.nodeValue = newNode.nodeValue;
         }
       }
     }
-    if (type === 8 || type === 3) {
-      if (to.nodeValue !== from.nodeValue) {
-        to.nodeValue = from.nodeValue;
-      }
-    }
-    if (!ignoreValueOfActiveElement(to, ctx)) {
-      syncInputValue(from, to, ctx);
-    }
-  }
-  function syncBooleanAttribute(from, to, attributeName, ctx) {
-    if (!(from instanceof Element && to instanceof Element)) return;
-    const fromLiveValue = from[attributeName], toLiveValue = to[attributeName];
-    if (fromLiveValue !== toLiveValue) {
-      let ignoreUpdate = ignoreAttribute(attributeName, to, "update", ctx);
-      if (!ignoreUpdate) {
-        to[attributeName] = from[attributeName];
-      }
-      if (fromLiveValue) {
-        if (!ignoreUpdate) {
-          to.setAttribute(attributeName, fromLiveValue);
+    function syncInputValue(oldElement, newElement, ctx) {
+      if (oldElement instanceof HTMLInputElement && newElement instanceof HTMLInputElement && newElement.type !== "file") {
+        let newValue = newElement.value;
+        let oldValue = oldElement.value;
+        syncBooleanAttribute(oldElement, newElement, "checked", ctx);
+        syncBooleanAttribute(oldElement, newElement, "disabled", ctx);
+        if (!newElement.hasAttribute("value")) {
+          if (!ignoreAttribute("value", oldElement, "remove", ctx)) {
+            oldElement.value = "";
+            oldElement.removeAttribute("value");
+          }
+        } else if (oldValue !== newValue) {
+          if (!ignoreAttribute("value", oldElement, "update", ctx)) {
+            oldElement.setAttribute("value", newValue);
+            oldElement.value = newValue;
+          }
         }
-      } else {
-        if (!ignoreAttribute(attributeName, to, "remove", ctx)) {
-          to.removeAttribute(attributeName);
+      } else if (oldElement instanceof HTMLOptionElement && newElement instanceof HTMLOptionElement) {
+        syncBooleanAttribute(oldElement, newElement, "selected", ctx);
+      } else if (oldElement instanceof HTMLTextAreaElement && newElement instanceof HTMLTextAreaElement) {
+        let newValue = newElement.value;
+        let oldValue = oldElement.value;
+        if (ignoreAttribute("value", oldElement, "update", ctx)) {
+          return;
+        }
+        if (newValue !== oldValue) {
+          oldElement.value = newValue;
+        }
+        if (oldElement.firstChild && oldElement.firstChild.nodeValue !== newValue) {
+          oldElement.firstChild.nodeValue = newValue;
         }
       }
     }
-  }
-  function syncInputValue(from, to, ctx) {
-    if (from instanceof HTMLInputElement && to instanceof HTMLInputElement && from.type !== "file") {
-      let fromValue = from.value;
-      let toValue = to.value;
-      syncBooleanAttribute(from, to, "checked", ctx);
-      syncBooleanAttribute(from, to, "disabled", ctx);
-      if (!from.hasAttribute("value")) {
-        if (!ignoreAttribute("value", to, "remove", ctx)) {
-          to.value = "";
-          to.removeAttribute("value");
+    function syncBooleanAttribute(oldElement, newElement, attributeName, ctx) {
+      const newLiveValue = newElement[attributeName], oldLiveValue = oldElement[attributeName];
+      if (newLiveValue !== oldLiveValue) {
+        const ignoreUpdate = ignoreAttribute(
+          attributeName,
+          oldElement,
+          "update",
+          ctx
+        );
+        if (!ignoreUpdate) {
+          oldElement[attributeName] = newElement[attributeName];
         }
-      } else if (fromValue !== toValue) {
-        if (!ignoreAttribute("value", to, "update", ctx)) {
-          to.setAttribute("value", fromValue);
-          to.value = fromValue;
+        if (newLiveValue) {
+          if (!ignoreUpdate) {
+            oldElement.setAttribute(attributeName, "");
+          }
+        } else {
+          if (!ignoreAttribute(attributeName, oldElement, "remove", ctx)) {
+            oldElement.removeAttribute(attributeName);
+          }
         }
       }
-    } else if (from instanceof HTMLOptionElement && to instanceof HTMLOptionElement) {
-      syncBooleanAttribute(from, to, "selected", ctx);
-    } else if (from instanceof HTMLTextAreaElement && to instanceof HTMLTextAreaElement) {
-      let fromValue = from.value;
-      let toValue = to.value;
-      if (ignoreAttribute("value", to, "update", ctx)) {
-        return;
-      }
-      if (fromValue !== toValue) {
-        to.value = fromValue;
+    }
+    function ignoreAttribute(attr, element, updateType, ctx) {
+      if (attr === "value" && ctx.ignoreActiveValue && element === document.activeElement) {
+        return true;
       }
-      if (to.firstChild && to.firstChild.nodeValue !== fromValue) {
-        to.firstChild.nodeValue = fromValue;
+      return ctx.callbacks.beforeAttributeUpdated(attr, element, updateType) === false;
+    }
+    function ignoreValueOfActiveElement(possibleActiveElement, ctx) {
+      return !!ctx.ignoreActiveValue && possibleActiveElement === document.activeElement && possibleActiveElement !== document.body;
+    }
+    return morphNode2;
+  }();
+  function withHeadBlocking(ctx, oldNode, newNode, callback) {
+    if (ctx.head.block) {
+      const oldHead = oldNode.querySelector("head");
+      const newHead = newNode.querySelector("head");
+      if (oldHead && newHead) {
+        const promises = handleHeadElement(oldHead, newHead, ctx);
+        return Promise.all(promises).then(() => {
+          const newCtx = Object.assign(ctx, {
+            head: {
+              block: false,
+              ignore: true
+            }
+          });
+          return callback(newCtx);
+        });
       }
     }
+    return callback(ctx);
   }
-  function handleHeadElement(newHeadTag, currentHead, ctx) {
+  function handleHeadElement(oldHead, newHead, ctx) {
     let added = [];
     let removed = [];
     let preserved = [];
     let nodesToAppend = [];
-    let headMergeStyle = ctx.head.style;
     let srcToNewHeadNodes = /* @__PURE__ */ new Map();
-    for (const newHeadChild of newHeadTag.children) {
+    for (const newHeadChild of newHead.children) {
       srcToNewHeadNodes.set(newHeadChild.outerHTML, newHeadChild);
     }
-    for (const currentHeadElt of currentHead.children) {
+    for (const currentHeadElt of oldHead.children) {
       let inNewContent = srcToNewHeadNodes.has(currentHeadElt.outerHTML);
       let isReAppended = ctx.head.shouldReAppend(currentHeadElt);
       let isPreserved = ctx.head.shouldPreserve(currentHeadElt);
@@ -344,7 +458,7 @@ var Idiomorph = /* @__PURE__ */ function() {
           preserved.push(currentHeadElt);
         }
       } else {
-        if (headMergeStyle === "append") {
+        if (ctx.head.style === "append") {
           if (isReAppended) {
             removed.push(currentHeadElt);
             nodesToAppend.push(currentHeadElt);
@@ -374,394 +488,216 @@ var Idiomorph = /* @__PURE__ */ function() {
           });
           promises.push(promise);
         }
-        currentHead.appendChild(newElt);
+        oldHead.appendChild(newElt);
         ctx.callbacks.afterNodeAdded(newElt);
         added.push(newElt);
       }
     }
     for (const removedElement of removed) {
       if (ctx.callbacks.beforeNodeRemoved(removedElement) !== false) {
-        currentHead.removeChild(removedElement);
+        oldHead.removeChild(removedElement);
         ctx.callbacks.afterNodeRemoved(removedElement);
       }
     }
-    ctx.head.afterHeadMorphed(currentHead, {
+    ctx.head.afterHeadMorphed(oldHead, {
       added,
       kept: preserved,
       removed
     });
     return promises;
   }
-  function noOp() {
-  }
-  function mergeDefaults(config2) {
-    let finalConfig = Object.assign({}, defaults);
-    Object.assign(finalConfig, config2);
-    finalConfig.callbacks = Object.assign(
-      {},
-      defaults.callbacks,
-      config2.callbacks
-    );
-    finalConfig.head = Object.assign({}, defaults.head, config2.head);
-    return finalConfig;
-  }
-  function createMorphContext(oldNode, newContent, config2) {
-    const mergedConfig = mergeDefaults(config2);
-    return {
-      target: oldNode,
-      newContent,
-      config: mergedConfig,
-      morphStyle: mergedConfig.morphStyle,
-      ignoreActive: mergedConfig.ignoreActive,
-      ignoreActiveValue: mergedConfig.ignoreActiveValue,
-      idMap: createIdMap(oldNode, newContent),
-      deadIds: /* @__PURE__ */ new Set(),
-      persistentIds: mergedConfig.twoPass ? createPersistentIds(oldNode, newContent) : /* @__PURE__ */ new Set(),
-      pantry: mergedConfig.twoPass ? createPantry() : document.createElement("div"),
-      callbacks: mergedConfig.callbacks,
-      head: mergedConfig.head
-    };
-  }
-  function createPantry() {
-    const pantry = document.createElement("div");
-    pantry.hidden = true;
-    document.body.insertAdjacentElement("afterend", pantry);
-    return pantry;
-  }
-  function isIdSetMatch(node1, node2, ctx) {
-    if (node1 == null || node2 == null) {
-      return false;
-    }
-    if (node1 instanceof Element && node2 instanceof Element && node1.tagName === node2.tagName) {
-      if (node1.id !== "" && node1.id === node2.id) {
-        return true;
-      } else {
-        return getIdIntersectionCount(ctx, node1, node2) > 0;
+  const createMorphContext = /* @__PURE__ */ function() {
+    function createMorphContext2(oldNode, newContent, config2) {
+      const { persistentIds, idMap } = createIdMaps(oldNode, newContent);
+      const mergedConfig = mergeDefaults(config2);
+      const morphStyle = mergedConfig.morphStyle || "outerHTML";
+      if (!["innerHTML", "outerHTML"].includes(morphStyle)) {
+        throw `Do not understand how to morph style ${morphStyle}`;
       }
+      return {
+        target: oldNode,
+        newContent,
+        config: mergedConfig,
+        morphStyle,
+        ignoreActive: mergedConfig.ignoreActive,
+        ignoreActiveValue: mergedConfig.ignoreActiveValue,
+        restoreFocus: mergedConfig.restoreFocus,
+        idMap,
+        persistentIds,
+        pantry: createPantry(),
+        callbacks: mergedConfig.callbacks,
+        head: mergedConfig.head
+      };
     }
-    return false;
-  }
-  function isSoftMatch(oldNode, newNode) {
-    if (oldNode == null || newNode == null) {
-      return false;
+    function mergeDefaults(config2) {
+      let finalConfig = Object.assign({}, defaults);
+      Object.assign(finalConfig, config2);
+      finalConfig.callbacks = Object.assign(
+        {},
+        defaults.callbacks,
+        config2.callbacks
+      );
+      finalConfig.head = Object.assign({}, defaults.head, config2.head);
+      return finalConfig;
     }
-    if (
-      /** @type {Element} */
-      oldNode.id && /** @type {Element} */
-      oldNode.id !== /** @type {Element} */
-      newNode.id
-    ) {
-      return false;
+    function createPantry() {
+      const pantry = document.createElement("div");
+      pantry.hidden = true;
+      document.body.insertAdjacentElement("afterend", pantry);
+      return pantry;
     }
-    return oldNode.nodeType === newNode.nodeType && /** @type {Element} */
-    oldNode.tagName === /** @type {Element} */
-    newNode.tagName;
-  }
-  function removeNodesBetween(startInclusive, endExclusive, ctx) {
-    let cursor = startInclusive;
-    while (cursor !== endExclusive) {
-      let tempNode = (
-        /** @type {Node} */
-        cursor
-      );
-      cursor = tempNode.nextSibling;
-      removeNode(tempNode, ctx);
+    function findIdElements(root) {
+      let elements = Array.from(root.querySelectorAll("[id]"));
+      if (root.id) {
+        elements.push(root);
+      }
+      return elements;
     }
-    removeIdsFromConsideration(ctx, endExclusive);
-    return endExclusive.nextSibling;
-  }
-  function findIdSetMatch(newContent, oldParent, newChild, insertionPoint, ctx) {
-    let newChildPotentialIdCount = getIdIntersectionCount(
-      ctx,
-      newChild,
-      oldParent
-    );
-    let potentialMatch = null;
-    if (newChildPotentialIdCount > 0) {
-      potentialMatch = insertionPoint;
-      let otherMatchCount = 0;
-      while (potentialMatch != null) {
-        if (isIdSetMatch(newChild, potentialMatch, ctx)) {
-          return potentialMatch;
-        }
-        otherMatchCount += getIdIntersectionCount(
-          ctx,
-          potentialMatch,
-          newContent
-        );
-        if (otherMatchCount > newChildPotentialIdCount) {
-          return null;
+    function populateIdMapWithTree(idMap, persistentIds, root, elements) {
+      for (const elt of elements) {
+        if (persistentIds.has(elt.id)) {
+          let current = elt;
+          while (current) {
+            let idSet = idMap.get(current);
+            if (idSet == null) {
+              idSet = /* @__PURE__ */ new Set();
+              idMap.set(current, idSet);
+            }
+            idSet.add(elt.id);
+            if (current === root) break;
+            current = current.parentElement;
+          }
         }
-        potentialMatch = potentialMatch.nextSibling;
       }
     }
-    return potentialMatch;
-  }
-  function findSoftMatch(newContent, oldParent, newChild, insertionPoint, ctx) {
-    let potentialSoftMatch = insertionPoint;
-    let nextSibling = newChild.nextSibling;
-    let siblingSoftMatchCount = 0;
-    while (potentialSoftMatch != null) {
-      if (getIdIntersectionCount(ctx, potentialSoftMatch, newContent) > 0) {
-        return null;
-      }
-      if (isSoftMatch(potentialSoftMatch, newChild)) {
-        return potentialSoftMatch;
+    function createIdMaps(oldContent, newContent) {
+      const oldIdElements = findIdElements(oldContent);
+      const newIdElements = findIdElements(newContent);
+      const persistentIds = createPersistentIds(oldIdElements, newIdElements);
+      let idMap = /* @__PURE__ */ new Map();
+      populateIdMapWithTree(idMap, persistentIds, oldContent, oldIdElements);
+      const newRoot = newContent.__idiomorphRoot || newContent;
+      populateIdMapWithTree(idMap, persistentIds, newRoot, newIdElements);
+      return { persistentIds, idMap };
+    }
+    function createPersistentIds(oldIdElements, newIdElements) {
+      let duplicateIds = /* @__PURE__ */ new Set();
+      let oldIdTagNameMap = /* @__PURE__ */ new Map();
+      for (const { id, tagName } of oldIdElements) {
+        if (oldIdTagNameMap.has(id)) {
+          duplicateIds.add(id);
+        } else {
+          oldIdTagNameMap.set(id, tagName);
+        }
       }
-      if (isSoftMatch(potentialSoftMatch, nextSibling)) {
-        siblingSoftMatchCount++;
-        nextSibling = /** @type {Node} */
-        nextSibling.nextSibling;
-        if (siblingSoftMatchCount >= 2) {
-          return null;
+      let persistentIds = /* @__PURE__ */ new Set();
+      for (const { id, tagName } of newIdElements) {
+        if (persistentIds.has(id)) {
+          duplicateIds.add(id);
+        } else if (oldIdTagNameMap.get(id) === tagName) {
+          persistentIds.add(id);
         }
       }
-      potentialSoftMatch = potentialSoftMatch.nextSibling;
+      for (const id of duplicateIds) {
+        persistentIds.delete(id);
+      }
+      return persistentIds;
     }
-    return potentialSoftMatch;
-  }
-  const generatedByIdiomorph = /* @__PURE__ */ new WeakSet();
-  function parseContent(newContent) {
-    let parser = new DOMParser();
-    let contentWithSvgsRemoved = newContent.replace(
-      /<svg(\s[^>]*>|>)([\s\S]*?)<\/svg>/gim,
-      ""
-    );
-    if (contentWithSvgsRemoved.match(/<\/html>/) || contentWithSvgsRemoved.match(/<\/head>/) || contentWithSvgsRemoved.match(/<\/body>/)) {
-      let content = parser.parseFromString(newContent, "text/html");
-      if (contentWithSvgsRemoved.match(/<\/html>/)) {
-        generatedByIdiomorph.add(content);
-        return content;
+    return createMorphContext2;
+  }();
+  const { normalizeElement, normalizeParent } = /* @__PURE__ */ function() {
+    const generatedByIdiomorph = /* @__PURE__ */ new WeakSet();
+    function normalizeElement2(content) {
+      if (content instanceof Document) {
+        return content.documentElement;
       } else {
-        let htmlElement = content.firstChild;
-        if (htmlElement) {
-          generatedByIdiomorph.add(htmlElement);
-          return htmlElement;
-        } else {
-          return null;
-        }
+        return content;
       }
-    } else {
-      let responseDoc = parser.parseFromString(
-        "<body><template>" + newContent + "</template></body>",
-        "text/html"
-      );
-      let content = (
-        /** @type {HTMLTemplateElement} */
-        responseDoc.body.querySelector("template").content
-      );
-      generatedByIdiomorph.add(content);
-      return content;
     }
-  }
-  function normalizeContent(newContent) {
-    if (newContent == null) {
-      const dummyParent = document.createElement("div");
-      return dummyParent;
-    } else if (generatedByIdiomorph.has(
-      /** @type {Element} */
-      newContent
-    )) {
-      return (
+    function normalizeParent2(newContent) {
+      if (newContent == null) {
+        return document.createElement("div");
+      } else if (typeof newContent === "string") {
+        return normalizeParent2(parseContent(newContent));
+      } else if (generatedByIdiomorph.has(
         /** @type {Element} */
         newContent
-      );
-    } else if (newContent instanceof Node) {
-      const dummyParent = document.createElement("div");
-      dummyParent.append(newContent);
-      return dummyParent;
-    } else {
-      const dummyParent = document.createElement("div");
-      for (const elt of [...newContent]) {
-        dummyParent.append(elt);
-      }
-      return dummyParent;
-    }
-  }
-  function insertSiblings(previousSibling, morphedNode, nextSibling) {
-    var _a, _b;
-    let stack = [];
-    let added = [];
-    while (previousSibling != null) {
-      stack.push(previousSibling);
-      previousSibling = previousSibling.previousSibling;
-    }
-    let node = stack.pop();
-    while (node !== void 0) {
-      added.push(node);
-      (_a = morphedNode.parentElement) == null ? void 0 : _a.insertBefore(node, morphedNode);
-      node = stack.pop();
-    }
-    added.push(morphedNode);
-    while (nextSibling != null) {
-      stack.push(nextSibling);
-      added.push(nextSibling);
-      nextSibling = nextSibling.nextSibling;
-    }
-    while (stack.length > 0) {
-      const node2 = (
-        /** @type {Node} */
-        stack.pop()
-      );
-      (_b = morphedNode.parentElement) == null ? void 0 : _b.insertBefore(node2, morphedNode.nextSibling);
-    }
-    return added;
-  }
-  function findBestNodeMatch(newContent, oldNode, ctx) {
-    let currentElement;
-    currentElement = newContent.firstChild;
-    let bestElement = currentElement;
-    let score = 0;
-    while (currentElement) {
-      let newScore = scoreElement(currentElement, oldNode, ctx);
-      if (newScore > score) {
-        bestElement = currentElement;
-        score = newScore;
-      }
-      currentElement = currentElement.nextSibling;
-    }
-    return bestElement;
-  }
-  function scoreElement(node1, node2, ctx) {
-    if (isSoftMatch(node2, node1)) {
-      return 0.5 + getIdIntersectionCount(
-        ctx,
-        /** @type {Node} */
-        node1,
-        node2
-      );
-    }
-    return 0;
-  }
-  function removeNode(tempNode, ctx) {
-    var _a;
-    removeIdsFromConsideration(ctx, tempNode);
-    if (ctx.config.twoPass && hasPersistentIdNodes(ctx, tempNode) && tempNode instanceof Element) {
-      moveToPantry(tempNode, ctx);
-    } else {
-      if (ctx.callbacks.beforeNodeRemoved(tempNode) === false) return;
-      (_a = tempNode.parentNode) == null ? void 0 : _a.removeChild(tempNode);
-      ctx.callbacks.afterNodeRemoved(tempNode);
-    }
-  }
-  function moveToPantry(node, ctx) {
-    var _a;
-    if (ctx.callbacks.beforeNodePantried(node) === false) return;
-    Array.from(node.childNodes).forEach((child) => {
-      moveToPantry(child, ctx);
-    });
-    if (ctx.persistentIds.has(
-      /** @type {Element} */
-      node.id
-    )) {
-      if (ctx.pantry.moveBefore) {
-        ctx.pantry.moveBefore(node, null);
+      )) {
+        return (
+          /** @type {Element} */
+          newContent
+        );
+      } else if (newContent instanceof Node) {
+        if (newContent.parentNode) {
+          return createDuckTypedParent(newContent);
+        } else {
+          const dummyParent = document.createElement("div");
+          dummyParent.append(newContent);
+          return dummyParent;
+        }
       } else {
-        ctx.pantry.insertBefore(node, null);
+        const dummyParent = document.createElement("div");
+        for (const elt of [...newContent]) {
+          dummyParent.append(elt);
+        }
+        return dummyParent;
       }
-    } else {
-      if (ctx.callbacks.beforeNodeRemoved(node) === false) return;
-      (_a = node.parentNode) == null ? void 0 : _a.removeChild(node);
-      ctx.callbacks.afterNodeRemoved(node);
     }
-  }
-  function restoreFromPantry(root, ctx) {
-    if (root instanceof Element) {
-      Array.from(ctx.pantry.children).reverse().forEach((element) => {
-        var _a;
-        const matchElement = root.querySelector(`#${element.id}`);
-        if (matchElement) {
-          if ((_a = matchElement.parentElement) == null ? void 0 : _a.moveBefore) {
-            matchElement.parentElement.moveBefore(element, matchElement);
-            while (matchElement.hasChildNodes()) {
-              element.moveBefore(matchElement.firstChild, null);
-            }
-          } else {
-            matchElement.before(element);
-            while (matchElement.firstChild) {
-              element.insertBefore(matchElement.firstChild, null);
-            }
-          }
-          if (ctx.callbacks.beforeNodeMorphed(element, matchElement) !== false) {
-            syncNodeFrom(matchElement, element, ctx);
-            ctx.callbacks.afterNodeMorphed(element, matchElement);
+    function createDuckTypedParent(newContent) {
+      return (
+        /** @type {Element} */
+        /** @type {unknown} */
+        {
+          childNodes: [newContent],
+          /** @ts-ignore - cover your eyes for a minute, tsc */
+          querySelectorAll: (s) => {
+            const elements = newContent.querySelectorAll(s);
+            return newContent.matches(s) ? [newContent, ...elements] : elements;
+          },
+          /** @ts-ignore */
+          insertBefore: (n, r) => newContent.parentNode.insertBefore(n, r),
+          /** @ts-ignore */
+          moveBefore: (n, r) => newContent.parentNode.moveBefore(n, r),
+          // for later use with populateIdMapWithTree to halt upwards iteration
+          get __idiomorphRoot() {
+            return newContent;
           }
-          matchElement.remove();
         }
-      });
-      ctx.pantry.remove();
-    }
-  }
-  function isIdInConsideration(ctx, id) {
-    return !ctx.deadIds.has(id);
-  }
-  function idIsWithinNode(ctx, id, targetNode) {
-    let idSet = ctx.idMap.get(targetNode) || EMPTY_SET;
-    return idSet.has(id);
-  }
-  function removeIdsFromConsideration(ctx, node) {
-    let idSet = ctx.idMap.get(node) || EMPTY_SET;
-    for (const id of idSet) {
-      ctx.deadIds.add(id);
-    }
-  }
-  function hasPersistentIdNodes(ctx, node) {
-    for (const id of ctx.idMap.get(node) || EMPTY_SET) {
-      if (ctx.persistentIds.has(id)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  function getIdIntersectionCount(ctx, node1, node2) {
-    let sourceSet = ctx.idMap.get(node1) || EMPTY_SET;
-    let matchCount = 0;
-    for (const id of sourceSet) {
-      if (isIdInConsideration(ctx, id) && idIsWithinNode(ctx, id, node2)) {
-        ++matchCount;
-      }
-    }
-    return matchCount;
-  }
-  function nodesWithIds(content) {
-    let nodes = Array.from(content.querySelectorAll("[id]"));
-    if (content.id) {
-      nodes.push(content);
+      );
     }
-    return nodes;
-  }
-  function populateIdMapForNode(node, idMap) {
-    let nodeParent = node.parentElement;
-    for (const elt of nodesWithIds(node)) {
-      let current = elt;
-      while (current !== nodeParent && current != null) {
-        let idSet = idMap.get(current);
-        if (idSet == null) {
-          idSet = /* @__PURE__ */ new Set();
-          idMap.set(current, idSet);
+    function parseContent(newContent) {
+      let parser = new DOMParser();
+      let contentWithSvgsRemoved = newContent.replace(
+        /<svg(\s[^>]*>|>)([\s\S]*?)<\/svg>/gim,
+        ""
+      );
+      if (contentWithSvgsRemoved.match(/<\/html>/) || contentWithSvgsRemoved.match(/<\/head>/) || contentWithSvgsRemoved.match(/<\/body>/)) {
+        let content = parser.parseFromString(newContent, "text/html");
+        if (contentWithSvgsRemoved.match(/<\/html>/)) {
+          generatedByIdiomorph.add(content);
+          return content;
+        } else {
+          let htmlElement = content.firstChild;
+          if (htmlElement) {
+            generatedByIdiomorph.add(htmlElement);
+          }
+          return htmlElement;
         }
-        idSet.add(elt.id);
-        current = current.parentElement;
-      }
-    }
-  }
-  function createIdMap(oldContent, newContent) {
-    let idMap = /* @__PURE__ */ new Map();
-    populateIdMapForNode(oldContent, idMap);
-    populateIdMapForNode(newContent, idMap);
-    return idMap;
-  }
-  function createPersistentIds(oldContent, newContent) {
-    const toIdTagName = (node) => node.tagName + "#" + node.id;
-    const oldIdSet = new Set(nodesWithIds(oldContent).map(toIdTagName));
-    let matchIdSet = /* @__PURE__ */ new Set();
-    for (const newNode of nodesWithIds(newContent)) {
-      if (oldIdSet.has(toIdTagName(newNode))) {
-        matchIdSet.add(newNode.id);
+      } else {
+        let responseDoc = parser.parseFromString(
+          "<body><template>" + newContent + "</template></body>",
+          "text/html"
+        );
+        let content = (
+          /** @type {HTMLTemplateElement} */
+          responseDoc.body.querySelector("template").content
+        );
+        generatedByIdiomorph.add(content);
+        return content;
       }
     }
-    return matchIdSet;
-  }
+    return { normalizeElement: normalizeElement2, normalizeParent: normalizeParent2 };
+  }();
   return {
     morph,
     defaults