@hotwired/turbo 7.1.0-rc.2 → 7.2.0-beta.1

package/dist/turbo.es2017-umd.js

@@ -1,26 +1,26 @@
 /*
-Turbo 7.1.0-rc.1
-Copyright © 2021 Basecamp, LLC
+Turbo 7.2.0-beta.1
+Copyright © 2022 Basecamp, LLC
  */
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
     typeof define === 'function' && define.amd ? define(['exports'], factory) :
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Turbo = {}));
-}(this, (function (exports) { 'use strict';
+})(this, (function (exports) { 'use strict';
 
     (function () {
-        if (window.Reflect === undefined || window.customElements === undefined ||
+        if (window.Reflect === undefined ||
+            window.customElements === undefined ||
             window.customElements.polyfillWrapFlushCallback) {
             return;
         }
         const BuiltInHTMLElement = HTMLElement;
         const wrapperForTheName = {
-            'HTMLElement': function HTMLElement() {
+            HTMLElement: function HTMLElement() {
                 return Reflect.construct(BuiltInHTMLElement, [], this.constructor);
-            }
+            },
         };
-        window.HTMLElement =
-            wrapperForTheName['HTMLElement'];
+        window.HTMLElement = wrapperForTheName["HTMLElement"];
         HTMLElement.prototype = BuiltInHTMLElement.prototype;
         HTMLElement.prototype.constructor = HTMLElement;
         Object.setPrototypeOf(HTMLElement, BuiltInHTMLElement);
@@ -78,7 +78,7 @@ Copyright © 2021 Basecamp, LLC
       }
     })(HTMLFormElement.prototype);
 
-    const submittersByForm = new WeakMap;
+    const submittersByForm = 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;
@@ -109,7 +109,7 @@ Copyright © 2021 Basecamp, LLC
                 if (this.type == "submit" && this.target instanceof HTMLFormElement) {
                     return submittersByForm.get(this.target);
                 }
-            }
+            },
         });
     })();
 
@@ -125,7 +125,7 @@ Copyright © 2021 Basecamp, LLC
             this.delegate = new FrameElement.delegateConstructor(this);
         }
         static get observedAttributes() {
-            return ["disabled", "loading", "src"];
+            return ["disabled", "complete", "loading", "src"];
         }
         connectedCallback() {
             this.delegate.connect();
@@ -135,6 +135,7 @@ Copyright © 2021 Basecamp, LLC
         }
         reload() {
             const { src } = this;
+            this.removeAttribute("complete");
             this.src = null;
             this.src = src;
         }
@@ -142,6 +143,9 @@ Copyright © 2021 Basecamp, LLC
             if (name == "loading") {
                 this.delegate.loadingStyleChanged();
             }
+            else if (name == "complete") {
+                this.delegate.completeChanged();
+            }
             else if (name == "src") {
                 this.delegate.sourceURLChanged();
             }
@@ -206,8 +210,10 @@ Copyright © 2021 Basecamp, LLC
     }
     function frameLoadingStyleFromString(style) {
         switch (style.toLowerCase()) {
-            case "lazy": return FrameLoadingStyle.lazy;
-            default: return FrameLoadingStyle.eager;
+            case "lazy":
+                return FrameLoadingStyle.lazy;
+            default:
+                return FrameLoadingStyle.eager;
         }
     }
 
@@ -219,7 +225,7 @@ Copyright © 2021 Basecamp, LLC
         if (url.hash) {
             return url.hash.slice(1);
         }
