uchi 0.1.8 → 0.2.0

data/app/assets/javascripts/uchi/application.js

@@ -611,7 +611,6 @@
     StreamElement: () => StreamElement,
     StreamSourceElement: () => StreamSourceElement,
     cache: () => cache,
-    clearCache: () => clearCache,
     config: () => config,
     connectStreamSource: () => connectStreamSource,
     disconnectStreamSource: () => disconnectStreamSource,
@@ -619,7 +618,11 @@
     fetchEnctypeFromString: () => fetchEnctypeFromString,
     fetchMethodFromString: () => fetchMethodFromString,
     isSafe: () => isSafe,
-    navigator: () => navigator$1,
+    morphBodyElements: () => morphBodyElements,
+    morphChildren: () => morphChildren,
+    morphElements: () => morphElements,
+    morphTurboFrameElements: () => morphTurboFrameElements,
+    navigator: () => sessionNavigator,
     registerAdapter: () => registerAdapter,
     renderStreamMessage: () => renderStreamMessage,
     session: () => session,
@@ -629,62 +632,6 @@
     start: () => start,
     visit: () => visit
   });
-  (function(prototype) {
-    if (typeof prototype.requestSubmit == "function") return;
-    prototype.requestSubmit = function(submitter2) {
-      if (submitter2) {
-        validateSubmitter(submitter2, this);
-        submitter2.click();
-      } else {
-        submitter2 = document.createElement("input");
-        submitter2.type = "submit";
-        submitter2.hidden = true;
-        this.appendChild(submitter2);
-        submitter2.click();
-        this.removeChild(submitter2);
-      }
-    };
-    function validateSubmitter(submitter2, form) {
-      submitter2 instanceof HTMLElement || raise(TypeError, "parameter 1 is not of type 'HTMLElement'");
-      submitter2.type == "submit" || raise(TypeError, "The specified element is not a submit button");
-      submitter2.form == form || raise(DOMException, "The specified element is not owned by this form element", "NotFoundError");
-    }
-    function raise(errorConstructor, message, name) {
-      throw new errorConstructor("Failed to execute 'requestSubmit' on 'HTMLFormElement': " + message + ".", name);
-    }
-  })(HTMLFormElement.prototype);
-  var submittersByForm = /* @__PURE__ */ new WeakMap();
-  function findSubmitterFromClickTarget(target) {
-    const element = target instanceof Element ? target : target instanceof Node ? target.parentElement : null;
-    const candidate = element ? element.closest("input, button") : null;
-    return candidate?.type == "submit" ? candidate : null;
-  }
-  function clickCaptured(event) {
-    const submitter2 = findSubmitterFromClickTarget(event.target);
-    if (submitter2 && submitter2.form) {
-      submittersByForm.set(submitter2.form, submitter2);
-    }
-  }
-  (function() {
-    if ("submitter" in Event.prototype) return;
-    let prototype = window.Event.prototype;
-    if ("SubmitEvent" in window) {
-      const prototypeOfSubmitEvent = window.SubmitEvent.prototype;
-      if (/Apple Computer/.test(navigator.vendor) && !("submitter" in prototypeOfSubmitEvent)) {
-        prototype = prototypeOfSubmitEvent;
-      } else {
-        return;
-      }
-    }
-    addEventListener("click", clickCaptured, true);
-    Object.defineProperty(prototype, "submitter", {
-      get() {
-        if (this.type == "submit" && this.target instanceof HTMLFormElement) {
-          return submittersByForm.get(this.target);
-        }
-      }
-    });
-  })();
   var FrameLoadingStyle = {
     eager: "eager",
     lazy: "lazy"
@@ -957,9 +904,6 @@
   function nextEventLoopTick() {
     return new Promise((resolve) => setTimeout(() => resolve(), 0));
   }
-  function nextMicrotask() {
-    return Promise.resolve();
-  }
   function parseHTMLDocument(html = "") {
     return new DOMParser().parseFromString(html, "text/html");
   }
@@ -984,7 +928,7 @@
       } else if (i == 19) {
         return (Math.floor(Math.random() * 4) + 8).toString(16);
       } else {
-        return Math.floor(Math.random() * 15).toString(16);
+        return Math.floor(Math.random() * 16).toString(16);
       }
     }).join("");
   }
@@ -1097,10 +1041,13 @@
     }
   }
   function findLinkFromClickTarget(target) {
-    return findClosestRecursively(target, "a[href]:not([target^=_]):not([download])");
-  }
-  function getLocationForLink(link) {
-    return expandURL(link.getAttribute("href") || "");
+    const link = findClosestRecursively(target, "a[href], a[xlink\\:href]");
+    if (!link) return null;
+    if (link.href.startsWith("#")) return null;
+    if (link.hasAttribute("download")) return null;
+    const linkTarget = link.getAttribute("target");
+    if (linkTarget && linkTarget !== "_self") return null;
+    return link;
   }
   function debounce(fn, delay) {
     let timeoutId = null;
@@ -1165,12 +1112,15 @@
     return (getLastPathComponent(url).match(/\.[^.]*$/) || [])[0] || "";
   }
   function isPrefixedBy(baseURL, url) {
-    const prefix = getPrefix(url);
-    return baseURL.href === expandURL(prefix).href || baseURL.href.startsWith(prefix);
+    const prefix = addTrailingSlash(url.origin + url.pathname);
+    return addTrailingSlash(baseURL.href) === prefix || baseURL.href.startsWith(prefix);
   }
   function locationIsVisitable(location2, rootLocation) {
     return isPrefixedBy(location2, rootLocation) && !config.drive.unvisitableExtensions.has(getExtension(location2));
   }
+  function getLocationForLink(link) {
+    return expandURL(link.getAttribute("href") || "");
+  }
   function getRequestURL(url) {
     const anchor = getAnchor(url);
     return anchor != null ? url.href.slice(0, -(anchor.length + 1)) : url.href;
@@ -1187,9 +1137,6 @@
   function getLastPathComponent(url) {
     return getPathComponents(url).slice(-1)[0];
   }
-  function getPrefix(url) {
-    return addTrailingSlash(url.origin + url.pathname);
-  }
   function addTrailingSlash(value) {
     return value.endsWith("/") ? value : value + "/";
   }
@@ -1253,13 +1200,12 @@
     }
   };
   var recentRequests = new LimitedSet(20);