-        else if (anchorMatch = url.href.match(/#(.*)$/)) {
+        else if ((anchorMatch = url.href.match(/#(.*)$/))) {
             return anchorMatch[1];
         }
     }
@@ -231,7 +237,7 @@ Copyright © 2021 Basecamp, LLC
         return (getLastPathComponent(url).match(/\.[^.]*$/) || [])[0] || "";
     }
     function isHTML(url) {
-        return !!getExtension(url).match(/^(?:|\.(?:htm|html|xhtml))$/);
+        return !!getExtension(url).match(/^(?:|\.(?:htm|html|xhtml|php))$/);
     }
     function isPrefixedBy(baseURL, url) {
         const prefix = getPrefix(url);
@@ -242,9 +248,7 @@ Copyright © 2021 Basecamp, LLC
     }
     function getRequestURL(url) {
         const anchor = getAnchor(url);
-        return anchor != null
-            ? url.href.slice(0, -(anchor.length + 1))
-            : url.href;
+        return anchor != null ? url.href.slice(0, -(anchor.length + 1)) : url.href;
     }
     function toCacheKey(url) {
         return getRequestURL(url);
@@ -313,7 +317,11 @@ Copyright © 2021 Basecamp, LLC
     }
 
     function dispatch(eventName, { target, cancelable, detail } = {}) {
-        const event = new CustomEvent(eventName, { cancelable, bubbles: true, detail });
+        const event = new CustomEvent(eventName, {
+            cancelable,
+            bubbles: true,
+            detail,
+        });
         if (target && target.isConnected) {
             target.dispatchEvent(event);
         }
@@ -323,10 +331,10 @@ Copyright © 2021 Basecamp, LLC
         return event;
     }
     function nextAnimationFrame() {
-        return new Promise(resolve => requestAnimationFrame(() => resolve()));
+        return new Promise((resolve) => requestAnimationFrame(() => resolve()));
     }
     function nextEventLoopTick() {
-        return new Promise(resolve => setTimeout(() => resolve(), 0));
+        return new Promise((resolve) => setTimeout(() => resolve(), 0));
     }
     function nextMicrotask() {
         return Promise.resolve();
@@ -338,7 +346,7 @@ Copyright © 2021 Basecamp, LLC
         const lines = interpolate(strings, values).replace(/^\n/, "").split("\n");
         const match = lines[0].match(/^\s+/);
         const indent = match ? match[0].length : 0;
-        return lines.map(line => line.slice(indent)).join("\n");
+        return lines.map((line) => line.slice(indent)).join("\n");
     }
     function interpolate(strings, values) {
         return strings.reduce((result, string, i) => {
@@ -347,7 +355,8 @@ Copyright © 2021 Basecamp, LLC
         }, "");
     }
     function uuid() {
-        return Array.apply(null, { length: 36 }).map((_, i) => {
+        return Array.from({ length: 36 })
+            .map((_, i) => {
             if (i == 8 || i == 13 || i == 18 || i == 23) {
                 return "-";
             }
@@ -360,10 +369,11 @@ Copyright © 2021 Basecamp, LLC
             else {
                 return Math.floor(Math.random() * 15).toString(16);
             }
-        }).join("");
+        })
+            .join("");
     }
     function getAttribute(attributeName, ...elements) {
-        for (const value of elements.map(element => element === null || element === void 0 ? void 0 : element.getAttribute(attributeName))) {
+        for (const value of elements.map((element) => element === null || element === void 0 ? void 0 : element.getAttribute(attributeName))) {
             if (typeof value == "string")
                 return value;
         }
@@ -385,6 +395,23 @@ Copyright © 2021 Basecamp, LLC
             element.removeAttribute("aria-busy");
         }
     }
+    function getMetaElement(name) {
+        return document.querySelector(`meta[name="${name}"]`);
+    }
+    function getMetaContent(name) {
+        const element = getMetaElement(name);
+        return element && element.content;
+    }
+    function setMetaContent(name, content) {
+        let element = getMetaElement(name);
+        if (!element) {
+            element = document.createElement("meta");
+            element.setAttribute("name", name);
+            document.head.appendChild(element);
+        }
+        element.setAttribute("content", content);
+        return element;
+    }
 
     var FetchMethod;
     (function (FetchMethod) {
@@ -396,27 +423,27 @@ Copyright © 2021 Basecamp, LLC
     })(FetchMethod || (FetchMethod = {}));
     function fetchMethodFromString(method) {
         switch (method.toLowerCase()) {
-            case "get": return FetchMethod.get;
-            case "post": return FetchMethod.post;
-            case "put": return FetchMethod.put;
-            case "patch": return FetchMethod.patch;
-            case "delete": return FetchMethod.delete;
+            case "get":
+                return FetchMethod.get;
+            case "post":
+                return FetchMethod.post;
+            case "put":
+                return FetchMethod.put;
+            case "patch":
+                return FetchMethod.patch;
+            case "delete":
+                return FetchMethod.delete;
         }
     }
     class FetchRequest {
-        constructor(delegate, method, location, body = new URLSearchParams, target = null) {
-            this.abortController = new AbortController;
-            this.resolveRequestPromise = (value) => { };
+        constructor(delegate, method, location, body = new URLSearchParams(), target = null) {
+            this.abortController = new AbortController();
+            this.resolveRequestPromise = (_value) => { };
             this.delegate = delegate;
             this.method = method;
             this.headers = this.defaultHeaders;
-            if (this.isIdempotent) {
-                this.url = mergeFormDataEntries(location, [...body.entries()]);
-            }
-            else {
-                this.body = body;
-                this.url = location;
-            }
+            this.body = body;
+            this.url = location;
             this.target = target;
         }
         get location() {
@@ -442,7 +469,7 @@ Copyright © 2021 Basecamp, LLC
                 return await this.receive(response);
             }
             catch (error) {
-                if (error.name !== 'AbortError') {
+                if (error.name !== "AbortError") {
                     this.delegate.requestErrored(this, error);
                     throw error;
                 }
@@ -453,7 +480,11 @@ Copyright © 2021 Basecamp, LLC
         }
         async receive(response) {
             const fetchResponse = new FetchResponse(response);
-            const event = dispatch("turbo:before-fetch-response", { cancelable: true, detail: { fetchResponse }, target: this.target });
+            const event = dispatch("turbo:before-fetch-response", {
+                cancelable: true,
+                detail: { fetchResponse },
+                target: this.target,
+            });
             if (event.defaultPrevented) {
                 this.delegate.requestPreventedHandlingResponse(this, fetchResponse);
             }
@@ -472,14 +503,14 @@ Copyright © 2021 Basecamp, LLC
                 credentials: "same-origin",
                 headers: this.headers,
                 redirect: "follow",
-                body: this.body,
+                body: this.isIdempotent ? null : this.body,
                 signal: this.abortSignal,
-                referrer: (_a = this.delegate.referrer) === null || _a === void 0 ? void 0 : _a.href
+                referrer: (_a = this.delegate.referrer) === null || _a === void 0 ? void 0 : _a.href,
             };
         }
         get defaultHeaders() {
             return {
-                "Accept": "text/html, application/xhtml+xml"
+                Accept: "text/html, application/xhtml+xml",
             };
         }
         get isIdempotent() {
@@ -489,40 +520,25 @@ Copyright © 2021 Basecamp, LLC
             return this.abortController.signal;
         }
         async allowRequestToBeIntercepted(fetchOptions) {
-            const requestInterception = new Promise(resolve => this.resolveRequestPromise = resolve);
+            const requestInterception = new Promise((resolve) => (this.resolveRequestPromise = resolve));
             const event = dispatch("turbo:before-fetch-request", {
                 cancelable: true,
                 detail: {
                     fetchOptions,
-                    url: this.url.href,
-                    resume: this.resolveRequestPromise
+                    url: this.url,
+                    resume: this.resolveRequestPromise,
                 },
-                target: this.target
+                target: this.target,
             });
             if (event.defaultPrevented)
                 await requestInterception;
         }
     }
-    function mergeFormDataEntries(url, entries) {
-        const currentSearchParams = new URLSearchParams(url.search);
-        for (const [name, value] of entries) {
-            if (value instanceof File)
-                continue;
-            if (currentSearchParams.has(name)) {
-                currentSearchParams.delete(name);
-                url.searchParams.set(name, value);
-            }
-            else {
-                url.searchParams.append(name, value);
-            }
-        }
-        return url;
-    }
 
     class AppearanceObserver {
         constructor(delegate, element) {
             this.started = false;
-            this.intersect = entries => {
+            this.intersect = (entries) => {
                 const lastEntry = entries.slice(-1)[0];
                 if (lastEntry === null || lastEntry === void 0 ? void 0 : lastEntry.isIntersecting) {
                     this.delegate.elementAppearedInViewport(this.element);
@@ -599,9 +615,12 @@ Copyright © 2021 Basecamp, LLC
     })(FormEnctype || (FormEnctype = {}));
     function formEnctypeFromString(encoding) {
         switch (encoding.toLowerCase()) {
-            case FormEnctype.multipart: return FormEnctype.multipart;
-            case FormEnctype.plain: return FormEnctype.plain;
-            default: return FormEnctype.urlEncoded;
+            case FormEnctype.multipart:
+                return FormEnctype.multipart;
+            case FormEnctype.plain:
+                return FormEnctype.plain;
+            default:
+                return FormEnctype.urlEncoded;
         }
     }
     class FormSubmission {
@@ -611,11 +630,15 @@ Copyright © 2021 Basecamp, LLC
             this.formElement = formElement;
             this.submitter = submitter;
             this.formData = buildFormData(formElement, submitter);
+            this.location = expandURL(this.action);
+            if (this.method == FetchMethod.get) {
+                mergeFormDataEntries(this.location, [...this.body.entries()]);
+            }
             this.fetchRequest = new FetchRequest(this, this.method, this.location, this.body, this.formElement);
             this.mustRedirect = mustRedirect;
         }
-        static confirmMethod(message, element) {
-            return confirm(message);
+        static confirmMethod(message, _element) {
+            return Promise.resolve(confirm(message));
         }
         get method() {
             var _a;
@@ -624,11 +647,13 @@ Copyright © 2021 Basecamp, LLC
         }
         get action() {
             var _a;
-            const formElementAction = typeof this.formElement.action === 'string' ? this.formElement.action : null;
-            return ((_a = this.submitter) === null || _a === void 0 ? void 0 : _a.getAttribute("formaction")) || this.formElement.getAttribute("action") || formElementAction || "";
-        }
-        get location() {
-            return expandURL(this.action);
+            const formElementAction = typeof this.formElement.action === "string" ? this.formElement.action : null;
+            if ((_a = this.submitter) === null || _a === void 0 ? void 0 : _a.hasAttribute("formaction")) {
+                return this.submitter.getAttribute("formaction") || "";
+            }
+            else {
+                return this.formElement.getAttribute("action") || formElementAction || "";
+            }
         }
         get body() {
             if (this.enctype == FormEnctype.urlEncoded || this.method == FetchMethod.get) {
@@ -651,7 +676,8 @@ Copyright © 2021 Basecamp, LLC
             }, []);
         }
         get confirmationMessage() {
-            return this.formElement.getAttribute("data-turbo-confirm");
+            var _a;
+            return ((_a = this.submitter) === null || _a === void 0 ? void 0 : _a.getAttribute("data-turbo-confirm")) || this.formElement.getAttribute("data-turbo-confirm");
         }
         get needsConfirmation() {
             return this.confirmationMessage !== null;
@@ -659,7 +685,7 @@ Copyright © 2021 Basecamp, LLC
         async start() {
             const { initialized, requesting } = FormSubmissionState;
             if (this.needsConfirmation) {
-                const answer = FormSubmission.confirmMethod(this.confirmationMessage, this.formElement);
+                const answer = await FormSubmission.confirmMethod(this.confirmationMessage, this.formElement);
                 if (!answer) {
                     return;
                 }
@@ -683,14 +709,19 @@ Copyright © 2021 Basecamp, LLC
                 if (token) {
                     headers["X-CSRF-Token"] = token;
                 }
+            }
+            if (this.requestAcceptsTurboStreamResponse(request)) {
                 headers["Accept"] = [StreamMessage.contentType, headers["Accept"]].join(", ");
             }
         }
-        requestStarted(request) {
+        requestStarted(_request) {
             var _a;
             this.state = FormSubmissionState.waiting;
             (_a = this.submitter) === null || _a === void 0 ? void 0 : _a.setAttribute("disabled", "");
-            dispatch("turbo:submit-start", { target: this.formElement, detail: { formSubmission: this } });
+            dispatch("turbo:submit-start", {
+                target: this.formElement,
+                detail: { formSubmission: this },
+            });
             this.delegate.formSubmissionStarted(this);
         }
         requestPreventedHandlingResponse(request, response) {
@@ -718,16 +749,22 @@ Copyright © 2021 Basecamp, LLC
             this.result = { success: false, error };
             this.delegate.formSubmissionErrored(this, error);
         }
-        requestFinished(request) {
+        requestFinished(_request) {
             var _a;
             this.state = FormSubmissionState.stopped;
             (_a = this.submitter) === null || _a === void 0 ? void 0 : _a.removeAttribute("disabled");
-            dispatch("turbo:submit-end", { target: this.formElement, detail: Object.assign({ formSubmission: this }, this.result) });
+            dispatch("turbo:submit-end", {
+                target: this.formElement,
+                detail: Object.assign({ formSubmission: this }, this.result),
+            });
             this.delegate.formSubmissionFinished(this);
         }
         requestMustRedirect(request) {
             return !request.isIdempotent && this.mustRedirect;
         }
+        requestAcceptsTurboStreamResponse(request) {
+            return !request.isIdempotent || this.formElement.hasAttribute("data-turbo-stream");
+        }
     }
     function buildFormData(formElement, submitter) {
         const formData = new FormData(formElement);
@@ -748,18 +785,27 @@ Copyright © 2021 Basecamp, LLC
             }
         }
     }
-    function getMetaContent(name) {
-        const element = document.querySelector(`meta[name="${name}"]`);
-        return element && element.content;
-    }
     function responseSucceededWithoutRedirect(response) {
         return response.statusCode == 200 && !response.redirected;
     }
+    function mergeFormDataEntries(url, entries) {
+        const searchParams = new URLSearchParams();
+        for (const [name, value] of entries) {
+            if (value instanceof File)
+                continue;
+            searchParams.append(name, value);
+        }
+        url.search = searchParams.toString();
+        return url;
+    }
 
     class Snapshot {
         constructor(element) {
             this.element = element;
         }
+        get activeElement() {
+            return this.element.ownerDocument.activeElement;
+        }
         get children() {
             return [...this.element.children];
         }
@@ -798,7 +844,9 @@ Copyright © 2021 Basecamp, LLC
         constructor(delegate, element) {
             this.submitBubbled = ((event) => {
                 const form = event.target;
-                if (form instanceof HTMLFormElement && form.closest("turbo-frame, html") == this.element) {
+                if (!event.defaultPrevented &&
+                    form instanceof HTMLFormElement &&
+                    form.closest("turbo-frame, html") == this.element) {
                     const submitter = event.submitter || undefined;
                     const method = (submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("formmethod")) || form.method;
                     if (method != "dialog" && this.delegate.shouldInterceptFormSubmission(form, submitter)) {
@@ -821,8 +869,8 @@ Copyright © 2021 Basecamp, LLC
 
     class View {
         constructor(delegate, element) {
-            this.resolveRenderPromise = (value) => { };
-            this.resolveInterceptionPromise = (value) => { };
+            this.resolveRenderPromise = (_value) => { };
+            this.resolveInterceptionPromise = (_value) => { };
             this.delegate = delegate;
             this.element = element;
         }
@@ -867,15 +915,17 @@ Copyright © 2021 Basecamp, LLC
             const { isPreview, shouldRender, newSnapshot: snapshot } = renderer;
             if (shouldRender) {
                 try {
-                    this.renderPromise = new Promise(resolve => this.resolveRenderPromise = resolve);
+                    this.renderPromise = new Promise((resolve) => (this.resolveRenderPromise = resolve));
                     this.renderer = renderer;
                     this.prepareToRenderSnapshot(renderer);
-                    const renderInterception = new Promise(resolve => this.resolveInterceptionPromise = resolve);
-                    const immediateRender = this.delegate.allowsImmediateRender(snapshot, this.resolveInterceptionPromise);
+                    const renderInterception = new Promise((resolve) => (this.resolveInterceptionPromise = resolve));
+                    const options = { resume: this.resolveInterceptionPromise, render: this.renderer.renderElement };
+                    const immediateRender = this.delegate.allowsImmediateRender(snapshot, options);
                     if (!immediateRender)
                         await renderInterception;
                     await this.renderSnapshot(renderer);
                     this.delegate.viewRenderedSnapshot(snapshot, isPreview);
+                    this.delegate.preloadOnLoadLinksForView(this.element);
                     this.finishRenderingSnapshot(renderer);
                 }
                 finally {
@@ -885,11 +935,11 @@ Copyright © 2021 Basecamp, LLC
                 }
             }
             else {
-                this.invalidate();
+                this.invalidate(renderer.reloadReason);
             }
         }
-        invalidate() {
-            this.delegate.viewInvalidated();
+        invalidate(reason) {
+            this.delegate.viewInvalidated(reason);
         }
         prepareToRenderSnapshot(renderer) {
             this.markAsPreview(renderer.isPreview);
@@ -940,9 +990,9 @@ Copyright © 2021 Basecamp, LLC
                 }
                 delete this.clickEvent;
             });
-            this.willVisit = () => {
+            this.willVisit = ((_event) => {
                 delete this.clickEvent;
-            };
+            });
             this.delegate = delegate;
             this.element = element;
         }
@@ -957,28 +1007,65 @@ Copyright © 2021 Basecamp, LLC
             document.removeEventListener("turbo:before-visit", this.willVisit);
         }
         respondsToEventTarget(target) {
-            const element = target instanceof Element
-                ? target
-                : target instanceof Node
-                    ? target.parentElement
-                    : null;
+            const element = target instanceof Element ? target : target instanceof Node ? target.parentElement : null;
             return element && element.closest("turbo-frame, html") == this.element;
         }
     }
 
+    class FormLinkInterceptor {
+        constructor(delegate, element) {
+            this.delegate = delegate;
+            this.linkInterceptor = new LinkInterceptor(this, element);
+        }
+        start() {
+            this.linkInterceptor.start();
+        }
+        stop() {
+            this.linkInterceptor.stop();
+        }
+        shouldInterceptLinkClick(link) {
+            return (this.delegate.shouldInterceptFormLinkClick(link) &&
+                (link.hasAttribute("data-turbo-method") || link.hasAttribute("data-turbo-stream")));
+        }
+        linkClickIntercepted(link, action) {
+            const form = document.createElement("form");
+            form.setAttribute("data-turbo", "true");
+            form.setAttribute("action", action);
+            form.setAttribute("hidden", "");
+            const method = link.getAttribute("data-turbo-method");
+            if (method)
+                form.setAttribute("method", method);
+            const turboFrame = link.getAttribute("data-turbo-frame");
+            if (turboFrame)
+                form.setAttribute("data-turbo-frame", turboFrame);
+            const turboConfirm = link.getAttribute("data-turbo-confirm");
+            if (turboConfirm)
+                form.setAttribute("data-turbo-confirm", turboConfirm);
+            const turboStream = link.hasAttribute("data-turbo-stream");
+            if (turboStream)
+                form.setAttribute("data-turbo-stream", "");
+            this.delegate.formLinkClickIntercepted(link, form);
+            document.body.appendChild(form);
+            form.requestSubmit();
+            form.remove();
+        }
+    }
+
     class Bardo {
-        constructor(permanentElementMap) {
+        constructor(delegate, permanentElementMap) {
+            this.delegate = delegate;
             this.permanentElementMap = permanentElementMap;
         }
-        static preservingPermanentElements(permanentElementMap, callback) {
-            const bardo = new this(permanentElementMap);
+        static preservingPermanentElements(delegate, permanentElementMap, callback) {
+            const bardo = new this(delegate, permanentElementMap);
             bardo.enter();
             callback();
             bardo.leave();
         }
         enter() {
             for (const id in this.permanentElementMap) {
-                const [, newPermanentElement] = this.permanentElementMap[id];
+                const [currentPermanentElement, newPermanentElement] = this.permanentElementMap[id];
+                this.delegate.enteringBardo(currentPermanentElement, newPermanentElement);
                 this.replaceNewPermanentElementWithPlaceholder(newPermanentElement);
             }
         }
@@ -987,6 +1074,7 @@ Copyright © 2021 Basecamp, LLC
                 const [currentPermanentElement] = this.permanentElementMap[id];
                 this.replaceCurrentPermanentElementWithClone(currentPermanentElement);
                 this.replacePlaceholderWithPermanentElement(currentPermanentElement);
+                this.delegate.leavingBardo(currentPermanentElement);
             }
         }
         replaceNewPermanentElementWithPlaceholder(permanentElement) {
@@ -1002,7 +1090,7 @@ Copyright © 2021 Basecamp, LLC
             placeholder === null || placeholder === void 0 ? void 0 : placeholder.replaceWith(permanentElement);
         }
         getPlaceholderById(id) {
-            return this.placeholders.find(element => element.content == id);
+            return this.placeholders.find((element) => element.content == id);
         }
         get placeholders() {
             return [...document.querySelectorAll("meta[name=turbo-permanent-placeholder][content]")];
@@ -1016,16 +1104,21 @@ Copyright © 2021 Basecamp, LLC
     }
 
     class Renderer {
-        constructor(currentSnapshot, newSnapshot, isPreview, willRender = true) {
+        constructor(currentSnapshot, newSnapshot, renderElement, isPreview, willRender = true) {
+            this.activeElement = null;
             this.currentSnapshot = currentSnapshot;
             this.newSnapshot = newSnapshot;
             this.isPreview = isPreview;
             this.willRender = willRender;
-            this.promise = new Promise((resolve, reject) => this.resolvingFunctions = { resolve, reject });
+            this.renderElement = renderElement;
+            this.promise = new Promise((resolve, reject) => (this.resolvingFunctions = { resolve, reject }));
         }
         get shouldRender() {
             return true;
         }
+        get reloadReason() {
+            return;
+        }
         prepareToRender() {
             return;
         }
@@ -1051,7 +1144,7 @@ Copyright © 2021 Basecamp, LLC
             }
         }
         preservingPermanentElements(callback) {
-            Bardo.preservingPermanentElements(this.permanentElementMap, callback);
+            Bardo.preservingPermanentElements(this, this.permanentElementMap, callback);
         }
         focusFirstAutofocusableElement() {
             const element = this.connectedSnapshot.firstAutofocusableElement;
@@ -1059,6 +1152,19 @@ Copyright © 2021 Basecamp, LLC
                 element.focus();
             }
         }
+        enteringBardo(currentPermanentElement) {
+            if (this.activeElement)
+                return;
+            if (currentPermanentElement.contains(this.currentSnapshot.activeElement)) {
+                this.activeElement = this.currentSnapshot.activeElement;
+            }
+        }
+        leavingBardo(currentPermanentElement) {
+            if (currentPermanentElement.contains(this.activeElement) && this.activeElement instanceof HTMLElement) {
+                this.activeElement.focus();
+                this.activeElement = null;
+            }
+        }
         get connectedSnapshot() {
             return this.newSnapshot.isConnected ? this.newSnapshot : this.currentSnapshot;
         }
@@ -1072,8 +1178,7 @@ Copyright © 2021 Basecamp, LLC
             return this.currentSnapshot.getPermanentElementMapForSnapshot(this.newSnapshot);
         }
         get cspNonce() {
-            var _a;
-            return (_a = document.head.querySelector('meta[name="csp-nonce"]')) === null || _a === void 0 ? void 0 : _a.getAttribute("content");
+            return getMetaContent("csp-nonce");
         }
     }
     function copyElementAttributes(destinationElement, sourceElement) {
@@ -1086,6 +1191,22 @@ Copyright © 2021 Basecamp, LLC
     }
 
     class FrameRenderer extends Renderer {
+        constructor(delegate, currentSnapshot, newSnapshot, renderElement, isPreview, willRender = true) {
+            super(currentSnapshot, newSnapshot, renderElement, isPreview, willRender);
+            this.delegate = delegate;
+        }
+        static renderElement(currentElement, newElement) {
+            var _a;
+            const destinationRange = document.createRange();
+            destinationRange.selectNodeContents(currentElement);
+            destinationRange.deleteContents();
+            const frameElement = newElement;
+            const sourceRange = (_a = frameElement.ownerDocument) === null || _a === void 0 ? void 0 : _a.createRange();
+            if (sourceRange) {
+                sourceRange.selectNodeContents(frameElement);
+                currentElement.appendChild(sourceRange.extractContents());
+            }
+        }
         get shouldRender() {
             return true;
         }
@@ -1101,23 +1222,16 @@ Copyright © 2021 Basecamp, LLC
             this.activateScriptElements();
         }
         loadFrameElement() {
-            var _a;
-            const destinationRange = document.createRange();
-            destinationRange.selectNodeContents(this.currentElement);
-            destinationRange.deleteContents();
-            const frameElement = this.newElement;
-            const sourceRange = (_a = frameElement.ownerDocument) === null || _a === void 0 ? void 0 : _a.createRange();
-            if (sourceRange) {
-                sourceRange.selectNodeContents(frameElement);
-                this.currentElement.appendChild(sourceRange.extractContents());
-            }
+            this.delegate.frameExtracted(this.newElement.cloneNode(true));
+            this.renderElement(this.currentElement, this.newElement);
         }
         scrollFrameIntoView() {
             if (this.currentElement.autoscroll || this.newElement.autoscroll) {
                 const element = this.currentElement.firstElementChild;
                 const block = readScrollLogicalPosition(this.currentElement.getAttribute("data-autoscroll-block"), "end");
+                const behavior = readScrollBehavior(this.currentElement.getAttribute("data-autoscroll-behavior"), "auto");
                 if (element) {
-                    element.scrollIntoView({ block });
+                    element.scrollIntoView({ block, behavior });
                     return true;
                 }
             }
@@ -1141,6 +1255,14 @@ Copyright © 2021 Basecamp, LLC
             return defaultValue;
         }
     }
+    function readScrollBehavior(value, defaultValue) {
+        if (value == "auto" || value == "smooth") {
+            return value;
+        }
+        else {
+            return defaultValue;
+        }
+    }
 
     class ProgressBar {
         constructor() {
@@ -1164,7 +1286,7 @@ Copyright © 2021 Basecamp, LLC
         left: 0;
         height: 3px;
         background: #0076ff;
-        z-index: 9999;
+        z-index: 2147483647;
         transition:
           width ${ProgressBar.animationDuration}ms ease-out,
           opacity ${ProgressBar.animationDuration / 2}ms ${ProgressBar.animationDuration / 2}ms ease-in;
@@ -1223,13 +1345,16 @@ Copyright © 2021 Basecamp, LLC
         }
         refresh() {
             requestAnimationFrame(() => {
-                this.progressElement.style.width = `${10 + (this.value * 90)}%`;
+                this.progressElement.style.width = `${10 + this.value * 90}%`;
             });
         }
         createStylesheetElement() {
             const element = document.createElement("style");
             element.type = "text/css";
             element.textContent = ProgressBar.defaultCSS;
+            if (this.cspNonce) {
+                element.nonce = this.cspNonce;
+            }
             return element;
         }
         createProgressElement() {
@@ -1237,6 +1362,9 @@ Copyright © 2021 Basecamp, LLC
             element.className = "turbo-progress-bar";
             return element;
         }
+        get cspNonce() {
+            return getMetaContent("csp-nonce");
+        }
     }
     ProgressBar.animationDuration = 300;
 
@@ -1253,14 +1381,14 @@ Copyright © 2021 Basecamp, LLC
                     : {
                         type: elementType(element),
                         tracked: elementIsTracked(element),
-                        elements: []
+                        elements: [],
                     };
                 return Object.assign(Object.assign({}, result), { [outerHTML]: Object.assign(Object.assign({}, details), { elements: [...details.elements, element] }) });
             }, {});
         }
         get trackedElementSignature() {
             return Object.keys(this.detailsByOuterHTML)
-                .filter(outerHTML => this.detailsByOuterHTML[outerHTML].tracked)
+                .filter((outerHTML) => this.detailsByOuterHTML[outerHTML].tracked)
                 .join("");
         }
         getScriptElementsNotInSnapshot(snapshot) {
@@ -1271,8 +1399,8 @@ Copyright © 2021 Basecamp, LLC
         }
         getElementsMatchingTypeNotInSnapshot(matchedType, snapshot) {
             return Object.keys(this.detailsByOuterHTML)
-                .filter(outerHTML => !(outerHTML in snapshot.detailsByOuterHTML))
-                .map(outerHTML => this.detailsByOuterHTML[outerHTML])
+                .filter((outerHTML) => !(outerHTML in snapshot.detailsByOuterHTML))
+                .map((outerHTML) => this.detailsByOuterHTML[outerHTML])
                 .filter(({ type }) => type == matchedType)
                 .map(({ elements: [element] }) => element);
         }
@@ -1292,13 +1420,11 @@ Copyright © 2021 Basecamp, LLC
         }
         getMetaValue(name) {
             const element = this.findMetaElementByName(name);
-            return element
-                ? element.getAttribute("content")
-                : null;
+            return element ? element.getAttribute("content") : null;
         }
         findMetaElementByName(name) {
             return Object.keys(this.detailsByOuterHTML).reduce((result, outerHTML) => {
-                const { elements: [element] } = this.detailsByOuterHTML[outerHTML];
+                const { elements: [element], } = this.detailsByOuterHTML[outerHTML];
                 return elementIsMetaElementWithName(element, name) ? element : result;
             }, undefined);
         }
@@ -1465,9 +1591,11 @@ Copyright © 2021 Basecamp, LLC
             if (this.state == VisitState.started) {
                 this.recordTimingMetric(TimingMetric.visitEnd);
                 this.state = VisitState.completed;
-                this.adapter.visitCompleted(this);
-                this.delegate.visitCompleted(this);
                 this.followRedirect();
+                if (!this.followedRedirect) {
+                    this.adapter.visitCompleted(this);
+                    this.delegate.visitCompleted(this);
+                }
             }
         }
         fail() {
@@ -1529,12 +1657,12 @@ Copyright © 2021 Basecamp, LLC
                     if (this.view.renderPromise)
                         await this.view.renderPromise;
                     if (isSuccessful(statusCode) && responseHTML != null) {
-                        await this.view.renderPage(PageSnapshot.fromHTMLString(responseHTML), false, this.willRender);
+                        await this.view.renderPage(PageSnapshot.fromHTMLString(responseHTML), false, this.willRender, this);
                         this.adapter.visitRendered(this);
                         this.complete();
                     }
                     else {
-                        await this.view.renderError(PageSnapshot.fromHTMLString(responseHTML));
+                        await this.view.renderError(PageSnapshot.fromHTMLString(responseHTML), this);
                         this.adapter.visitRendered(this);
                         this.fail();
                     }
@@ -1569,7 +1697,7 @@ Copyright © 2021 Basecamp, LLC
                     else {
                         if (this.view.renderPromise)
                             await this.view.renderPromise;
-                        await this.view.renderPage(snapshot, isPreview, this.willRender);
+                        await this.view.renderPage(snapshot, isPreview, this.willRender, this);
                         this.adapter.visitRendered(this);
                         if (!isPreview) {
                             this.complete();
@@ -1582,8 +1710,9 @@ Copyright © 2021 Basecamp, LLC
             var _a;
             if (this.redirectedToLocation && !this.followedRedirect && ((_a = this.response) === null || _a === void 0 ? void 0 : _a.redirected)) {
                 this.adapter.visitProposedToLocation(this.redirectedToLocation, {
-                    action: 'replace',
-                    response: this.response
+                    action: "replace",
+                    willRender: false,
+                    response: this.response,
                 });
                 this.followedRedirect = true;
             }
@@ -1599,13 +1728,15 @@ Copyright © 2021 Basecamp, LLC
         requestStarted() {
             this.startRequest();
         }
-        requestPreventedHandlingResponse(request, response) {
-        }
+        requestPreventedHandlingResponse(_request, _response) { }
         async requestSucceededWithResponse(request, response) {
             const responseHTML = await response.responseHTML;
             const { redirected, statusCode } = response;
             if (responseHTML == undefined) {
-                this.recordResponse({ statusCode: SystemStatusCode.contentTypeMismatch, redirected });
+                this.recordResponse({
+                    statusCode: SystemStatusCode.contentTypeMismatch,
+                    redirected,
+                });
             }
             else {
                 this.redirectedToLocation = response.redirected ? response.location : undefined;
@@ -1616,14 +1747,20 @@ Copyright © 2021 Basecamp, LLC
             const responseHTML = await response.responseHTML;
             const { redirected, statusCode } = response;
             if (responseHTML == undefined) {
-                this.recordResponse({ statusCode: SystemStatusCode.contentTypeMismatch, redirected });
+                this.recordResponse({
+                    statusCode: SystemStatusCode.contentTypeMismatch,
+                    redirected,
+                });
             }
             else {
                 this.recordResponse({ statusCode: statusCode, responseHTML, redirected });
             }
         }
-        requestErrored(request, error) {
-            this.recordResponse({ statusCode: SystemStatusCode.networkFailure, redirected: false });
+        requestErrored(_request, _error) {
+            this.recordResponse({
+                statusCode: SystemStatusCode.networkFailure,
+                redirected: false,
+            });
         }
         requestFinished() {
             this.finishRequest();
@@ -1664,9 +1801,11 @@ Copyright © 2021 Basecamp, LLC
         }
         getHistoryMethodForAction(action) {
             switch (action) {
-                case "replace": return history.replaceState;
+                case "replace":
+                    return history.replaceState;
                 case "advance":
-                case "restore": return history.pushState;
+                case "restore":
+                    return history.pushState;
             }
         }
         hasPreloadedResponse() {
@@ -1685,18 +1824,20 @@ Copyright © 2021 Basecamp, LLC
         }
         cacheSnapshot() {
             if (!this.snapshotCached) {
-                this.view.cacheSnapshot().then(snapshot => snapshot && this.visitCachedSnapshot(snapshot));
+                this.view.cacheSnapshot().then((snapshot) => snapshot && this.visitCachedSnapshot(snapshot));
                 this.snapshotCached = true;
             }
         }
         async render(callback) {
             this.cancelRender();
-            await new Promise(resolve => {
+            await new Promise((resolve) => {
                 this.frame = requestAnimationFrame(() => resolve());
             });
             await callback();
             delete this.frame;
-            this.performScroll();
+            if (!this.view.forceReloaded) {
+                this.performScroll();
+            }
         }
         cancelRender() {
             if (this.frame) {
@@ -1711,7 +1852,7 @@ Copyright © 2021 Basecamp, LLC
 
     class BrowserAdapter {
         constructor(session) {
-            this.progressBar = new ProgressBar;
+            this.progressBar = new ProgressBar();
             this.showProgressBar = () => {
                 this.progressBar.show();
             };
@@ -1721,10 +1862,10 @@ Copyright © 2021 Basecamp, LLC
             this.navigator.startVisit(location, uuid(), options);
         }
         visitStarted(visit) {
+            this.location = visit.location;
+            visit.loadCachedSnapshot();
             visit.issueRequest();
-            visit.changeHistory();
             visit.goToSamePageAnchor();
-            visit.loadCachedSnapshot();
         }
         visitRequestStarted(visit) {
             this.progressBar.setValue(0);
@@ -1743,29 +1884,31 @@ Copyright © 2021 Basecamp, LLC
                 case SystemStatusCode.networkFailure:
                 case SystemStatusCode.timeoutFailure:
                 case SystemStatusCode.contentTypeMismatch:
-                    return this.reload();
+                    return this.reload({
+                        reason: "request_failed",
+                        context: {
+                            statusCode,
+                        },
+                    });
                 default:
                     return visit.loadResponse();
             }
         }
-        visitRequestFinished(visit) {
+        visitRequestFinished(_visit) {
             this.progressBar.setValue(1);
             this.hideVisitProgressBar();
         }
-        visitCompleted(visit) {
-        }
-        pageInvalidated() {
-            this.reload();
+        visitCompleted(_visit) { }
+        pageInvalidated(reason) {
+            this.reload(reason);
         }
-        visitFailed(visit) {
-        }
-        visitRendered(visit) {
-        }
-        formSubmissionStarted(formSubmission) {
+        visitFailed(_visit) { }
+        visitRendered(_visit) { }
+        formSubmissionStarted(_formSubmission) {
             this.progressBar.setValue(0);
             this.showFormProgressBarAfterDelay();
         }
-        formSubmissionFinished(formSubmission) {
+        formSubmissionFinished(_formSubmission) {
             this.progressBar.setValue(1);
             this.hideFormProgressBar();
         }
@@ -1791,8 +1934,11 @@ Copyright © 2021 Basecamp, LLC
                 delete this.formProgressBarTimeout;
             }
         }
-        reload() {
-            window.location.reload();
+        reload(reason) {
+            dispatch("turbo:reload", { detail: reason });
+            if (!this.location)
+                return;
+            window.location.href = this.location.toString();
         }
         get navigator() {
             return this.session.navigator;
@@ -1802,6 +1948,12 @@ Copyright © 2021 Basecamp, LLC
     class CacheObserver {
         constructor() {
             this.started = false;
+            this.removeStaleElements = ((_event) => {
+                const staleElements = [...document.querySelectorAll('[data-turbo-cache="false"]')];
+                for (const element of staleElements) {
+                    element.remove();
+                }
+            });
         }
         start() {
             if (!this.started) {
@@ -1815,12 +1967,6 @@ Copyright © 2021 Basecamp, LLC
                 removeEventListener("turbo:before-cache", this.removeStaleElements, false);
             }
         }
-        removeStaleElements() {
-            const staleElements = [...document.querySelectorAll('[data-turbo-cache="false"]')];
-            for (const element of staleElements) {
-                element.remove();
-            }
-        }
     }
 
     class FormSubmitObserver {
@@ -1834,12 +1980,12 @@ Copyright © 2021 Basecamp, LLC
                 if (!event.defaultPrevented) {
                     const form = event.target instanceof HTMLFormElement ? event.target : undefined;
                     const submitter = event.submitter || undefined;
-                    if (form) {
-                        const method = (submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("formmethod")) || form.getAttribute("method");
-                        if (method != "dialog" && this.delegate.willSubmitForm(form, submitter)) {
-                            event.preventDefault();
-                            this.delegate.formSubmitted(form, submitter);
-                        }
+                    if (form &&
+                        submissionDoesNotDismissDialog(form, submitter) &&
+                        submissionDoesNotTargetIFrame(form, submitter) &&
+                        this.delegate.willSubmitForm(form, submitter)) {
+                        event.preventDefault();
+                        this.delegate.formSubmitted(form, submitter);
                     }
                 }
             });
@@ -1858,6 +2004,18 @@ Copyright © 2021 Basecamp, LLC
             }
         }
     }
+    function submissionDoesNotDismissDialog(form, submitter) {
+        const method = (submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("formmethod")) || form.getAttribute("method");
+        return method != "dialog";
+    }
+    function submissionDoesNotTargetIFrame(form, submitter) {
+        const target = (submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("formtarget")) || form.target;
+        for (const element of document.getElementsByName(target)) {
+            if (element instanceof HTMLIFrameElement)
+                return false;
+        }
+        return true;
+    }
 
     class FrameRedirector {
         constructor(element) {
@@ -1873,7 +2031,7 @@ Copyright © 2021 Basecamp, LLC
             this.linkInterceptor.stop();
             this.formInterceptor.stop();
         }
-        shouldInterceptLinkClick(element, url) {
+        shouldInterceptLinkClick(element, _url) {
             return this.shouldRedirect(element);
         }
         linkClickIntercepted(element, url) {
@@ -1888,7 +2046,6 @@ Copyright © 2021 Basecamp, LLC
         formSubmissionIntercepted(element, submitter) {
             const frame = this.findFrameElement(element, submitter);
             if (frame) {
-                frame.removeAttribute("reloadable");
                 frame.delegate.formSubmissionIntercepted(element, submitter);
             }
         }
@@ -1931,7 +2088,7 @@ Copyright © 2021 Basecamp, LLC
                     }
                 }
             };
-            this.onPageLoad = async (event) => {
+            this.onPageLoad = async (_event) => {
                 await nextMicrotask();
                 this.pageLoaded = true;
             };
@@ -2004,9 +2161,9 @@ Copyright © 2021 Basecamp, LLC
                 if (this.clickEventIsSignificant(event)) {
                     const target = (event.composedPath && event.composedPath()[0]) || event.target;
                     const link = this.findLinkFromClickTarget(target);
-                    if (link) {
+                    if (link && doesNotTargetIFrame(link)) {
                         const location = this.getLocationForLink(link);
-                        if (this.delegate.willFollowLinkToLocation(link, location)) {
+                        if (this.delegate.willFollowLinkToLocation(link, location, event)) {
                             event.preventDefault();
                             this.delegate.followedLinkToLocation(link, location);
                         }
@@ -2028,13 +2185,13 @@ Copyright © 2021 Basecamp, LLC
             }
         }
         clickEventIsSignificant(event) {
-            return !((event.target && event.target.isContentEditable)
-                || event.defaultPrevented
-                || event.which > 1
-                || event.altKey
-                || event.ctrlKey
-                || event.metaKey
-                || event.shiftKey);
+            return !((event.target && event.target.isContentEditable) ||
+                event.defaultPrevented ||
+                event.which > 1 ||
+                event.altKey ||
+                event.ctrlKey ||
+                event.metaKey ||
+                event.shiftKey);
         }
         findLinkFromClickTarget(target) {
             if (target instanceof Element) {
@@ -2045,6 +2202,13 @@ Copyright © 2021 Basecamp, LLC
             return expandURL(link.getAttribute("href") || "");
         }
     }
+    function doesNotTargetIFrame(anchor) {
+        for (const element of document.getElementsByName(anchor.target)) {
+            if (element instanceof HTMLIFrameElement)
+                return false;
+        }
+        return true;
+    }
 
     function isAction(action) {
         return action == "advance" || action == "replace" || action == "restore";
@@ -2065,6 +2229,7 @@ Copyright © 2021 Basecamp, LLC
             }
         }
         startVisit(locatable, restorationIdentifier, options = {}) {
+            this.lastVisit = this.currentVisit;
             this.stop();
             this.currentVisit = new Visit(this, expandURL(locatable), restorationIdentifier, Object.assign({ referrer: this.location }, options));
             this.currentVisit.start();
@@ -2094,7 +2259,7 @@ Copyright © 2021 Basecamp, LLC
             return this.delegate.history;
         }
         formSubmissionStarted(formSubmission) {
-            if (typeof this.adapter.formSubmissionStarted === 'function') {
+            if (typeof this.adapter.formSubmissionStarted === "function") {
                 this.adapter.formSubmissionStarted(formSubmission);
             }
         }
@@ -2107,7 +2272,10 @@ Copyright © 2021 Basecamp, LLC
                     }
                     const { statusCode, redirected } = fetchResponse;
                     const action = this.getActionForFormSubmission(formSubmission);
-                    const visitOptions = { action, response: { statusCode, responseHTML, redirected } };
+                    const visitOptions = {
+                        action,
+                        response: { statusCode, responseHTML, redirected },
+                    };
                     this.proposeVisit(fetchResponse.location, visitOptions);
                 }
             }
@@ -2117,10 +2285,10 @@ Copyright © 2021 Basecamp, LLC
             if (responseHTML) {
                 const snapshot = PageSnapshot.fromHTMLString(responseHTML);
                 if (fetchResponse.serverError) {
-                    await this.view.renderError(snapshot);
+                    await this.view.renderError(snapshot, this.currentVisit);
                 }
                 else {
-                    await this.view.renderPage(snapshot);
+                    await this.view.renderPage(snapshot, false, true, this.currentVisit);
                 }
                 this.view.scrollToTop();
                 this.view.clearSnapshotCache();
@@ -2130,7 +2298,7 @@ Copyright © 2021 Basecamp, LLC
             console.error(error);
         }
         formSubmissionFinished(formSubmission) {
-            if (typeof this.adapter.formSubmissionFinished === 'function') {
+            if (typeof this.adapter.formSubmissionFinished === "function") {
                 this.adapter.formSubmissionFinished(formSubmission);
             }
         }
@@ -2141,12 +2309,14 @@ Copyright © 2021 Basecamp, LLC
             this.delegate.visitCompleted(visit);
         }
         locationWithActionIsSamePage(location, action) {
+            var _a;
             const anchor = getAnchor(location);
-            const currentAnchor = getAnchor(this.view.lastRenderedLocation);
-            const isRestorationToTop = action === 'restore' && typeof anchor === 'undefined';
-            return action !== "replace" &&
-                getRequestURL(location) === getRequestURL(this.view.lastRenderedLocation) &&
-                (isRestorationToTop || (anchor != null && anchor !== currentAnchor));
+            const lastLocation = ((_a = this.lastVisit) === null || _a === void 0 ? void 0 : _a.location) || this.view.lastRenderedLocation;
+            const currentAnchor = getAnchor(lastLocation);
+            const isRestorationToTop = action === "restore" && typeof anchor === "undefined";
+            return (action !== "replace" &&
+                getRequestURL(location) === getRequestURL(lastLocation) &&
+                (isRestorationToTop || (anchor != null && anchor !== currentAnchor)));
         }
         visitScrolledToSamePageLocation(oldURL, newURL) {
             this.delegate.visitScrolledToSamePageLocation(oldURL, newURL);
@@ -2252,7 +2422,7 @@ Copyright © 2021 Basecamp, LLC
 
     class StreamObserver {
         constructor(delegate) {
-            this.sources = new Set;
+            this.sources = new Set();
             this.started = false;
             this.inspectFetchResponse = ((event) => {
                 const response = fetchResponseFromEvent(event);
@@ -2319,14 +2489,18 @@ Copyright © 2021 Basecamp, LLC
     }
 
     class ErrorRenderer extends Renderer {
+        static renderElement(currentElement, newElement) {
+            const { documentElement, body } = document;
+            documentElement.replaceChild(newElement, body);
+        }
         async render() {
             this.replaceHeadAndBody();
             this.activateScriptElements();
         }
         replaceHeadAndBody() {
-            const { documentElement, head, body } = document;
+            const { documentElement, head } = document;
             documentElement.replaceChild(this.newHead, head);
-            documentElement.replaceChild(this.newElement, body);
+            this.renderElement(this.currentElement, this.newElement);
         }
         activateScriptElements() {
             for (const replaceableElement of this.scriptElements) {
@@ -2346,9 +2520,29 @@ Copyright © 2021 Basecamp, LLC
     }
 
     class PageRenderer extends Renderer {
+        static renderElement(currentElement, newElement) {
+            if (document.body && newElement instanceof HTMLBodyElement) {
+                document.body.replaceWith(newElement);
+            }
+            else {
+                document.documentElement.appendChild(newElement);
+            }
+        }
         get shouldRender() {
             return this.newSnapshot.isVisitable && this.trackedElementsAreIdentical;
         }
+        get reloadReason() {
+            if (!this.newSnapshot.isVisitable) {
+                return {
+                    reason: "turbo_visit_control_is_reload",
+                };
+            }
+            if (!this.trackedElementsAreIdentical) {
+                return {
+                    reason: "tracked_element_mismatch",
+                };
+            }
+        }
         prepareToRender() {
             this.mergeHead();
         }
@@ -2418,12 +2612,7 @@ Copyright © 2021 Basecamp, LLC
             }
         }
         assignNewBody() {
-            if (document.body && this.newElement instanceof HTMLBodyElement) {
-                document.body.replaceWith(this.newElement);
-            }
-            else {
-                document.documentElement.appendChild(this.newElement);
-            }
+            this.renderElement(this.currentElement, this.newElement);
         }
         get newHeadStylesheetElements() {
             return this.newHeadSnapshot.getStylesheetElementsNotInSnapshot(this.currentHeadSnapshot);
@@ -2492,13 +2681,21 @@ Copyright © 2021 Basecamp, LLC
             super(...arguments);
             this.snapshotCache = new SnapshotCache(10);
             this.lastRenderedLocation = new URL(location.href);
+            this.forceReloaded = false;
         }
-        renderPage(snapshot, isPreview = false, willRender = true) {
-            const renderer = new PageRenderer(this.snapshot, snapshot, isPreview, willRender);
+        renderPage(snapshot, isPreview = false, willRender = true, visit) {
+            const renderer = new PageRenderer(this.snapshot, snapshot, PageRenderer.renderElement, isPreview, willRender);
+            if (!renderer.shouldRender) {
+                this.forceReloaded = true;
+            }
+            else {
+                visit === null || visit === void 0 ? void 0 : visit.changeHistory();
+            }
             return this.render(renderer);
         }
-        renderError(snapshot) {
-            const renderer = new ErrorRenderer(this.snapshot, snapshot, false);
+        renderError(snapshot, visit) {
+            visit === null || visit === void 0 ? void 0 : visit.changeHistory();
+            const renderer = new ErrorRenderer(this.snapshot, snapshot, ErrorRenderer.renderElement, false);
             return this.render(renderer);
         }
         clearSnapshotCache() {
@@ -2525,10 +2722,50 @@ Copyright © 2021 Basecamp, LLC
         }
     }
 
+    class Preloader {
+        constructor(delegate) {
+            this.selector = "a[data-turbo-preload]";
+            this.delegate = delegate;
+        }
+        get snapshotCache() {
+            return this.delegate.navigator.view.snapshotCache;
+        }
+        start() {
+            if (document.readyState === "loading") {
+                return document.addEventListener("DOMContentLoaded", () => {
+                    this.preloadOnLoadLinksForView(document.body);
+                });
+            }
+            else {
+                this.preloadOnLoadLinksForView(document.body);
+            }
+        }
+        preloadOnLoadLinksForView(element) {
+            for (const link of element.querySelectorAll(this.selector)) {
+                this.preloadURL(link);
+            }
+        }
+        async preloadURL(link) {
+            const location = new URL(link.href);
+            if (this.snapshotCache.has(location)) {
+                return;
+            }
+            try {
+                const response = await fetch(location.toString(), { headers: { "VND.PREFETCH": "true", Accept: "text/html" } });
+                const responseText = await response.text();
+                const snapshot = PageSnapshot.fromHTMLString(responseText);
+                this.snapshotCache.put(location, snapshot);
+            }
+            catch (_) {
+            }
+        }
+    }
+
     class Session {
         constructor() {
             this.navigator = new Navigator(this);
             this.history = new History(this);
+            this.preloader = new Preloader(this);
             this.view = new PageView(this, document.documentElement);
             this.adapter = new BrowserAdapter(this);
             this.pageObserver = new PageObserver(this);
@@ -2537,22 +2774,26 @@ Copyright © 2021 Basecamp, LLC
             this.formSubmitObserver = new FormSubmitObserver(this);
             this.scrollObserver = new ScrollObserver(this);
             this.streamObserver = new StreamObserver(this);
+            this.formLinkInterceptor = new FormLinkInterceptor(this, document.documentElement);
             this.frameRedirector = new FrameRedirector(document.documentElement);
             this.drive = true;
             this.enabled = true;
             this.progressBarDelay = 500;
             this.started = false;
+            this.formMode = "on";
         }
         start() {
             if (!this.started) {
                 this.pageObserver.start();
                 this.cacheObserver.start();
+                this.formLinkInterceptor.start();
                 this.linkClickObserver.start();
                 this.formSubmitObserver.start();
                 this.scrollObserver.start();
                 this.streamObserver.start();
                 this.frameRedirector.start();
                 this.history.start();
+                this.preloader.start();
                 this.started = true;
                 this.enabled = true;
             }
@@ -2564,6 +2805,7 @@ Copyright © 2021 Basecamp, LLC
             if (this.started) {
                 this.pageObserver.stop();
                 this.cacheObserver.stop();
+                this.formLinkInterceptor.stop();
                 this.linkClickObserver.stop();
                 this.formSubmitObserver.stop();
                 this.scrollObserver.stop();
@@ -2594,6 +2836,9 @@ Copyright © 2021 Basecamp, LLC
         setProgressBarDelay(delay) {
             this.progressBarDelay = delay;
         }
+        setFormMode(mode) {
+            this.formMode = mode;
+        }
         get location() {
             return this.history.location;
         }
@@ -2602,48 +2847,32 @@ Copyright © 2021 Basecamp, LLC
         }
         historyPoppedToLocationWithRestorationIdentifier(location, restorationIdentifier) {
             if (this.enabled) {
-                this.navigator.startVisit(location, restorationIdentifier, { action: "restore", historyChanged: true });
+                this.navigator.startVisit(location, restorationIdentifier, {
+                    action: "restore",
+                    historyChanged: true,
+                });
             }
             else {
-                this.adapter.pageInvalidated();
+                this.adapter.pageInvalidated({
+                    reason: "turbo_disabled",
+                });
             }
         }
         scrollPositionChanged(position) {
             this.history.updateRestorationData({ scrollPosition: position });
         }
-        willFollowLinkToLocation(link, location) {
-            return this.elementDriveEnabled(link)
-                && locationIsVisitable(location, this.snapshot.rootLocation)
-                && this.applicationAllowsFollowingLinkToLocation(link, location);
+        shouldInterceptFormLinkClick(_link) {
+            return true;
+        }
+        formLinkClickIntercepted(_link, _form) { }
+        willFollowLinkToLocation(link, location, event) {
+            return (this.elementDriveEnabled(link) &&
+                locationIsVisitable(location, this.snapshot.rootLocation) &&
+                this.applicationAllowsFollowingLinkToLocation(link, location, event));
         }
         followedLinkToLocation(link, location) {
             const action = this.getActionForLink(link);
-            this.convertLinkWithMethodClickToFormSubmission(link) || this.visit(location.href, { action });
-        }
-        convertLinkWithMethodClickToFormSubmission(link) {
-            const linkMethod = link.getAttribute("data-turbo-method");
-            if (linkMethod) {
-                const form = document.createElement("form");
-                form.method = linkMethod;
-                form.action = link.getAttribute("href") || "undefined";
-                form.hidden = true;
-                if (link.hasAttribute("data-turbo-confirm")) {
-                    form.setAttribute("data-turbo-confirm", link.getAttribute("data-turbo-confirm"));
-                }
-                const frame = this.getTargetFrameForLink(link);
-                if (frame) {
-                    form.setAttribute("data-turbo-frame", frame);
-                    form.addEventListener("turbo:submit-start", () => form.remove());
-                }
-                else {
-                    form.addEventListener("submit", () => form.remove());
-                }
-                document.body.appendChild(form);
-                return dispatch("submit", { cancelable: true, target: form });
-            }
-            else {
-                return false;
-            }
+            this.visit(location.href, { action });
         }
         allowsVisitingLocationWithAction(location, action) {
             return this.locationWithActionIsSamePage(location, action) || this.applicationAllowsVisitingLocation(location);
@@ -2669,9 +2898,9 @@ Copyright © 2021 Basecamp, LLC
         }
         willSubmitForm(form, submitter) {
             const action = getAction(form, submitter);
-            return this.elementDriveEnabled(form)
-                && (!submitter || this.elementDriveEnabled(submitter))
-                && locationIsVisitable(expandURL(action), this.snapshot.rootLocation);
+            return (this.elementDriveEnabled(form) &&
+                (!submitter || this.formElementDriveEnabled(submitter)) &&
+                locationIsVisitable(expandURL(action), this.snapshot.rootLocation));
         }
         formSubmitted(form, submitter) {
             this.navigator.submitForm(form, submitter);
@@ -2695,16 +2924,23 @@ Copyright © 2021 Basecamp, LLC
                 this.notifyApplicationBeforeCachingSnapshot();
             }
         }
-        allowsImmediateRender({ element }, resume) {
-            const event = this.notifyApplicationBeforeRender(element, resume);
-            return !event.defaultPrevented;
+        allowsImmediateRender({ element }, options) {
+            const event = this.notifyApplicationBeforeRender(element, options);
+            const { defaultPrevented, detail: { render }, } = event;
+            if (this.view.renderer && render) {
+                this.view.renderer.renderElement = render;
+            }
+            return !defaultPrevented;
         }
-        viewRenderedSnapshot(snapshot, isPreview) {
+        viewRenderedSnapshot(_snapshot, _isPreview) {
             this.view.lastRenderedLocation = this.history.location;
             this.notifyApplicationAfterRender();
         }
-        viewInvalidated() {
-            this.adapter.pageInvalidated();
+        preloadOnLoadLinksForView(element) {
+            this.preloader.preloadOnLoadLinksForView(element);
+        }
+        viewInvalidated(reason) {
+            this.adapter.pageInvalidated(reason);
         }
         frameLoaded(frame) {
             this.notifyApplicationAfterFrameLoad(frame);
@@ -2712,19 +2948,26 @@ Copyright © 2021 Basecamp, LLC
         frameRendered(fetchResponse, frame) {
             this.notifyApplicationAfterFrameRender(fetchResponse, frame);
         }
-        applicationAllowsFollowingLinkToLocation(link, location) {
-            const event = this.notifyApplicationAfterClickingLinkToLocation(link, location);
+        applicationAllowsFollowingLinkToLocation(link, location, ev) {
+            const event = this.notifyApplicationAfterClickingLinkToLocation(link, location, ev);
             return !event.defaultPrevented;
         }
         applicationAllowsVisitingLocation(location) {
             const event = this.notifyApplicationBeforeVisitingLocation(location);
             return !event.defaultPrevented;
         }
-        notifyApplicationAfterClickingLinkToLocation(link, location) {
-            return dispatch("turbo:click", { target: link, detail: { url: location.href }, cancelable: true });
+        notifyApplicationAfterClickingLinkToLocation(link, location, event) {
+            return dispatch("turbo:click", {
+                target: link,
+                detail: { url: location.href, originalEvent: event },
+                cancelable: true,
+            });
         }
         notifyApplicationBeforeVisitingLocation(location) {
-            return dispatch("turbo:before-visit", { detail: { url: location.href }, cancelable: true });
+            return dispatch("turbo:before-visit", {
+                detail: { url: location.href },
+                cancelable: true,
+            });
         }
         notifyApplicationAfterVisitingLocation(location, action) {
             markAsBusy(document.documentElement);
@@ -2733,24 +2976,46 @@ Copyright © 2021 Basecamp, LLC
         notifyApplicationBeforeCachingSnapshot() {
             return dispatch("turbo:before-cache");
         }
-        notifyApplicationBeforeRender(newBody, resume) {
-            return dispatch("turbo:before-render", { detail: { newBody, resume }, cancelable: true });
+        notifyApplicationBeforeRender(newBody, options) {
+            return dispatch("turbo:before-render", {
+                detail: Object.assign({ newBody }, options),
+                cancelable: true,
+            });
         }
         notifyApplicationAfterRender() {
             return dispatch("turbo:render");
         }
         notifyApplicationAfterPageLoad(timing = {}) {
             clearBusyState(document.documentElement);
-            return dispatch("turbo:load", { detail: { url: this.location.href, timing } });
+            return dispatch("turbo:load", {
+                detail: { url: this.location.href, timing },
+            });
         }
         notifyApplicationAfterVisitingSamePageLocation(oldURL, newURL) {
-            dispatchEvent(new HashChangeEvent("hashchange", { oldURL: oldURL.toString(), newURL: newURL.toString() }));
+            dispatchEvent(new HashChangeEvent("hashchange", {
+                oldURL: oldURL.toString(),
+                newURL: newURL.toString(),
+            }));
         }
         notifyApplicationAfterFrameLoad(frame) {
             return dispatch("turbo:frame-load", { target: frame });
         }
         notifyApplicationAfterFrameRender(fetchResponse, frame) {
-            return dispatch("turbo:frame-render", { detail: { fetchResponse }, target: frame, cancelable: true });
+            return dispatch("turbo:frame-render", {
+                detail: { fetchResponse },
+                target: frame,
+                cancelable: true,
+            });
+        }
+        formElementDriveEnabled(element) {
+            if (this.formMode == "off") {
+                return false;
+            }
+            if (this.formMode == "optin") {
+                const form = element === null || element === void 0 ? void 0 : element.closest("form[data-turbo]");
+                return (form === null || form === void 0 ? void 0 : form.getAttribute("data-turbo")) == "true";
+            }
+            return this.elementDriveEnabled(element);
         }
         elementDriveEnabled(element) {
             const container = element === null || element === void 0 ? void 0 : element.closest("[data-turbo]");
@@ -2775,18 +3040,6 @@ Copyright © 2021 Basecamp, LLC
             const action = link.getAttribute("data-turbo-action");
             return isAction(action) ? action : "advance";
         }
-        getTargetFrameForLink(link) {
-            const frame = link.getAttribute("data-turbo-frame");
-            if (frame) {
-                return frame;
-            }
-            else {
-                const container = link.closest("turbo-frame");
-                if (container) {
-                    return container.id;
-                }
-            }
-        }
         get snapshot() {
             return this.view.snapshot;
         }
@@ -2798,11 +3051,59 @@ Copyright © 2021 Basecamp, LLC
         absoluteURL: {
             get() {
                 return this.toString();
-            }
+            },
+        },
+    };
+
+    class Cache {
+        constructor(session) {
+            this.session = session;
+        }
+        clear() {
+            this.session.clearCache();
+        }
+        resetCacheControl() {
+            this.setCacheControl("");
+        }
+        exemptPageFromCache() {
+            this.setCacheControl("no-cache");
+        }
+        exemptPageFromPreview() {
+            this.setCacheControl("no-preview");
+        }
+        setCacheControl(value) {
+            setMetaContent("turbo-cache-control", value);
         }
+    }
+
+    const StreamActions = {
+        after() {
+            this.targetElements.forEach((e) => { var _a; return (_a = e.parentElement) === null || _a === void 0 ? void 0 : _a.insertBefore(this.templateContent, e.nextSibling); });
+        },
+        append() {
+            this.removeDuplicateTargetChildren();
+            this.targetElements.forEach((e) => e.append(this.templateContent));
+        },
+        before() {
+            this.targetElements.forEach((e) => { var _a; return (_a = e.parentElement) === null || _a === void 0 ? void 0 : _a.insertBefore(this.templateContent, e); });
+        },
+        prepend() {
+            this.removeDuplicateTargetChildren();
+            this.targetElements.forEach((e) => e.prepend(this.templateContent));
+        },
+        remove() {
+            this.targetElements.forEach((e) => e.remove());
+        },
+        replace() {
+            this.targetElements.forEach((e) => e.replaceWith(this.templateContent));
+        },
+        update() {
+            this.targetElements.forEach((e) => e.replaceChildren(this.templateContent));
+        },
     };
 
-    const session = new Session;
+    const session = new Session();
+    const cache = new Cache(session);
     const { navigator: navigator$1 } = session;
     function start() {
         session.start();
@@ -2823,6 +3124,7 @@ Copyright © 2021 Basecamp, LLC
         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) {
@@ -2831,13 +3133,18 @@ Copyright © 2021 Basecamp, LLC
     function setConfirmMethod(confirmMethod) {
         FormSubmission.confirmMethod = confirmMethod;
     }
+    function setFormMode(mode) {
+        session.setFormMode(mode);
+    }
 
     var Turbo = /*#__PURE__*/Object.freeze({
         __proto__: null,
         navigator: navigator$1,
         session: session,
+        cache: cache,
         PageRenderer: PageRenderer,
         PageSnapshot: PageSnapshot,
+        FrameRenderer: FrameRenderer,
         start: start,
         registerAdapter: registerAdapter,
         visit: visit,
@@ -2846,39 +3153,52 @@ Copyright © 2021 Basecamp, LLC
         renderStreamMessage: renderStreamMessage,
         clearCache: clearCache,
         setProgressBarDelay: setProgressBarDelay,
-        setConfirmMethod: setConfirmMethod
+        setConfirmMethod: setConfirmMethod,
+        setFormMode: setFormMode,
+        StreamActions: StreamActions
     });
 
     class FrameController {
         constructor(element) {
-            this.fetchResponseLoaded = (fetchResponse) => { };
+            this.fetchResponseLoaded = (_fetchResponse) => { };
             this.currentFetchRequest = null;
             this.resolveVisitPromise = () => { };
             this.connected = false;
             this.hasBeenLoaded = false;
-            this.settingSourceURL = false;
+            this.ignoredAttributes = new Set();
+            this.visitCachedSnapshot = ({ element }) => {
+                const frame = element.querySelector("#" + this.element.id);
+                if (frame && this.previousFrameElement) {
+                    frame.replaceChildren(...this.previousFrameElement.children);
+                }
+                delete this.previousFrameElement;
+            };
             this.element = element;
             this.view = new FrameView(this, this.element);
             this.appearanceObserver = new AppearanceObserver(this, this.element);
+            this.formLinkInterceptor = new FormLinkInterceptor(this, this.element);
             this.linkInterceptor = new LinkInterceptor(this, this.element);
             this.formInterceptor = new FormInterceptor(this, this.element);
         }
         connect() {
             if (!this.connected) {
                 this.connected = true;
-                this.reloadable = false;
                 if (this.loadingStyle == FrameLoadingStyle.lazy) {
                     this.appearanceObserver.start();
                 }
+                else {
+                    this.loadSourceURL();
+                }
+                this.formLinkInterceptor.start();
                 this.linkInterceptor.start();
                 this.formInterceptor.start();
-                this.sourceURLChanged();
             }
         }
         disconnect() {
             if (this.connected) {
                 this.connected = false;
                 this.appearanceObserver.stop();
+                this.formLinkInterceptor.stop();
                 this.linkInterceptor.stop();
                 this.formInterceptor.stop();
             }
@@ -2889,10 +3209,20 @@ Copyright © 2021 Basecamp, LLC
             }
         }
         sourceURLChanged() {
+            if (this.isIgnoringChangesTo("src"))
+                return;
+            if (this.element.isConnected) {
+                this.complete = false;
+            }
             if (this.loadingStyle == FrameLoadingStyle.eager || this.hasBeenLoaded) {
                 this.loadSourceURL();
             }
         }
+        completeChanged() {
+            if (this.isIgnoringChangesTo("complete"))
+                return;
+            this.loadSourceURL();
+        }
         loadingStyleChanged() {
             if (this.loadingStyle == FrameLoadingStyle.lazy) {
                 this.appearanceObserver.start();
@@ -2903,21 +3233,11 @@ Copyright © 2021 Basecamp, LLC
             }
         }
         async loadSourceURL() {
-            if (!this.settingSourceURL && this.enabled && this.isActive && (this.reloadable || this.sourceURL != this.currentURL)) {
-                const previousURL = this.currentURL;
-                this.currentURL = this.sourceURL;
-                if (this.sourceURL) {
-                    try {
-                        this.element.loaded = this.visit(this.sourceURL);
-                        this.appearanceObserver.stop();
-                        await this.element.loaded;
-                        this.hasBeenLoaded = true;
-                    }
-                    catch (error) {
-                        this.currentURL = previousURL;
-                        throw error;
-                    }
-                }
+            if (this.enabled && this.isActive && !this.complete && this.sourceURL) {
+                this.element.loaded = this.visit(expandURL(this.sourceURL));
+                this.appearanceObserver.stop();
+                await this.element.loaded;
+                this.hasBeenLoaded = true;
             }
         }
         async loadResponse(fetchResponse) {
@@ -2929,10 +3249,11 @@ Copyright © 2021 Basecamp, LLC
                 if (html) {
                     const { body } = parseHTMLDocument(html);
                     const snapshot = new Snapshot(await this.extractForeignFrameElement(body));
-                    const renderer = new FrameRenderer(this.view.snapshot, snapshot, false, false);
+                    const renderer = new FrameRenderer(this, this.view.snapshot, snapshot, FrameRenderer.renderElement, false, false);
                     if (this.view.renderPromise)
                         await this.view.renderPromise;
                     await this.view.render(renderer);
+                    this.complete = true;
                     session.frameRendered(fetchResponse, this.element);
                     session.frameLoaded(this.element);
                     this.fetchResponseLoaded(fetchResponse);
@@ -2946,19 +3267,21 @@ Copyright © 2021 Basecamp, LLC
                 this.fetchResponseLoaded = () => { };
             }
         }
-        elementAppearedInViewport(element) {
+        elementAppearedInViewport(_element) {
             this.loadSourceURL();
         }
-        shouldInterceptLinkClick(element, url) {
-            if (element.hasAttribute("data-turbo-method")) {
-                return false;
-            }
-            else {
-                return this.shouldInterceptNavigation(element);
-            }
+        shouldInterceptFormLinkClick(link) {
+            return this.shouldInterceptNavigation(link);
+        }
+        formLinkClickIntercepted(link, form) {
+            const frame = this.findFrameElement(link);
+            if (frame)
+                form.setAttribute("data-turbo-frame", frame.id);
+        }
+        shouldInterceptLinkClick(element, _url) {
+            return this.shouldInterceptNavigation(element);
         }
         linkClickIntercepted(element, url) {
-            this.reloadable = true;
             this.navigateFrame(element, url);
         }
         shouldInterceptFormSubmission(element, submitter) {
@@ -2968,19 +3291,18 @@ Copyright © 2021 Basecamp, LLC
             if (this.formSubmission) {
                 this.formSubmission.stop();
             }
-            this.reloadable = false;
             this.formSubmission = new FormSubmission(this, element, submitter);
             const { fetchRequest } = this.formSubmission;
             this.prepareHeadersForRequest(fetchRequest.headers, fetchRequest);
             this.formSubmission.start();
         }
-        prepareHeadersForRequest(headers, request) {
+        prepareHeadersForRequest(headers, _request) {
             headers["Turbo-Frame"] = this.id;
         }
-        requestStarted(request) {
+        requestStarted(_request) {
             markAsBusy(this.element);
         }
-        requestPreventedHandlingResponse(request, response) {
+        requestPreventedHandlingResponse(_request, _response) {
             this.resolveVisitPromise();
         }
         async requestSucceededWithResponse(request, response) {
@@ -2995,7 +3317,7 @@ Copyright © 2021 Basecamp, LLC
             console.error(error);
             this.resolveVisitPromise();
         }
-        requestFinished(request) {
+        requestFinished(_request) {
             clearBusyState(this.element);
         }
         formSubmissionStarted({ formElement }) {
@@ -3015,19 +3337,32 @@ Copyright © 2021 Basecamp, LLC
         formSubmissionFinished({ formElement }) {
             clearBusyState(formElement, this.findFrameElement(formElement));
         }
-        allowsImmediateRender(snapshot, resume) {
-            return true;
+        allowsImmediateRender({ element: newFrame }, options) {
+            const event = dispatch("turbo:before-frame-render", {
+                target: this.element,
+                detail: Object.assign({ newFrame }, options),
+                cancelable: true,
+            });
+            const { defaultPrevented, detail: { render }, } = event;
+            if (this.view.renderer && render) {
+                this.view.renderer.renderElement = render;
+            }
+            return !defaultPrevented;
         }
-        viewRenderedSnapshot(snapshot, isPreview) {
+        viewRenderedSnapshot(_snapshot, _isPreview) { }
+        preloadOnLoadLinksForView(element) {
+            session.preloadOnLoadLinksForView(element);
         }
-        viewInvalidated() {
+        viewInvalidated() { }
+        frameExtracted(element) {
+            this.previousFrameElement = element;
         }
         async visit(url) {
             var _a;
-            const request = new FetchRequest(this, FetchMethod.get, expandURL(url), new URLSearchParams, this.element);
+            const request = new FetchRequest(this, FetchMethod.get, url, new URLSearchParams(), this.element);
             (_a = this.currentFetchRequest) === null || _a === void 0 ? void 0 : _a.cancel();
             this.currentFetchRequest = request;
-            return new Promise(resolve => {
+            return new Promise((resolve) => {
                 this.resolveVisitPromise = () => {
                     this.resolveVisitPromise = () => { };
                     this.currentFetchRequest = null;
@@ -3039,19 +3374,23 @@ Copyright © 2021 Basecamp, LLC
         navigateFrame(element, url, submitter) {
             const frame = this.findFrameElement(element, submitter);
             this.proposeVisitIfNavigatedWithAction(frame, element, submitter);
-            frame.setAttribute("reloadable", "");
             frame.src = url;
         }
         proposeVisitIfNavigatedWithAction(frame, element, submitter) {
             const action = getAttribute("data-turbo-action", submitter, element, frame);
             if (isAction(action)) {
-                const { visitCachedSnapshot } = new SnapshotSubstitution(frame);
+                const { visitCachedSnapshot } = frame.delegate;
                 frame.delegate.fetchResponseLoaded = (fetchResponse) => {
                     if (frame.src) {
                         const { statusCode, redirected } = fetchResponse;
                         const responseHTML = frame.ownerDocument.documentElement.outerHTML;
                         const response = { statusCode, redirected, responseHTML };
-                        session.visit(frame.src, { action, response, visitCachedSnapshot, willRender: false });
+                        session.visit(frame.src, {
+                            action,
+                            response,
+                            visitCachedSnapshot,
+                            willRender: false,
+                        });
                     }
                 };
             }
@@ -3065,10 +3404,12 @@ Copyright © 2021 Basecamp, LLC
             let element;
             const id = CSS.escape(this.id);
             try {
-                if (element = activateElement(container.querySelector(`turbo-frame#${id}`), this.currentURL)) {
+                element = activateElement(container.querySelector(`turbo-frame#${id}`), this.sourceURL);
+                if (element) {
                     return element;
                 }
-                if (element = activateElement(container.querySelector(`turbo-frame[src][recurse~=${id}]`), this.currentURL)) {
+                element = activateElement(container.querySelector(`turbo-frame[src][recurse~=${id}]`), this.sourceURL);
+                if (element) {
                     await element.loaded;
                     return await this.extractForeignFrameElement(element);
                 }
@@ -3116,24 +3457,10 @@ Copyright © 2021 Basecamp, LLC
                 return this.element.src;
             }
         }
-        get reloadable() {
-            const frame = this.findFrameElement(this.element);
-            return frame.hasAttribute("reloadable");
-        }
-        set reloadable(value) {
-            const frame = this.findFrameElement(this.element);
-            if (value) {
-                frame.setAttribute("reloadable", "");
-            }
-            else {
-                frame.removeAttribute("reloadable");
-            }
-        }
         set sourceURL(sourceURL) {
-            this.settingSourceURL = true;
-            this.element.src = sourceURL !== null && sourceURL !== void 0 ? sourceURL : null;
-            this.currentURL = this.element.src;
-            this.settingSourceURL = false;
+            this.ignoringChangesToAttribute("src", () => {
+                this.element.src = sourceURL !== null && sourceURL !== void 0 ? sourceURL : null;
+            });
         }
         get loadingStyle() {
             return this.element.loading;
@@ -3141,6 +3468,19 @@ Copyright © 2021 Basecamp, LLC
         get isLoading() {
             return this.formSubmission !== undefined || this.resolveVisitPromise() !== undefined;
         }
+        get complete() {
+            return this.element.hasAttribute("complete");
+        }
+        set complete(value) {
+            this.ignoringChangesToAttribute("complete", () => {
+                if (value) {
+                    this.element.setAttribute("complete", "");
+                }
+                else {
+                    this.element.removeAttribute("complete");
+                }
+            });
+        }
         get isActive() {
             return this.element.isActive && this.connected;
         }
@@ -3150,16 +3490,13 @@ Copyright © 2021 Basecamp, LLC
             const root = (_a = meta === null || meta === void 0 ? void 0 : meta.content) !== null && _a !== void 0 ? _a : "/";
             return expandURL(root);
         }
-    }
-    class SnapshotSubstitution {
-        constructor(element) {
-            this.visitCachedSnapshot = ({ element }) => {
-                var _a;
-                const { id, clone } = this;
-                (_a = element.querySelector("#" + id)) === null || _a === void 0 ? void 0 : _a.replaceWith(clone);
-            };
-            this.clone = element.cloneNode(true);
-            this.id = element.id;
+        isIgnoringChangesTo(attributeName) {
+            return this.ignoredAttributes.has(attributeName);
+        }
+        ignoringChangesToAttribute(attributeName, callback) {
+            this.ignoredAttributes.add(attributeName);
+            callback();
+            this.ignoredAttributes.delete(attributeName);
         }
     }
     function getFrameElementById(id) {
@@ -3187,35 +3524,6 @@ Copyright © 2021 Basecamp, LLC
         }
     }
 
-    const StreamActions = {
-        after() {
-            this.targetElements.forEach(e => { var _a; return (_a = e.parentElement) === null || _a === void 0 ? void 0 : _a.insertBefore(this.templateContent, e.nextSibling); });
-        },
-        append() {
-            this.removeDuplicateTargetChildren();
-            this.targetElements.forEach(e => e.append(this.templateContent));
-        },
-        before() {
-            this.targetElements.forEach(e => { var _a; return (_a = e.parentElement) === null || _a === void 0 ? void 0 : _a.insertBefore(this.templateContent, e); });
-        },
-        prepend() {
-            this.removeDuplicateTargetChildren();
-            this.targetElements.forEach(e => e.prepend(this.templateContent));
-        },
-        remove() {
-            this.targetElements.forEach(e => e.remove());
-        },
-        replace() {
-            this.targetElements.forEach(e => e.replaceWith(this.templateContent));
-        },
-        update() {
-            this.targetElements.forEach(e => {
-                e.innerHTML = "";
-                e.append(this.templateContent);
-            });
-        }
-    };
-
     class StreamElement extends HTMLElement {
         async connectedCallback() {
             try {
@@ -3230,12 +3538,12 @@ Copyright © 2021 Basecamp, LLC
         }
         async render() {
             var _a;
-            return (_a = this.renderPromise) !== null && _a !== void 0 ? _a : (this.renderPromise = (async () => {
+            return ((_a = this.renderPromise) !== null && _a !== void 0 ? _a : (this.renderPromise = (async () => {
                 if (this.dispatchEvent(this.beforeRenderEvent)) {
                     await nextAnimationFrame();
                     this.performAction();
                 }
-            })());
+            })()));
         }
         disconnect() {
             try {
@@ -3244,13 +3552,13 @@ Copyright © 2021 Basecamp, LLC
             catch (_a) { }
         }
         removeDuplicateTargetChildren() {
-            this.duplicateChildren.forEach(c => c.remove());
+            this.duplicateChildren.forEach((c) => c.remove());
         }
         get duplicateChildren() {
             var _a;
-            const existingChildren = this.targetElements.flatMap(e => [...e.children]).filter(c => !!c.id);
-            const newChildrenIds = [...(_a = this.templateContent) === null || _a === void 0 ? void 0 : _a.children].filter(c => !!c.id).map(c => c.id);
-            return existingChildren.filter(c => newChildrenIds.includes(c.id));
+            const existingChildren = this.targetElements.flatMap((e) => [...e.children]).filter((c) => !!c.id);
+            const newChildrenIds = [...(((_a = this.templateContent) === null || _a === void 0 ? void 0 : _a.children) || [])].filter((c) => !!c.id).map((c) => c.id);
+            return existingChildren.filter((c) => newChildrenIds.includes(c.id));
         }
         get performAction() {
             if (this.action) {
@@ -3299,7 +3607,10 @@ Copyright © 2021 Basecamp, LLC
             return (_b = ((_a = this.outerHTML.match(/<[^>]+>/)) !== null && _a !== void 0 ? _a : [])[0]) !== null && _b !== void 0 ? _b : "<turbo-stream>";
         }
         get beforeRenderEvent() {
-            return new CustomEvent("turbo:before-stream-render", { bubbles: true, cancelable: true });
+            return new CustomEvent("turbo:before-stream-render", {
+                bubbles: true,
+                cancelable: true,
+            });
         }
         get targetElementsById() {
             var _a;
@@ -3323,9 +3634,35 @@ Copyright © 2021 Basecamp, LLC
         }
     }
 
+    class StreamSourceElement extends HTMLElement {
+        constructor() {
+            super(...arguments);
+            this.streamSource = null;
+        }
+        connectedCallback() {
+            this.streamSource = this.src.match(/^ws{1,2}:/) ? new WebSocket(this.src) : new EventSource(this.src);
+            connectStreamSource(this.streamSource);
+        }
+        disconnectedCallback() {
+            if (this.streamSource) {
+                disconnectStreamSource(this.streamSource);
+            }
+        }
+        get src() {
+            return this.getAttribute("src") || "";
+        }
+    }
+
     FrameElement.delegateConstructor = FrameController;
-    customElements.define("turbo-frame", FrameElement);
-    customElements.define("turbo-stream", StreamElement);
+    if (customElements.get("turbo-frame") === undefined) {
+        customElements.define("turbo-frame", FrameElement);
+    }
+    if (customElements.get("turbo-stream") === undefined) {
+        customElements.define("turbo-stream", StreamElement);
+    }
+    if (customElements.get("turbo-stream-source") === undefined) {
+        customElements.define("turbo-stream-source", StreamSourceElement);
+    }
 
     (() => {
         let element = document.currentScript;
@@ -3333,7 +3670,8 @@ Copyright © 2021 Basecamp, LLC
             return;
         if (element.hasAttribute("data-turbo-suppress-warning"))
             return;
-        while (element = element.parentElement) {
+        element = element.parentElement;
+        while (element) {
             if (element == document.body) {
                 return console.warn(unindent `
         You are loading Turbo from a <script> element inside the <body> element. This is probably not what you meant to do!
@@ -3346,14 +3684,18 @@ Copyright © 2021 Basecamp, LLC
         Suppress this warning by adding a "data-turbo-suppress-warning" attribute to: %s
       `, element.outerHTML);
             }
+            element = element.parentElement;
         }
     })();
 
     window.Turbo = Turbo;
     start();
 
+    exports.FrameRenderer = FrameRenderer;
     exports.PageRenderer = PageRenderer;
     exports.PageSnapshot = PageSnapshot;
+    exports.StreamActions = StreamActions;
+    exports.cache = cache;
     exports.clearCache = clearCache;
     exports.connectStreamSource = connectStreamSource;
     exports.disconnectStreamSource = disconnectStreamSource;
@@ -3362,10 +3704,11 @@ Copyright © 2021 Basecamp, LLC
     exports.renderStreamMessage = renderStreamMessage;
     exports.session = session;
     exports.setConfirmMethod = setConfirmMethod;
+    exports.setFormMode = setFormMode;
     exports.setProgressBarDelay = setProgressBarDelay;
     exports.start = start;
     exports.visit = visit;
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));