-  var nativeFetch = window.fetch;
   function fetchWithTurboHeaders(url, options = {}) {
     const modifiedHeaders = new Headers(options.headers || {});
     const requestUID = uuid();
     recentRequests.add(requestUID);
     modifiedHeaders.append("X-Turbo-Request-Id", requestUID);
-    return nativeFetch(url, {
+    return window.fetch(url, {
       ...options,
       headers: modifiedHeaders
     });
@@ -1513,29 +1459,92 @@
     }
     return fragment;
   }
+  var identity = (key) => key;
+  var LRUCache = class {
+    keys = [];
+    entries = {};
+    #toCacheKey;
+    constructor(size, toCacheKey2 = identity) {
+      this.size = size;
+      this.#toCacheKey = toCacheKey2;
+    }
+    has(key) {
+      return this.#toCacheKey(key) in this.entries;
+    }
+    get(key) {
+      if (this.has(key)) {
+        const entry = this.read(key);
+        this.touch(key);
+        return entry;
+      }
+    }
+    put(key, entry) {
+      this.write(key, entry);
+      this.touch(key);
+      return entry;
+    }
+    clear() {
+      for (const key of Object.keys(this.entries)) {
+        this.evict(key);
+      }
+    }
+    // Private
+    read(key) {
+      return this.entries[this.#toCacheKey(key)];
+    }
+    write(key, entry) {
+      this.entries[this.#toCacheKey(key)] = entry;
+    }
+    touch(key) {
+      key = this.#toCacheKey(key);
+      const index = this.keys.indexOf(key);
+      if (index > -1) this.keys.splice(index, 1);
+      this.keys.unshift(key);
+      this.trim();
+    }
+    trim() {
+      for (const key of this.keys.splice(this.size)) {
+        this.evict(key);
+      }
+    }
+    evict(key) {
+      delete this.entries[key];
+    }
+  };
   var PREFETCH_DELAY = 100;
-  var PrefetchCache = class {
+  var PrefetchCache = class extends LRUCache {
     #prefetchTimeout = null;
-    #prefetched = null;
-    get(url) {
-      if (this.#prefetched && this.#prefetched.url === url && this.#prefetched.expire > Date.now()) {
-        return this.#prefetched.request;
-      }
+    #maxAges = {};
+    constructor(size = 1, prefetchDelay = PREFETCH_DELAY) {
+      super(size, toCacheKey);
+      this.prefetchDelay = prefetchDelay;
     }
-    setLater(url, request, ttl) {
-      this.clear();
+    putLater(url, request, ttl) {
       this.#prefetchTimeout = setTimeout(() => {
         request.perform();
-        this.set(url, request, ttl);
+        this.put(url, request, ttl);
         this.#prefetchTimeout = null;
-      }, PREFETCH_DELAY);
+      }, this.prefetchDelay);
     }
-    set(url, request, ttl) {
-      this.#prefetched = { url, request, expire: new Date((/* @__PURE__ */ new Date()).getTime() + ttl) };
+    put(url, request, ttl = cacheTtl) {
+      super.put(url, request);
+      this.#maxAges[toCacheKey(url)] = new Date((/* @__PURE__ */ new Date()).getTime() + ttl);
     }
     clear() {
+      super.clear();
       if (this.#prefetchTimeout) clearTimeout(this.#prefetchTimeout);
-      this.#prefetched = null;
+    }
+    evict(key) {
+      super.evict(key);
+      delete this.#maxAges[key];
+    }
+    has(key) {
+      if (super.has(key)) {
+        const maxAge = this.#maxAges[toCacheKey(key)];
+        return maxAge && maxAge > Date.now();
+      } else {
+        return false;
+      }
     }
   };
   var cacheTtl = 10 * 1e3;
@@ -1849,8 +1858,8 @@
     scrollToAnchor(anchor) {
       const element = this.snapshot.getElementForAnchor(anchor);
       if (element) {
-        this.scrollToElement(element);
         this.focusElement(element);
+        this.scrollToElement(element);
       } else {
         this.scrollToPosition({ x: 0, y: 0 });
       }
@@ -2311,9 +2320,6 @@
     }
     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);
       morphChildren2(
         ctx,
         oldParent,
@@ -2324,8 +2330,7 @@
         oldNode.nextSibling
         // end point for iteration
       );
-      childNodes = Array.from(oldParent.childNodes);
-      return childNodes.slice(index, childNodes.length - rightMargin);
+      return Array.from(oldParent.childNodes);
     }
     function saveAndRestoreFocus(ctx, fn) {
       if (!ctx.config.restoreFocus) return fn();
@@ -2338,8 +2343,8 @@
       }
       const { id: activeElementId, selectionStart, selectionEnd } = activeElement;
       const results = fn();
-      if (activeElementId && activeElementId !== document.activeElement?.id) {
-        activeElement = ctx.target.querySelector(`#${activeElementId}`);
+      if (activeElementId && activeElementId !== document.activeElement?.getAttribute("id")) {
+        activeElement = ctx.target.querySelector(`[id="${activeElementId}"]`);
         activeElement?.focus();
       }
       if (activeElement && !activeElement.selectionEnd && selectionEnd) {
@@ -2371,16 +2376,22 @@
               continue;
             }
           }
-          if (newChild instanceof Element && ctx.persistentIds.has(newChild.id)) {
-            const movedChild = moveBeforeById(
-              oldParent,
-              newChild.id,
-              insertionPoint,
-              ctx
+          if (newChild instanceof Element) {
+            const newChildId = (
+              /** @type {String} */
+              newChild.getAttribute("id")
             );
-            morphNode(movedChild, newChild, ctx);
-            insertionPoint = movedChild.nextSibling;
-            continue;
+            if (ctx.persistentIds.has(newChildId)) {
+              const movedChild = moveBeforeById(
+                oldParent,
+                newChildId,
+                insertionPoint,
+                ctx
+              );
+              morphNode(movedChild, newChild, ctx);
+              insertionPoint = movedChild.nextSibling;
+              continue;
+            }
           }
           const insertedNode = createNode(
             oldParent,
@@ -2440,7 +2451,7 @@
                 softMatch = void 0;
               }
             }
-            if (cursor.contains(document.activeElement)) break;
+            if (ctx.activeElementAndParents.includes(cursor)) break;
             cursor = cursor.nextSibling;
           }
           return softMatch || null;
@@ -2468,7 +2479,8 @@
           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);
+          // We can't use .id because of form input shadowing, and we can't count on .getAttribute's presence because it could be a document-fragment
+          (!oldElt.getAttribute?.("id") || oldElt.getAttribute?.("id") === newElt.getAttribute?.("id"));
         }
         return findBestMatch2;
       })();
@@ -2496,14 +2508,19 @@
       function moveBeforeById(parentNode, id, after, ctx) {
         const target = (
           /** @type {Element} - will always be found */
-          ctx.target.querySelector(`#${id}`) || ctx.pantry.querySelector(`#${id}`)
+          // ctx.target.id unsafe because of form input shadowing
+          // ctx.target could be a document fragment which doesn't have `getAttribute`
+          ctx.target.getAttribute?.("id") === id && ctx.target || ctx.target.querySelector(`[id="${id}"]`) || ctx.pantry.querySelector(`[id="${id}"]`)
         );
         removeElementFromAncestorsIdMaps(target, ctx);
         moveBefore(parentNode, target, after);
         return target;
       }
       function removeElementFromAncestorsIdMaps(element, ctx) {
-        const id = element.id;
+        const id = (
+          /** @type {String} */
+          element.getAttribute("id")
+        );
         while (element = element.parentNode) {
           let idSet = ctx.idMap.get(element);
           if (idSet) {
@@ -2767,6 +2784,7 @@
           idMap,
           persistentIds,
           pantry: createPantry(),
+          activeElementAndParents: createActiveElementAndParents(oldNode),
           callbacks: mergedConfig.callbacks,
           head: mergedConfig.head
         };
@@ -2788,16 +2806,32 @@
         document.body.insertAdjacentElement("afterend", pantry);
         return pantry;
       }
+      function createActiveElementAndParents(oldNode) {
+        let activeElementAndParents = [];
+        let elt = document.activeElement;
+        if (elt?.tagName !== "BODY" && oldNode.contains(elt)) {
+          while (elt) {
+            activeElementAndParents.push(elt);
+            if (elt === oldNode) break;
+            elt = elt.parentElement;
+          }
+        }
+        return activeElementAndParents;
+      }
       function findIdElements(root) {
         let elements = Array.from(root.querySelectorAll("[id]"));
-        if (root.id) {
+        if (root.getAttribute?.("id")) {
           elements.push(root);
         }
         return elements;
       }
       function populateIdMapWithTree(idMap, persistentIds, root, elements) {
         for (const elt of elements) {
-          if (persistentIds.has(elt.id)) {
+          const id = (
+            /** @type {String} */
+            elt.getAttribute("id")
+          );
+          if (persistentIds.has(id)) {
             let current = elt;
             while (current) {
               let idSet = idMap.get(current);
@@ -2805,7 +2839,7 @@
                 idSet = /* @__PURE__ */ new Set();
                 idMap.set(current, idSet);
               }
-              idSet.add(elt.id);
+              idSet.add(id);
               if (current === root) break;
               current = current.parentElement;
             }
@@ -2871,7 +2905,10 @@
           );
         } else if (newContent instanceof Node) {
           if (newContent.parentNode) {
-            return createDuckTypedParent(newContent);
+            return (
+              /** @type {any} */
+              new SlicedParentNode(newContent)
+            );
           } else {
             const dummyParent = document.createElement("div");
             dummyParent.append(newContent);
@@ -2885,27 +2922,68 @@
           return dummyParent;
         }
       }
-      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;
-            }
+      class SlicedParentNode {
+        /** @param {Node} node */
+        constructor(node) {
+          this.originalNode = node;
+          this.realParentNode = /** @type {Element} */
+          node.parentNode;
+          this.previousSibling = node.previousSibling;
+          this.nextSibling = node.nextSibling;
+        }
+        /** @returns {Node[]} */
+        get childNodes() {
+          const nodes = [];
+          let cursor = this.previousSibling ? this.previousSibling.nextSibling : this.realParentNode.firstChild;
+          while (cursor && cursor != this.nextSibling) {
+            nodes.push(cursor);
+            cursor = cursor.nextSibling;
           }
-        );
+          return nodes;
+        }
+        /**
+         * @param {string} selector
+         * @returns {Element[]}
+         */
+        querySelectorAll(selector) {
+          return this.childNodes.reduce(
+            (results, node) => {
+              if (node instanceof Element) {
+                if (node.matches(selector)) results.push(node);
+                const nodeList = node.querySelectorAll(selector);
+                for (let i = 0; i < nodeList.length; i++) {
+                  results.push(nodeList[i]);
+                }
+              }
+              return results;
+            },
+            /** @type {Element[]} */
+            []
+          );
+        }
+        /**
+         * @param {Node} node
+         * @param {Node} referenceNode
+         * @returns {Node}
+         */
+        insertBefore(node, referenceNode) {
+          return this.realParentNode.insertBefore(node, referenceNode);
+        }
+        /**
+         * @param {Node} node
+         * @param {Node} referenceNode
+         * @returns {Node}
+         */
+        moveBefore(node, referenceNode) {
+          return this.realParentNode.moveBefore(node, referenceNode);
+        }
+        /**
+         * for later use with populateIdMapWithTree to halt upwards iteration
+         * @returns {Node}
+         */
+        get __idiomorphRoot() {
+          return this.originalNode;
+        }
       }
       function parseContent(newContent) {
         let parser = new DOMParser();
@@ -2951,11 +3029,21 @@
       callbacks: new DefaultIdiomorphCallbacks(callbacks)
     });
   }
-  function morphChildren(currentElement, newElement) {
+  function morphChildren(currentElement, newElement, options = {}) {
     morphElements(currentElement, newElement.childNodes, {
+      ...options,
       morphStyle: "innerHTML"
     });
   }
+  function shouldRefreshFrameWithMorphing(currentFrame, newFrame) {
+    return currentFrame instanceof FrameElement && currentFrame.shouldReloadWithMorph && (!newFrame || areFramesCompatibleForRefreshing(currentFrame, newFrame)) && !currentFrame.closest("[data-turbo-permanent]");
+  }
+  function areFramesCompatibleForRefreshing(currentFrame, newFrame) {
+    return newFrame instanceof Element && newFrame.nodeName === "TURBO-FRAME" && currentFrame.id === newFrame.id && (!newFrame.getAttribute("src") || urlsAreEqual(currentFrame.src, newFrame.getAttribute("src")));
+  }
+  function closestFrameReloadableWithMorphing(node) {
+    return node.parentElement.closest("turbo-frame[src][refresh=morph]");
+  }
   var DefaultIdiomorphCallbacks = class {
     #beforeNodeMorphed;
     constructor({ beforeNodeMorphed } = {}) {
@@ -3004,7 +3092,17 @@
         target: currentElement,
         detail: { currentElement, newElement }
       });
-      morphChildren(currentElement, newElement);
+      morphChildren(currentElement, newElement, {
+        callbacks: {
+          beforeNodeMorphed: (node, newNode) => {
+            if (shouldRefreshFrameWithMorphing(node, newNode) && closestFrameReloadableWithMorphing(node) === currentElement) {
+              node.reload();
+              return false;
+            }
+            return true;
+          }
+        }
+      });
     }
     async preservingPermanentElements(callback) {
       return await callback();
@@ -3225,11 +3323,17 @@
       for (const clonedPasswordInput of clonedElement.querySelectorAll('input[type="password"]')) {
         clonedPasswordInput.value = "";
       }
+      for (const clonedNoscriptElement of clonedElement.querySelectorAll("noscript")) {
+        clonedNoscriptElement.remove();
+      }
       return new _PageSnapshot(this.documentElement, clonedElement, this.headSnapshot);
     }
     get lang() {
       return this.documentElement.getAttribute("lang");
     }
+    get dir() {
+      return this.documentElement.getAttribute("dir");
+    }
     get headElement() {
       return this.headSnapshot.element;
     }
@@ -3250,13 +3354,14 @@
       return this.getSetting("visit-control") != "reload";
     }
     get prefersViewTransitions() {
-      return this.headSnapshot.getMetaValue("view-transition") === "same-origin";
+      const viewTransitionEnabled = this.getSetting("view-transition") === "true" || this.headSnapshot.getMetaValue("view-transition") === "same-origin";
+      return viewTransitionEnabled && !window.matchMedia("(prefers-reduced-motion: reduce)").matches;
     }
-    get shouldMorphPage() {
-      return this.getSetting("refresh-method") === "morph";
+    get refreshMethod() {
+      return this.getSetting("refresh-method");
     }
-    get shouldPreserveScrollPosition() {
-      return this.getSetting("refresh-scroll") === "preserve";
+    get refreshScroll() {
+      return this.getSetting("refresh-scroll");
     }
     // Private
     getSetting(name) {
@@ -3289,7 +3394,8 @@
     willRender: true,
     updateHistory: true,
     shouldCacheSnapshot: true,
-    acceptsStreamResponse: false
+    acceptsStreamResponse: false,
+    refresh: {}
   };
   var TimingMetric = {
     visitStart: "visitStart",
@@ -3342,7 +3448,8 @@
         updateHistory,
         shouldCacheSnapshot,
         acceptsStreamResponse,
-        direction
+        direction,
+        refresh
       } = {
         ...defaultOptions,
         ...options
@@ -3353,7 +3460,6 @@
       this.snapshot = snapshot;
       this.snapshotHTML = snapshotHTML;
       this.response = response;
-      this.isSamePage = this.delegate.locationWithActionIsSamePage(this.location, this.action);
       this.isPageRefresh = this.view.isPageRefresh(this);
       this.visitCachedSnapshot = visitCachedSnapshot;
       this.willRender = willRender;
@@ -3362,6 +3468,7 @@
       this.shouldCacheSnapshot = shouldCacheSnapshot;
       this.acceptsStreamResponse = acceptsStreamResponse;
       this.direction = direction || Direction[action];
+      this.refresh = refresh;
     }
     get adapter() {
       return this.delegate.adapter;
@@ -3375,9 +3482,6 @@
     get restorationData() {
       return this.history.getRestorationDataForIdentifier(this.restorationIdentifier);
     }
-    get silent() {
-      return this.isSamePage;
-    }
     start() {
       if (this.state == VisitState.initialized) {
         this.recordTimingMetric(TimingMetric.visitStart);
@@ -3496,7 +3600,7 @@
         const isPreview = this.shouldIssueRequest();
         this.render(async () => {
           this.cacheSnapshot();
-          if (this.isSamePage || this.isPageRefresh) {
+          if (this.isPageRefresh) {
             this.adapter.visitRendered(this);
           } else {
             if (this.view.renderPromise) await this.view.renderPromise;
@@ -3520,16 +3624,6 @@
         this.followedRedirect = true;
       }
     }
-    goToSamePageAnchor() {
-      if (this.isSamePage) {
-        this.render(async () => {
-          this.cacheSnapshot();
-          this.performScroll();
-          this.changeHistory();
-          this.adapter.visitRendered(this);
-        });
-      }
-    }
     // Fetch request delegate
     prepareRequest(request) {
       if (this.acceptsStreamResponse) {
@@ -3583,9 +3677,6 @@
         } else {
           this.scrollToAnchor() || this.view.scrollToTop();
         }
-        if (this.isSamePage) {
-          this.delegate.visitScrolledToSamePageLocation(this.view.lastRenderedLocation, this.location);
-        }
         this.scrolled = true;
       }
     }
@@ -3615,9 +3706,7 @@
       return typeof this.response == "object";
     }
     shouldIssueRequest() {
-      if (this.isSamePage) {
-        return false;
-      } else if (this.action == "restore") {
+      if (this.action == "restore") {
         return !this.hasCachedSnapshot();
       } else {
         return this.willRender;
@@ -3667,9 +3756,9 @@
     }
     visitStarted(visit2) {
       this.location = visit2.location;
+      this.redirectedToLocation = null;
       visit2.loadCachedSnapshot();
       visit2.issueRequest();
-      visit2.goToSamePageAnchor();
     }
     visitRequestStarted(visit2) {
       this.progressBar.setValue(0);
@@ -3681,6 +3770,9 @@
     }
     visitRequestCompleted(visit2) {
       visit2.loadResponse();
+      if (visit2.response.redirected) {
+        this.redirectedToLocation = visit2.redirectedToLocation;
+      }
     }
     visitRequestFailedWithStatusCode(visit2, statusCode) {
       switch (statusCode) {
@@ -3753,7 +3845,7 @@
     };
     reload(reason) {
       dispatch("turbo:reload", { detail: reason });
-      window.location.href = this.location?.toString() || window.location.href;
+      window.location.href = (this.redirectedToLocation || this.location)?.toString() || window.location.href;
     }
     get navigator() {
       return this.session.navigator;
@@ -3761,7 +3853,6 @@
   };
   var CacheObserver = class {
     selector = "[data-turbo-temporary]";
-    deprecatedSelector = "[data-turbo-cache=false]";
     started = false;
     start() {
       if (!this.started) {
@@ -3781,16 +3872,7 @@
       }
     };
     get temporaryElements() {
-      return [...document.querySelectorAll(this.selector), ...this.temporaryElementsWithDeprecation];
-    }
-    get temporaryElementsWithDeprecation() {
-      const elements = document.querySelectorAll(this.deprecatedSelector);
-      if (elements.length) {
-        console.warn(
-          `The ${this.deprecatedSelector} selector is deprecated and will be removed in a future version. Use ${this.selector} instead.`
-        );
-      }
-      return [...elements];
+      return [...document.querySelectorAll(this.selector)];
     }
   };
   var FrameRedirector = class {
@@ -3858,7 +3940,6 @@
     restorationIdentifier = uuid();
     restorationData = {};
     started = false;
-    pageLoaded = false;
     currentIndex = 0;
     constructor(delegate) {
       this.delegate = delegate;
@@ -3866,7 +3947,6 @@
     start() {
       if (!this.started) {
         addEventListener("popstate", this.onPopState, false);
-        addEventListener("load", this.onPageLoad, false);
         this.currentIndex = history.state?.turbo?.restorationIndex || 0;
         this.started = true;
         this.replace(new URL(window.location.href));
@@ -3875,7 +3955,6 @@
     stop() {
       if (this.started) {
         removeEventListener("popstate", this.onPopState, false);
-        removeEventListener("load", this.onPageLoad, false);
         this.started = false;
       }
     }
@@ -3919,29 +3998,19 @@
     }
     // Event handlers
     onPopState = (event) => {
-      if (this.shouldHandlePopState()) {
-        const { turbo } = event.state || {};
-        if (turbo) {
-          this.location = new URL(window.location.href);
-          const { restorationIdentifier, restorationIndex } = turbo;
-          this.restorationIdentifier = restorationIdentifier;
-          const direction = restorationIndex > this.currentIndex ? "forward" : "back";
-          this.delegate.historyPoppedToLocationWithRestorationIdentifierAndDirection(this.location, restorationIdentifier, direction);
-          this.currentIndex = restorationIndex;
-        }
+      const { turbo } = event.state || {};
+      this.location = new URL(window.location.href);
+      if (turbo) {
+        const { restorationIdentifier, restorationIndex } = turbo;
+        this.restorationIdentifier = restorationIdentifier;
+        const direction = restorationIndex > this.currentIndex ? "forward" : "back";
+        this.delegate.historyPoppedToLocationWithRestorationIdentifierAndDirection(this.location, restorationIdentifier, direction);
+        this.currentIndex = restorationIndex;
+      } else {
+        this.currentIndex++;
+        this.delegate.historyPoppedWithEmptyState(this.location);
       }
     };
-    onPageLoad = async (_event) => {
-      await nextMicrotask();
-      this.pageLoaded = true;
-    };
-    // Private
-    shouldHandlePopState() {
-      return this.pageIsLoaded();
-    }
-    pageIsLoaded() {
-      return this.pageLoaded || document.readyState == "complete";
-    }
   };
   var LinkPrefetchObserver = class {
     started = false;
@@ -3999,7 +4068,8 @@
             new URLSearchParams(),
             target
           );
-          prefetchCache.setLater(location2.toString(), fetchRequest, this.#cacheTtl);
+          fetchRequest.fetchOptions.priority = "low";
+          prefetchCache.putLater(location2, fetchRequest, this.#cacheTtl);
         }
       }
     };
@@ -4012,7 +4082,7 @@
     };
     #tryToUsePrefetchedRequest = (event) => {
       if (event.target.tagName !== "FORM" && event.detail.fetchOptions.method === "GET") {
-        const cached = prefetchCache.get(event.detail.url.toString());
+        const cached = prefetchCache.get(event.detail.url);
         if (cached) {
           event.detail.fetchRequest = cached;
         }
@@ -4161,7 +4231,7 @@
         } else {
           await this.view.renderPage(snapshot, false, true, this.currentVisit);
         }
-        if (!snapshot.shouldPreserveScrollPosition) {
+        if (snapshot.refreshScroll !== "preserve") {
           this.view.scrollToTop();
         }
         this.view.clearSnapshotCache();
@@ -4190,14 +4260,10 @@
       this.delegate.visitCompleted(visit2);
       delete this.currentVisit;
     }
+    // Same-page links are no longer handled with a Visit.
+    // This method is still needed for Turbo Native adapters.
     locationWithActionIsSamePage(location2, action) {
-      const anchor = getAnchor(location2);
-      const currentAnchor = getAnchor(this.view.lastRenderedLocation);
-      const isRestorationToTop = action === "restore" && typeof anchor === "undefined";
-      return action !== "replace" && getRequestURL(location2) === getRequestURL(this.view.lastRenderedLocation) && (isRestorationToTop || anchor != null && anchor !== currentAnchor);
-    }
-    visitScrolledToSamePageLocation(oldURL, newURL) {
-      this.delegate.visitScrolledToSamePageLocation(oldURL, newURL);
+      return false;
     }
     // Visits
     get location() {
@@ -4516,12 +4582,17 @@
     }
     #setLanguage() {
       const { documentElement } = this.currentSnapshot;
-      const { lang } = this.newSnapshot;
+      const { dir, lang } = this.newSnapshot;
       if (lang) {
         documentElement.setAttribute("lang", lang);
       } else {
         documentElement.removeAttribute("lang");
       }
+      if (dir) {
+        documentElement.setAttribute("dir", dir);
+      } else {
+        documentElement.removeAttribute("dir");
+      }
     }
     async mergeHead() {
       const mergedHeadElements = this.mergeProvisionalElements();
@@ -4601,8 +4672,14 @@
     }
     activateNewBody() {
       document.adoptNode(this.newElement);
+      this.removeNoscriptElements();
       this.activateNewBodyScriptElements();
     }
+    removeNoscriptElements() {
+      for (const noscriptElement of this.newElement.querySelectorAll("noscript")) {
+        noscriptElement.remove();
+      }
+    }
     activateNewBodyScriptElements() {
       for (const inertScriptElement of this.newBodyScriptElements) {
         const activatedScriptElement = activateScriptElement(inertScriptElement);
@@ -4640,12 +4717,15 @@
     static renderElement(currentElement, newElement) {
       morphElements(currentElement, newElement, {
         callbacks: {
-          beforeNodeMorphed: (element) => !canRefreshFrame(element)
+          beforeNodeMorphed: (node, newNode) => {
+            if (shouldRefreshFrameWithMorphing(node, newNode) && !closestFrameReloadableWithMorphing(node)) {
+              node.reload();
+              return false;
+            }
+            return true;
+          }
         }
       });
-      for (const frame of currentElement.querySelectorAll("turbo-frame")) {
-        if (canRefreshFrame(frame)) frame.reload();
-      }
       dispatch("turbo:morph", { detail: { currentElement, newElement } });
     }
     async preservingPermanentElements(callback) {
@@ -4658,51 +4738,12 @@
       return false;
     }
   };
-  function canRefreshFrame(frame) {
-    return frame instanceof FrameElement && frame.src && frame.refresh === "morph" && !frame.closest("[data-turbo-permanent]");
-  }
-  var SnapshotCache = class {
-    keys = [];
-    snapshots = {};
+  var SnapshotCache = class extends LRUCache {
     constructor(size) {
-      this.size = size;
-    }
-    has(location2) {
-      return toCacheKey(location2) in this.snapshots;
-    }
-    get(location2) {
-      if (this.has(location2)) {
-        const snapshot = this.read(location2);
-        this.touch(location2);
-        return snapshot;
-      }
-    }
-    put(location2, snapshot) {
-      this.write(location2, snapshot);
-      this.touch(location2);
-      return snapshot;
+      super(size, toCacheKey);
     }
-    clear() {
-      this.snapshots = {};
-    }
-    // Private
-    read(location2) {
-      return this.snapshots[toCacheKey(location2)];
-    }
-    write(location2, snapshot) {
-      this.snapshots[toCacheKey(location2)] = snapshot;
-    }
-    touch(location2) {
-      const key = toCacheKey(location2);
-      const index = this.keys.indexOf(key);
-      if (index > -1) this.keys.splice(index, 1);
-      this.keys.unshift(key);
-      this.trim();
-    }
-    trim() {
-      for (const key of this.keys.splice(this.size)) {
-        delete this.snapshots[key];
-      }
+    get snapshots() {
+      return this.entries;
     }
   };
   var PageView = class extends View {
@@ -4713,7 +4754,7 @@
       return this.snapshot.prefersViewTransitions && newSnapshot.prefersViewTransitions;
     }
     renderPage(snapshot, isPreview = false, willRender = true, visit2) {
-      const shouldMorphPage = this.isPageRefresh(visit2) && this.snapshot.shouldMorphPage;
+      const shouldMorphPage = this.isPageRefresh(visit2) && (visit2?.refresh?.method || this.snapshot.refreshMethod) === "morph";
       const rendererClass = shouldMorphPage ? MorphingPageRenderer : PageRenderer;
       const renderer = new rendererClass(this.snapshot, snapshot, isPreview, willRender);
       if (!renderer.shouldRender) {
@@ -4748,7 +4789,7 @@
       return !visit2 || this.lastRenderedLocation.pathname === visit2.location.pathname && visit2.action === "replace";
     }
     shouldPreserveScrollPosition(visit2) {
-      return this.isPageRefresh(visit2) && this.snapshot.shouldPreserveScrollPosition;
+      return this.isPageRefresh(visit2) && (visit2?.refresh?.scroll || this.snapshot.refreshScroll) === "preserve";
     }
     get snapshot() {
       return PageSnapshot.fromElement(this.element);
@@ -4905,11 +4946,13 @@
         this.navigator.proposeVisit(expandURL(location2), options);
       }
     }
-    refresh(url, requestId) {
+    refresh(url, options = {}) {
+      options = typeof options === "string" ? { requestId: options } : options;
+      const { method, requestId, scroll } = options;
       const isRecentRequest = requestId && this.recentRequests.has(requestId);
       const isCurrentUrl = url === document.baseURI;
       if (!isRecentRequest && !this.navigator.currentVisit && isCurrentUrl) {
-        this.visit(url, { action: "replace", shouldCacheSnapshot: false });
+        this.visit(url, { action: "replace", shouldCacheSnapshot: false, refresh: { method, scroll } });
       }
     }
     connectStreamSource(source) {
@@ -4988,6 +5031,11 @@
         });
       }
     }
+    historyPoppedWithEmptyState(location2) {
+      this.history.replace(location2);
+      this.view.lastRenderedLocation = location2;
+      this.view.cacheSnapshot();
+    }
     // Scroll observer delegate
     scrollPositionChanged(position) {
       this.history.updateRestorationData({ scrollPosition: position });
@@ -5013,7 +5061,7 @@
     }
     // Navigator delegate
     allowsVisitingLocationWithAction(location2, action) {
-      return this.locationWithActionIsSamePage(location2, action) || this.applicationAllowsVisitingLocation(location2);
+      return this.applicationAllowsVisitingLocation(location2);
     }
     visitProposedToLocation(location2, options) {
       extendURLWithDeprecatedProperties(location2);
@@ -5026,21 +5074,13 @@
         this.view.markVisitDirection(visit2.direction);
       }
       extendURLWithDeprecatedProperties(visit2.location);
-      if (!visit2.silent) {
-        this.notifyApplicationAfterVisitingLocation(visit2.location, visit2.action);
-      }
+      this.notifyApplicationAfterVisitingLocation(visit2.location, visit2.action);
     }
     visitCompleted(visit2) {
       this.view.unmarkVisitDirection();
       clearBusyState(document.documentElement);
       this.notifyApplicationAfterPageLoad(visit2.getTimingMetrics());
     }
-    locationWithActionIsSamePage(location2, action) {
-      return this.navigator.locationWithActionIsSamePage(location2, action);
-    }
-    visitScrolledToSamePageLocation(oldURL, newURL) {
-      this.notifyApplicationAfterVisitingSamePageLocation(oldURL, newURL);
-    }
     // Form submit observer delegate
     willSubmitForm(form, submitter2) {
       const action = getAction$1(form, submitter2);
@@ -5066,9 +5106,7 @@
     }
     // Page view delegate
     viewWillCacheSnapshot() {
-      if (!this.navigator.currentVisit?.silent) {
-        this.notifyApplicationBeforeCachingSnapshot();
-      }
+      this.notifyApplicationBeforeCachingSnapshot();
     }
     allowsImmediateRender({ element }, options) {
       const event = this.notifyApplicationBeforeRender(element, options);
@@ -5140,14 +5178,6 @@
         detail: { url: this.location.href, timing }
       });
     }
-    notifyApplicationAfterVisitingSamePageLocation(oldURL, newURL) {
-      dispatchEvent(
-        new HashChangeEvent("hashchange", {
-          oldURL: oldURL.toString(),
-          newURL: newURL.toString()
-        })
-      );
-    }
     notifyApplicationAfterFrameLoad(frame) {
       return dispatch("turbo:frame-load", { target: frame });
     }
@@ -5207,7 +5237,7 @@
     }
   };
   var session = new Session(recentRequests);
-  var { cache, navigator: navigator$1 } = session;
+  var { cache, navigator: sessionNavigator } = session;
   function start() {
     session.start();
   }
@@ -5226,12 +5256,6 @@
   function renderStreamMessage(message) {
     session.renderStreamMessage(message);
   }
-  function clearCache() {
-    console.warn(
-      "Please replace `Turbo.clearCache()` with `Turbo.cache.clear()`. The top-level function is deprecated and will be removed in a future version of Turbo.`"
-    );
-    session.clearCache();
-  }
   function setProgressBarDelay(delay) {
     console.warn(
       "Please replace `Turbo.setProgressBarDelay(delay)` with `Turbo.config.drive.progressBarDelay = delay`. The top-level function is deprecated and will be removed in a future version of Turbo.`"
@@ -5250,26 +5274,35 @@
     );
     config.forms.mode = mode;
   }
+  function morphBodyElements(currentBody, newBody) {
+    MorphingPageRenderer.renderElement(currentBody, newBody);
+  }
+  function morphTurboFrameElements(currentFrame, newFrame) {
+    MorphingFrameRenderer.renderElement(currentFrame, newFrame);
+  }
   var Turbo = /* @__PURE__ */ Object.freeze({
     __proto__: null,
-    navigator: navigator$1,
-    session,
-    cache,
     PageRenderer,
     PageSnapshot,
     FrameRenderer,
     fetch: fetchWithTurboHeaders,
     config,
+    session,
+    cache,
+    navigator: sessionNavigator,
     start,
     registerAdapter,
     visit,
     connectStreamSource,
     disconnectStreamSource,
     renderStreamMessage,
-    clearCache,
     setProgressBarDelay,
     setConfirmMethod,
-    setFormMode
+    setFormMode,
+    morphBodyElements,
+    morphTurboFrameElements,
+    morphChildren,
+    morphElements
   });
   var TurboFrameMissingError = class extends Error {
   };
@@ -5313,15 +5346,23 @@
         this.formLinkClickObserver.stop();
         this.linkInterceptor.stop();
         this.formSubmitObserver.stop();
+        if (!this.element.hasAttribute("recurse")) {
+          this.#currentFetchRequest?.cancel();
+        }
       }
     }
     disabledChanged() {
-      if (this.loadingStyle == FrameLoadingStyle.eager) {
+      if (this.disabled) {
+        this.#currentFetchRequest?.cancel();
+      } else if (this.loadingStyle == FrameLoadingStyle.eager) {
         this.#loadSourceURL();
       }
     }
     sourceURLChanged() {
       if (this.#isIgnoringChangesTo("src")) return;
+      if (!this.sourceURL) {
+        this.#currentFetchRequest?.cancel();
+      }
       if (this.element.isConnected) {
         this.complete = false;
       }
@@ -5403,12 +5444,13 @@
       }
       this.formSubmission = new FormSubmission(this, element, submitter2);
       const { fetchRequest } = this.formSubmission;
-      this.prepareRequest(fetchRequest);
+      const frame = this.#findFrameElement(element, submitter2);
+      this.prepareRequest(fetchRequest, frame);
       this.formSubmission.start();
     }
     // Fetch request delegate
-    prepareRequest(request) {
-      request.headers["Turbo-Frame"] = this.id;
+    prepareRequest(request, frame = this) {
+      request.headers["Turbo-Frame"] = frame.id;
       if (this.currentNavigationElement?.hasAttribute("data-turbo-stream")) {
         request.acceptResponseType(StreamMessage.contentType);
       }
@@ -5598,7 +5640,8 @@
     }
     #findFrameElement(element, submitter2) {
       const id = getAttribute("data-turbo-frame", submitter2, element) || this.element.getAttribute("target");
-      return getFrameElementById(id) ?? this.element;
+      const target = this.#getFrameElementById(id);
+      return target instanceof FrameElement ? target : this.element;
     }
     async extractForeignFrameElement(container) {
       let element;
@@ -5632,9 +5675,11 @@
         return false;
       }
       if (id) {
-        const frameElement = getFrameElementById(id);
+        const frameElement = this.#getFrameElementById(id);
         if (frameElement) {
           return !frameElement.disabled;
+        } else if (id == "_parent") {
+          return false;
         }
       }
       if (!session.elementIsNavigatable(element)) {
@@ -5649,8 +5694,11 @@
     get id() {
       return this.element.id;
     }
+    get disabled() {
+      return this.element.disabled;
+    }
     get enabled() {
-      return !this.element.disabled;
+      return !this.disabled;
     }
     get sourceURL() {
       if (this.element.src) {
@@ -5699,15 +5747,15 @@
       callback();
       delete this.currentNavigationElement;
     }
-  };
-  function getFrameElementById(id) {
-    if (id != null) {
-      const element = document.getElementById(id);
-      if (element instanceof FrameElement) {
-        return element;
+    #getFrameElementById(id) {
+      if (id != null) {
+        const element = id === "_parent" ? this.element.parentElement.closest("turbo-frame") : document.getElementById(id);
+        if (element instanceof FrameElement) {
+          return element;
+        }
       }
     }
-  }
+  };
   function activateElement(element, currentURL) {
     if (element) {
       const src = element.getAttribute("src");
@@ -5726,6 +5774,7 @@
   }
   var StreamActions = {
     after() {
+      this.removeDuplicateTargetSiblings();
       this.targetElements.forEach((e) => e.parentElement?.insertBefore(this.templateContent, e.nextSibling));
     },
     append() {
@@ -5733,6 +5782,7 @@
       this.targetElements.forEach((e) => e.append(this.templateContent));
     },
     before() {
+      this.removeDuplicateTargetSiblings();
       this.targetElements.forEach((e) => e.parentElement?.insertBefore(this.templateContent, e));
     },
     prepend() {
@@ -5764,7 +5814,10 @@
       });
     },
     refresh() {
-      session.refresh(this.baseURI, this.requestId);
+      const method = this.getAttribute("method");
+      const requestId = this.requestId;
+      const scroll = this.getAttribute("scroll");
+      session.refresh(this.baseURI, { method, requestId, scroll });
     }
   };
   var StreamElement = class _StreamElement extends HTMLElement {
@@ -5809,6 +5862,20 @@
       const newChildrenIds = [...this.templateContent?.children || []].filter((c) => !!c.getAttribute("id")).map((c) => c.getAttribute("id"));
       return existingChildren.filter((c) => newChildrenIds.includes(c.getAttribute("id")));
     }
+    /**
+    * Removes duplicate siblings (by ID)
+    */
+    removeDuplicateTargetSiblings() {
+      this.duplicateSiblings.forEach((c) => c.remove());
+    }
+    /**
+    * Gets the list of duplicate siblings (i.e. those with the same ID)
+    */
+    get duplicateSiblings() {
+      const existingChildren = this.targetElements.flatMap((e) => [...e.parentElement.children]).filter((c) => !!c.id);
+      const newChildrenIds = [...this.templateContent?.children || []].filter((c) => !!c.id).map((c) => c.id);
+      return existingChildren.filter((c) => newChildrenIds.includes(c.id));
+    }
     /**
      * Gets the action function to be performed.
      */
@@ -5935,10 +6002,10 @@
     customElements.define("turbo-stream-source", StreamSourceElement);
   }
   (() => {
-    let element = document.currentScript;
-    if (!element) return;
-    if (element.hasAttribute("data-turbo-suppress-warning")) return;
-    element = element.parentElement;
+    const scriptElement = document.currentScript;
+    if (!scriptElement) return;
+    if (scriptElement.hasAttribute("data-turbo-suppress-warning")) return;
+    let element = scriptElement.parentElement;
     while (element) {
       if (element == document.body) {
         return console.warn(
@@ -5952,7 +6019,7 @@
         ——
         Suppress this warning by adding a "data-turbo-suppress-warning" attribute to: %s
       `,
-          element.outerHTML
+          scriptElement.outerHTML
         );
       }
       element = element.parentElement;
@@ -8578,7 +8645,7 @@
   };
   var useClickOutside = (composableController, options = {}) => {
     const controller = composableController;
-    const { onlyVisible, dispatchEvent: dispatchEvent2, events, eventPrefix } = Object.assign({}, defaultOptions$5, options);
+    const { onlyVisible, dispatchEvent, events, eventPrefix } = Object.assign({}, defaultOptions$5, options);
     const onEvent = (event) => {
       const targetElement = (options === null || options === void 0 ? void 0 : options.element) || controller.element;
       if (targetElement.contains(event.target) || !isElementInViewport(targetElement) && onlyVisible) {
@@ -8587,7 +8654,7 @@
       if (controller.clickOutside) {
         controller.clickOutside(event);
       }
-      if (dispatchEvent2) {
+      if (dispatchEvent) {
         const eventName = composeEventName("click:outside", controller, eventPrefix);
         const clickOutsideEvent = extendedEvent(eventName, event, {
           controller
@@ -9521,7 +9588,7 @@
 
 @hotwired/turbo/dist/turbo.es2017-esm.js:
   (*!
-  Turbo 8.0.13
-  Copyright © 2025 37signals LLC
+  Turbo 8.0.23
+  Copyright © 2026 37signals LLC
    *)
 */