turbo-rails 0.7.11 → 1.3.0

data/app/assets/javascripts/turbo.js

@@ -14,6 +14,31 @@
   Object.setPrototypeOf(HTMLElement, BuiltInHTMLElement);
 })();
 
+(function(prototype) {
+  if (typeof prototype.requestSubmit == "function") return;
+  prototype.requestSubmit = function(submitter) {
+    if (submitter) {
+      validateSubmitter(submitter, this);
+      submitter.click();
+    } else {
+      submitter = document.createElement("input");
+      submitter.type = "submit";
+      submitter.hidden = true;
+      this.appendChild(submitter);
+      submitter.click();
+      this.removeChild(submitter);
+    }
+  };
+  function validateSubmitter(submitter, form) {
+    submitter instanceof HTMLElement || raise(TypeError, "parameter 1 is not of type 'HTMLElement'");
+    submitter.type == "submit" || raise(TypeError, "The specified element is not a submit button");
+    submitter.form == form || raise(DOMException, "The specified element is not owned by this form element", "NotFoundError");
+  }
+  function raise(errorConstructor, message, name) {
+    throw new errorConstructor("Failed to execute 'requestSubmit' on 'HTMLFormElement': " + message + ".", name);
+  }
+})(HTMLFormElement.prototype);
+
 const submittersByForm = new WeakMap;
 
 function findSubmitterFromClickTarget(target) {
@@ -30,9 +55,17 @@ function clickCaptured(event) {
 }
 
 (function() {
-  if ("SubmitEvent" in window) return;
+  if ("submitter" in Event.prototype) return;
+  let prototype;
+  if ("SubmitEvent" in window && /Apple Computer/.test(navigator.vendor)) {
+    prototype = window.SubmitEvent.prototype;
+  } else if ("SubmitEvent" in window) {
+    return;
+  } else {
+    prototype = window.Event.prototype;
+  }
   addEventListener("click", clickCaptured, true);
-  Object.defineProperty(Event.prototype, "submitter", {
+  Object.defineProperty(prototype, "submitter", {
     get() {
       if (this.type == "submit" && this.target instanceof HTMLFormElement) {
         return submittersByForm.get(this.target);
@@ -55,7 +88,7 @@ class FrameElement extends HTMLElement {
     this.delegate = new FrameElement.delegateConstructor(this);
   }
   static get observedAttributes() {
-    return [ "disabled", "loading", "src" ];
+    return [ "disabled", "complete", "loading", "src" ];
   }
   connectedCallback() {
     this.delegate.connect();
@@ -65,12 +98,16 @@ class FrameElement extends HTMLElement {
   }
   reload() {
     const {src: src} = this;
+    this.removeAttribute("complete");
     this.src = null;
     this.src = src;
+    return this.loaded;
   }
   attributeChangedCallback(name) {
     if (name == "loading") {
       this.delegate.loadingStyleChanged();
+    } else if (name == "complete") {
+      this.delegate.completeChanged();
     } else if (name == "src") {
       this.delegate.sourceURLChanged();
     } else {
@@ -152,12 +189,17 @@ function getAnchor(url) {
   }
 }
 
+function getAction(form, submitter) {
+  const action = (submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("formaction")) || form.getAttribute("action") || form.action;
+  return expandURL(action);
+}
+
 function getExtension(url) {
   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) {
@@ -165,6 +207,10 @@ function isPrefixedBy(baseURL, url) {
   return baseURL.href === expandURL(prefix).href || baseURL.href.startsWith(prefix);
 }
 
+function locationIsVisitable(location, rootLocation) {
+  return isPrefixedBy(location, rootLocation) && isHTML(location);
+}
+
 function getRequestURL(url) {
   const anchor = getAnchor(url);
   return anchor != null ? url.href.slice(0, -(anchor.length + 1)) : url.href;
@@ -226,11 +272,11 @@ class FetchResponse {
     return this.header("Content-Type");
   }
   get responseText() {
-    return this.response.text();
+    return this.response.clone().text();
   }
   get responseHTML() {
     if (this.isHTML) {
-      return this.response.text();
+      return this.response.clone().text();
     } else {
       return Promise.resolve(undefined);
     }
@@ -240,13 +286,49 @@ class FetchResponse {
   }
 }
 
+function isAction(action) {
+  return action == "advance" || action == "replace" || action == "restore";
+}
+
+function activateScriptElement(element) {
+  if (element.getAttribute("data-turbo-eval") == "false") {
+    return element;
+  } else {
+    const createdScriptElement = document.createElement("script");
+    const cspNonce = getMetaContent("csp-nonce");
+    if (cspNonce) {
+      createdScriptElement.nonce = cspNonce;
+    }
+    createdScriptElement.textContent = element.textContent;
+    createdScriptElement.async = false;
+    copyElementAttributes(createdScriptElement, element);
+    return createdScriptElement;
+  }
+}
+
+function copyElementAttributes(destinationElement, sourceElement) {
+  for (const {name: name, value: value} of sourceElement.attributes) {
+    destinationElement.setAttribute(name, value);
+  }
+}
+
+function createDocumentFragment(html) {
+  const template = document.createElement("template");
+  template.innerHTML = html;
+  return template.content;
+}
+
 function dispatch(eventName, {target: target, cancelable: cancelable, detail: detail} = {}) {
   const event = new CustomEvent(eventName, {
     cancelable: cancelable,
     bubbles: true,
     detail: detail
   });
-  void (target || document.documentElement).dispatchEvent(event);
+  if (target && target.isConnected) {
+    target.dispatchEvent(event);
+  } else {
+    document.documentElement.dispatchEvent(event);
+  }
   return event;
 }
 
@@ -281,7 +363,7 @@ function interpolate(strings, values) {
 }
 
 function uuid() {
-  return Array.apply(null, {
+  return Array.from({
     length: 36
   }).map(((_, i) => {
     if (i == 8 || i == 13 || i == 18 || i == 23) {
@@ -296,6 +378,88 @@ function uuid() {
   })).join("");
 }
 
+function getAttribute(attributeName, ...elements) {
+  for (const value of elements.map((element => element === null || element === void 0 ? void 0 : element.getAttribute(attributeName)))) {
+    if (typeof value == "string") return value;
+  }
+  return null;
+}
+
+function hasAttribute(attributeName, ...elements) {
+  return elements.some((element => element && element.hasAttribute(attributeName)));
+}
+
+function markAsBusy(...elements) {
+  for (const element of elements) {
+    if (element.localName == "turbo-frame") {
+      element.setAttribute("busy", "");
+    }
+    element.setAttribute("aria-busy", "true");
+  }
+}
+
+function clearBusyState(...elements) {
+  for (const element of elements) {
+    if (element.localName == "turbo-frame") {
+      element.removeAttribute("busy");
+    }
+    element.removeAttribute("aria-busy");
+  }
+}
+
+function waitForLoad(element, timeoutInMilliseconds = 2e3) {
+  return new Promise((resolve => {
+    const onComplete = () => {
+      element.removeEventListener("error", onComplete);
+      element.removeEventListener("load", onComplete);
+      resolve();
+    };
+    element.addEventListener("load", onComplete, {
+      once: true
+    });
+    element.addEventListener("error", onComplete, {
+      once: true
+    });
+    setTimeout(resolve, timeoutInMilliseconds);
+  }));
+}
+
+function getHistoryMethodForAction(action) {
+  switch (action) {
+   case "replace":
+    return history.replaceState;
+
+   case "advance":
+   case "restore":
+    return history.pushState;
+  }
+}
+
+function getVisitAction(...elements) {
+  const action = getAttribute("data-turbo-action", ...elements);
+  return isAction(action) ? action : null;
+}
+
+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) {
@@ -326,18 +490,15 @@ function fetchMethodFromString(method) {
 }
 
 class FetchRequest {
-  constructor(delegate, method, location, body = new URLSearchParams) {
+  constructor(delegate, method, location, body = new URLSearchParams, target = null) {
     this.abortController = new AbortController;
-    this.resolveRequestPromise = value => {};
+    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() {
     return this.url;
@@ -362,7 +523,9 @@ class FetchRequest {
       return await this.receive(response);
     } catch (error) {
       if (error.name !== "AbortError") {
-        this.delegate.requestErrored(this, error);
+        if (this.willDelegateErrorHandling(error)) {
+          this.delegate.requestErrored(this, error);
+        }
         throw error;
       }
     } finally {
@@ -375,7 +538,8 @@ class FetchRequest {
       cancelable: true,
       detail: {
         fetchResponse: fetchResponse
-      }
+      },
+      target: this.target
     });
     if (event.defaultPrevented) {
       this.delegate.requestPreventedHandlingResponse(this, fetchResponse);
@@ -393,7 +557,7 @@ class FetchRequest {
       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
     };
@@ -409,32 +573,33 @@ class FetchRequest {
   get abortSignal() {
     return this.abortController.signal;
   }
+  acceptResponseType(mimeType) {
+    this.headers["Accept"] = [ mimeType, this.headers["Accept"] ].join(", ");
+  }
   async allowRequestToBeIntercepted(fetchOptions) {
     const requestInterception = new Promise((resolve => this.resolveRequestPromise = resolve));
     const event = dispatch("turbo:before-fetch-request", {
       cancelable: true,
       detail: {
         fetchOptions: fetchOptions,
-        url: this.url.href,
+        url: this.url,
         resume: this.resolveRequestPromise
-      }
+      },
+      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);
-    }
+  willDelegateErrorHandling(error) {
+    const event = dispatch("turbo:fetch-request-error", {
+      target: this.target,
+      cancelable: true,
+      detail: {
+        request: this,
+        error: error
+      }
+    });
+    return !event.defaultPrevented;
   }
-  return url;
 }
 
 class AppearanceObserver {
@@ -465,40 +630,31 @@ class AppearanceObserver {
 }
 
 class StreamMessage {
-  constructor(html) {
-    this.templateElement = document.createElement("template");
-    this.templateElement.innerHTML = html;
+  constructor(fragment) {
+    this.fragment = importStreamElements(fragment);
   }
   static wrap(message) {
     if (typeof message == "string") {
-      return new this(message);
+      return new this(createDocumentFragment(message));
     } else {
       return message;
     }
   }
-  get fragment() {
-    const fragment = document.createDocumentFragment();
-    for (const element of this.foreignElements) {
-      fragment.appendChild(document.importNode(element, true));
-    }
-    return fragment;
-  }
-  get foreignElements() {
-    return this.templateChildren.reduce(((streamElements, child) => {
-      if (child.tagName.toLowerCase() == "turbo-stream") {
-        return [ ...streamElements, child ];
-      } else {
-        return streamElements;
-      }
-    }), []);
-  }
-  get templateChildren() {
-    return Array.from(this.templateElement.content.children);
-  }
 }
 
 StreamMessage.contentType = "text/vnd.turbo-stream.html";
 
+function importStreamElements(fragment) {
+  for (const element of fragment.querySelectorAll("turbo-stream")) {
+    const streamElement = document.importNode(element, true);
+    for (const inertScriptElement of streamElement.templateElement.content.querySelectorAll("script")) {
+      inertScriptElement.replaceWith(activateScriptElement(inertScriptElement));
+    }
+    element.replaceWith(streamElement);
+  }
+  return fragment;
+}
+
 var FormSubmissionState;
 
 (function(FormSubmissionState) {
@@ -538,9 +694,16 @@ class FormSubmission {
     this.formElement = formElement;
     this.submitter = submitter;
     this.formData = buildFormData(formElement, submitter);
-    this.fetchRequest = new FetchRequest(this, this.method, this.location, this.body);
+    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, _submitter) {
+    return Promise.resolve(confirm(message));
+  }
   get method() {
     var _a;
     const method = ((_a = this.submitter) === null || _a === void 0 ? void 0 : _a.getAttribute("formmethod")) || this.formElement.getAttribute("method") || "";
@@ -549,10 +712,11 @@ class FormSubmission {
   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);
+    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) {
@@ -573,6 +737,13 @@ class FormSubmission {
   }
   async start() {
     const {initialized: initialized, requesting: requesting} = FormSubmissionState;
+    const confirmationMessage = getAttribute("data-turbo-confirm", this.submitter, this.formElement);
+    if (typeof confirmationMessage === "string") {
+      const answer = await FormSubmission.confirmMethod(confirmationMessage, this.formElement, this.submitter);
+      if (!answer) {
+        return;
+      }
+    }
     if (this.state == initialized) {
       this.state = requesting;
       return this.fetchRequest.perform();
@@ -592,11 +763,15 @@ class FormSubmission {
       if (token) {
         headers["X-CSRF-Token"] = token;
       }
-      headers["Accept"] = [ StreamMessage.contentType, headers["Accept"] ].join(", ");
+    }
+    if (this.requestAcceptsTurboStreamResponse(request)) {
+      request.acceptResponseType(StreamMessage.contentType);
     }
   }
-  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: {
@@ -640,8 +815,10 @@ class FormSubmission {
     };
     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({
@@ -653,14 +830,17 @@ class FormSubmission {
   requestMustRedirect(request) {
     return !request.isIdempotent && this.mustRedirect;
   }
+  requestAcceptsTurboStreamResponse(request) {
+    return !request.isIdempotent || hasAttribute("data-turbo-stream", this.submitter, this.formElement);
+  }
 }
 
 function buildFormData(formElement, submitter) {
   const formData = new FormData(formElement);
   const name = submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("name");
   const value = submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("value");
-  if (name && value != null && formData.get(name) != value) {
-    formData.append(name, value);
+  if (name) {
+    formData.append(name, value || "");
   }
   return formData;
 }
@@ -676,19 +856,27 @@ function getCookieValue(cookieName) {
   }
 }
 
-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 ];
   }
@@ -702,13 +890,17 @@ class Snapshot {
     return this.element.isConnected;
   }
   get firstAutofocusableElement() {
-    return this.element.querySelector("[autofocus]");
+    const inertDisabledOrHidden = "[inert], :disabled, [hidden], details:not([open]), dialog:not([open])";
+    for (const element of this.element.querySelectorAll("[autofocus]")) {
+      if (element.closest(inertDisabledOrHidden) == null) return element; else continue;
+    }
+    return null;
   }
   get permanentElements() {
-    return [ ...this.element.querySelectorAll("[id][data-turbo-permanent]") ];
+    return queryPermanentElementsAll(this.element);
   }
   getPermanentElementById(id) {
-    return this.element.querySelector(`#${id}[data-turbo-permanent]`);
+    return getPermanentElementById(this.element, id);
   }
   getPermanentElementMapForSnapshot(snapshot) {
     const permanentElementMap = {};
@@ -723,34 +915,65 @@ class Snapshot {
   }
 }
 
-class FormInterceptor {
-  constructor(delegate, element) {
+function getPermanentElementById(node, id) {
+  return node.querySelector(`#${id}[data-turbo-permanent]`);
+}
+
+function queryPermanentElementsAll(node) {
+  return node.querySelectorAll("[id][data-turbo-permanent]");
+}
+
+class FormSubmitObserver {
+  constructor(delegate, eventTarget) {
+    this.started = false;
+    this.submitCaptured = () => {
+      this.eventTarget.removeEventListener("submit", this.submitBubbled, false);
+      this.eventTarget.addEventListener("submit", this.submitBubbled, false);
+    };
     this.submitBubbled = event => {
-      if (event.target instanceof HTMLFormElement) {
-        const form = event.target;
+      if (!event.defaultPrevented) {
+        const form = event.target instanceof HTMLFormElement ? event.target : undefined;
         const submitter = event.submitter || undefined;
-        if (this.delegate.shouldInterceptFormSubmission(form, submitter)) {
+        if (form && submissionDoesNotDismissDialog(form, submitter) && submissionDoesNotTargetIFrame(form, submitter) && this.delegate.willSubmitForm(form, submitter)) {
           event.preventDefault();
-          event.stopImmediatePropagation();
-          this.delegate.formSubmissionIntercepted(form, submitter);
+          this.delegate.formSubmitted(form, submitter);
         }
       }
     };
     this.delegate = delegate;
-    this.element = element;
+    this.eventTarget = eventTarget;
   }
   start() {
-    this.element.addEventListener("submit", this.submitBubbled);
+    if (!this.started) {
+      this.eventTarget.addEventListener("submit", this.submitCaptured, true);
+      this.started = true;
+    }
   }
   stop() {
-    this.element.removeEventListener("submit", this.submitBubbled);
+    if (this.started) {
+      this.eventTarget.removeEventListener("submit", this.submitCaptured, true);
+      this.started = false;
+    }
+  }
+}
+
+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 View {
   constructor(delegate, element) {
-    this.resolveRenderPromise = value => {};
-    this.resolveInterceptionPromise = value => {};
+    this.resolveRenderPromise = _value => {};
+    this.resolveInterceptionPromise = _value => {};
     this.delegate = delegate;
     this.element = element;
   }
@@ -801,12 +1024,17 @@ class View {
       try {
         this.renderPromise = new Promise((resolve => this.resolveRenderPromise = resolve));
         this.renderer = renderer;
-        this.prepareToRenderSnapshot(renderer);
+        await this.prepareToRenderSnapshot(renderer);
         const renderInterception = new Promise((resolve => this.resolveInterceptionPromise = resolve));
-        const immediateRender = this.delegate.allowsImmediateRender(snapshot, this.resolveInterceptionPromise);
+        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 {
         delete this.renderer;
@@ -814,15 +1042,15 @@ class View {
         delete this.renderPromise;
       }
     } else {
-      this.invalidate();
+      this.invalidate(renderer.reloadReason);
     }
   }
-  invalidate() {
-    this.delegate.viewInvalidated();
+  invalidate(reason) {
+    this.delegate.viewInvalidated(reason);
   }
-  prepareToRenderSnapshot(renderer) {
+  async prepareToRenderSnapshot(renderer) {
     this.markAsPreview(renderer.isPreview);
-    renderer.prepareToRender();
+    await renderer.prepareToRender();
   }
   markAsPreview(isPreview) {
     if (isPreview) {
@@ -848,60 +1076,115 @@ class FrameView extends View {
   }
 }
 
-class LinkInterceptor {
-  constructor(delegate, element) {
-    this.clickBubbled = event => {
-      if (this.respondsToEventTarget(event.target)) {
-        this.clickEvent = event;
-      } else {
-        delete this.clickEvent;
-      }
+class LinkClickObserver {
+  constructor(delegate, eventTarget) {
+    this.started = false;
+    this.clickCaptured = () => {
+      this.eventTarget.removeEventListener("click", this.clickBubbled, false);
+      this.eventTarget.addEventListener("click", this.clickBubbled, false);
     };
-    this.linkClicked = event => {
-      if (this.clickEvent && this.respondsToEventTarget(event.target) && event.target instanceof Element) {
-        if (this.delegate.shouldInterceptLinkClick(event.target, event.detail.url)) {
-          this.clickEvent.preventDefault();
-          event.preventDefault();
-          this.delegate.linkClickIntercepted(event.target, event.detail.url);
+    this.clickBubbled = event => {
+      if (event instanceof MouseEvent && this.clickEventIsSignificant(event)) {
+        const target = event.composedPath && event.composedPath()[0] || event.target;
+        const link = this.findLinkFromClickTarget(target);
+        if (link && doesNotTargetIFrame(link)) {
+          const location = this.getLocationForLink(link);
+          if (this.delegate.willFollowLinkToLocation(link, location, event)) {
+            event.preventDefault();
+            this.delegate.followedLinkToLocation(link, location);
+          }
         }
       }
-      delete this.clickEvent;
-    };
-    this.willVisit = () => {
-      delete this.clickEvent;
     };
     this.delegate = delegate;
-    this.element = element;
+    this.eventTarget = eventTarget;
+  }
+  start() {
+    if (!this.started) {
+      this.eventTarget.addEventListener("click", this.clickCaptured, true);
+      this.started = true;
+    }
+  }
+  stop() {
+    if (this.started) {
+      this.eventTarget.removeEventListener("click", this.clickCaptured, true);
+      this.started = false;
+    }
+  }
+  clickEventIsSignificant(event) {
+    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) {
+      return target.closest("a[href]:not([target^=_]):not([download])");
+    }
+  }
+  getLocationForLink(link) {
+    return expandURL(link.getAttribute("href") || "");
+  }
+}
+
+function doesNotTargetIFrame(anchor) {
+  for (const element of document.getElementsByName(anchor.target)) {
+    if (element instanceof HTMLIFrameElement) return false;
+  }
+  return true;
+}
+
+class FormLinkClickObserver {
+  constructor(delegate, element) {
+    this.delegate = delegate;
+    this.linkClickObserver = new LinkClickObserver(this, element);
   }
   start() {
-    this.element.addEventListener("click", this.clickBubbled);
-    document.addEventListener("turbo:click", this.linkClicked);
-    document.addEventListener("turbo:before-visit", this.willVisit);
+    this.linkClickObserver.start();
   }
   stop() {
-    this.element.removeEventListener("click", this.clickBubbled);
-    document.removeEventListener("turbo:click", this.linkClicked);
-    document.removeEventListener("turbo:before-visit", this.willVisit);
+    this.linkClickObserver.stop();
   }
-  respondsToEventTarget(target) {
-    const element = target instanceof Element ? target : target instanceof Node ? target.parentElement : null;
-    return element && element.closest("turbo-frame, html") == this.element;
+  willFollowLinkToLocation(link, location, originalEvent) {
+    return this.delegate.willSubmitFormLinkToLocation(link, location, originalEvent) && link.hasAttribute("data-turbo-method");
+  }
+  followedLinkToLocation(link, location) {
+    const action = location.href;
+    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 turboAction = link.getAttribute("data-turbo-action");
+    if (turboAction) form.setAttribute("data-turbo-action", turboAction);
+    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.submittedFormLinkToLocation(link, location, form);
+    document.body.appendChild(form);
+    form.addEventListener("turbo:submit-end", (() => form.remove()), {
+      once: true
+    });
+    requestAnimationFrame((() => form.requestSubmit()));
   }
 }
 
 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);
     }
   }
@@ -910,6 +1193,7 @@ class Bardo {
       const [currentPermanentElement] = this.permanentElementMap[id];
       this.replaceCurrentPermanentElementWithClone(currentPermanentElement);
       this.replacePlaceholderWithPermanentElement(currentPermanentElement);
+      this.delegate.leavingBardo(currentPermanentElement);
     }
   }
   replaceNewPermanentElementWithPlaceholder(permanentElement) {
@@ -940,10 +1224,13 @@ function createPlaceholderForPermanentElement(permanentElement) {
 }
 
 class Renderer {
-  constructor(currentSnapshot, newSnapshot, isPreview) {
+  constructor(currentSnapshot, newSnapshot, renderElement, isPreview, willRender = true) {
+    this.activeElement = null;
     this.currentSnapshot = currentSnapshot;
     this.newSnapshot = newSnapshot;
     this.isPreview = isPreview;
+    this.willRender = willRender;
+    this.renderElement = renderElement;
     this.promise = new Promise(((resolve, reject) => this.resolvingFunctions = {
       resolve: resolve,
       reject: reject
@@ -952,6 +1239,9 @@ class Renderer {
   get shouldRender() {
     return true;
   }
+  get reloadReason() {
+    return;
+  }
   prepareToRender() {
     return;
   }
@@ -961,22 +1251,8 @@ class Renderer {
       delete this.resolvingFunctions;
     }
   }
-  createScriptElement(element) {
-    if (element.getAttribute("data-turbo-eval") == "false") {
-      return element;
-    } else {
-      const createdScriptElement = document.createElement("script");
-      if (this.cspNonce) {
-        createdScriptElement.nonce = this.cspNonce;
-      }
-      createdScriptElement.textContent = element.textContent;
-      createdScriptElement.async = false;
-      copyElementAttributes(createdScriptElement, element);
-      return createdScriptElement;
-    }
-  }
   preservingPermanentElements(callback) {
-    Bardo.preservingPermanentElements(this.permanentElementMap, callback);
+    Bardo.preservingPermanentElements(this, this.permanentElementMap, callback);
   }
   focusFirstAutofocusableElement() {
     const element = this.connectedSnapshot.firstAutofocusableElement;
@@ -984,6 +1260,18 @@ class Renderer {
       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;
   }
@@ -996,16 +1284,6 @@ class Renderer {
   get permanentElementMap() {
     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");
-  }
-}
-
-function copyElementAttributes(destinationElement, sourceElement) {
-  for (const {name: name, value: value} of [ ...sourceElement.attributes ]) {
-    destinationElement.setAttribute(name, value);
-  }
 }
 
 function elementIsFocusable(element) {
@@ -1013,6 +1291,22 @@ function elementIsFocusable(element) {
 }
 
 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;
   }
@@ -1028,24 +1322,18 @@ class FrameRenderer extends Renderer {
     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.willRenderFrame(this.currentElement, this.newElement);
+    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: block
+          block: block,
+          behavior: behavior
         });
         return true;
       }
@@ -1054,7 +1342,7 @@ class FrameRenderer extends Renderer {
   }
   activateScriptElements() {
     for (const inertScriptElement of this.newScriptElements) {
-      const activatedScriptElement = this.createScriptElement(inertScriptElement);
+      const activatedScriptElement = activateScriptElement(inertScriptElement);
       inertScriptElement.replaceWith(activatedScriptElement);
     }
   }
@@ -1071,6 +1359,14 @@ function readScrollLogicalPosition(value, defaultValue) {
   }
 }
 
+function readScrollBehavior(value, defaultValue) {
+  if (value == "auto" || value == "smooth") {
+    return value;
+  } else {
+    return defaultValue;
+  }
+}
+
 class ProgressBar {
   constructor() {
     this.hiding = false;
@@ -1093,7 +1389,7 @@ class ProgressBar {
         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;
@@ -1159,6 +1455,9 @@ class ProgressBar {
     const element = document.createElement("style");
     element.type = "text/css";
     element.textContent = ProgressBar.defaultCSS;
+    if (this.cspNonce) {
+      element.nonce = this.cspNonce;
+    }
     return element;
   }
   createProgressElement() {
@@ -1166,6 +1465,9 @@ class ProgressBar {
     element.className = "turbo-progress-bar";
     return element;
   }
+  get cspNonce() {
+    return getMetaContent("csp-nonce");
+  }
 }
 
 ProgressBar.animationDuration = 300;
@@ -1173,7 +1475,7 @@ ProgressBar.animationDuration = 300;
 class HeadSnapshot extends Snapshot {
   constructor() {
     super(...arguments);
-    this.detailsByOuterHTML = this.children.filter((element => !elementIsNoscript(element))).reduce(((result, element) => {
+    this.detailsByOuterHTML = this.children.filter((element => !elementIsNoscript(element))).map((element => elementWithoutNonce(element))).reduce(((result, element) => {
       const {outerHTML: outerHTML} = element;
       const details = outerHTML in result ? result[outerHTML] : {
         type: elementType(element),
@@ -1236,25 +1538,32 @@ function elementIsTracked(element) {
 }
 
 function elementIsScript(element) {
-  const tagName = element.tagName.toLowerCase();
+  const tagName = element.localName;
   return tagName == "script";
 }
 
 function elementIsNoscript(element) {
-  const tagName = element.tagName.toLowerCase();
+  const tagName = element.localName;
   return tagName == "noscript";
 }
 
 function elementIsStylesheet(element) {
-  const tagName = element.tagName.toLowerCase();
+  const tagName = element.localName;
   return tagName == "style" || tagName == "link" && element.getAttribute("rel") == "stylesheet";
 }
 
 function elementIsMetaElementWithName(element, name) {
-  const tagName = element.tagName.toLowerCase();
+  const tagName = element.localName;
   return tagName == "meta" && element.getAttribute("name") == name;
 }
 
+function elementWithoutNonce(element) {
+  if (element.hasAttribute("nonce")) {
+    element.setAttribute("nonce", "");
+  }
+  return element;
+}
+
 class PageSnapshot extends Snapshot {
   constructor(element, headSnapshot) {
     super(element);
@@ -1270,7 +1579,18 @@ class PageSnapshot extends Snapshot {
     return new this(body, new HeadSnapshot(head));
   }
   clone() {
-    return new PageSnapshot(this.element.cloneNode(true), this.headSnapshot);
+    const clonedElement = this.element.cloneNode(true);
+    const selectElements = this.element.querySelectorAll("select");
+    const clonedSelectElements = clonedElement.querySelectorAll("select");
+    for (const [index, source] of selectElements.entries()) {
+      const clone = clonedSelectElements[index];
+      for (const option of clone.selectedOptions) option.selected = false;
+      for (const option of source.selectedOptions) clone.options[option.index].selected = true;
+    }
+    for (const clonedPasswordInput of clonedElement.querySelectorAll('input[type="password"]')) {
+      clonedPasswordInput.value = "";
+    }
+    return new PageSnapshot(clonedElement, this.headSnapshot);
   }
   get headElement() {
     return this.headSnapshot.element;
@@ -1318,7 +1638,12 @@ var VisitState;
 
 const defaultOptions = {
   action: "advance",
-  historyChanged: false
+  historyChanged: false,
+  visitCachedSnapshot: () => {},
+  willRender: true,
+  updateHistory: true,
+  shouldCacheSnapshot: true,
+  acceptsStreamResponse: false
 };
 
 var SystemStatusCode;
@@ -1336,18 +1661,26 @@ class Visit {
     this.followedRedirect = false;
     this.historyChanged = false;
     this.scrolled = false;
+    this.shouldCacheSnapshot = true;
+    this.acceptsStreamResponse = false;
     this.snapshotCached = false;
     this.state = VisitState.initialized;
     this.delegate = delegate;
     this.location = location;
     this.restorationIdentifier = restorationIdentifier || uuid();
-    const {action: action, historyChanged: historyChanged, referrer: referrer, snapshotHTML: snapshotHTML, response: response} = Object.assign(Object.assign({}, defaultOptions), options);
+    const {action: action, historyChanged: historyChanged, referrer: referrer, snapshotHTML: snapshotHTML, response: response, visitCachedSnapshot: visitCachedSnapshot, willRender: willRender, updateHistory: updateHistory, shouldCacheSnapshot: shouldCacheSnapshot, acceptsStreamResponse: acceptsStreamResponse} = Object.assign(Object.assign({}, defaultOptions), options);
     this.action = action;
     this.historyChanged = historyChanged;
     this.referrer = referrer;
     this.snapshotHTML = snapshotHTML;
     this.response = response;
     this.isSamePage = this.delegate.locationWithActionIsSamePage(this.location, this.action);
+    this.visitCachedSnapshot = visitCachedSnapshot;
+    this.willRender = willRender;
+    this.updateHistory = updateHistory;
+    this.scrolled = !willRender;
+    this.shouldCacheSnapshot = shouldCacheSnapshot;
+    this.acceptsStreamResponse = acceptsStreamResponse;
   }
   get adapter() {
     return this.delegate.adapter;
@@ -1385,9 +1718,11 @@ class Visit {
     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() {
@@ -1398,9 +1733,9 @@ class Visit {
   }
   changeHistory() {
     var _a;
-    if (!this.historyChanged) {
+    if (!this.historyChanged && this.updateHistory) {
       const actionForHistory = this.location.href === ((_a = this.referrer) === null || _a === void 0 ? void 0 : _a.href) ? "replace" : this.action;
-      const method = this.getHistoryMethodForAction(actionForHistory);
+      const method = getHistoryMethodForAction(actionForHistory);
       this.history.update(method, this.location, this.restorationIdentifier);
       this.historyChanged = true;
     }
@@ -1443,14 +1778,15 @@ class Visit {
     if (this.response) {
       const {statusCode: statusCode, responseHTML: responseHTML} = this.response;
       this.render((async () => {
-        this.cacheSnapshot();
+        if (this.shouldCacheSnapshot) this.cacheSnapshot();
         if (this.view.renderPromise) await this.view.renderPromise;
         if (isSuccessful(statusCode) && responseHTML != null) {
-          await this.view.renderPage(PageSnapshot.fromHTMLString(responseHTML));
+          await this.view.renderPage(PageSnapshot.fromHTMLString(responseHTML), false, this.willRender, this);
+          this.performScroll();
           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();
         }
@@ -1483,7 +1819,8 @@ class Visit {
           this.adapter.visitRendered(this);
         } else {
           if (this.view.renderPromise) await this.view.renderPromise;
-          await this.view.renderPage(snapshot, isPreview);
+          await this.view.renderPage(snapshot, isPreview, this.willRender, this);
+          this.performScroll();
           this.adapter.visitRendered(this);
           if (!isPreview) {
             this.complete();
@@ -1493,7 +1830,8 @@ class Visit {
     }
   }
   followRedirect() {
-    if (this.redirectedToLocation && !this.followedRedirect) {
+    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
@@ -1505,51 +1843,64 @@ class Visit {
     if (this.isSamePage) {
       this.render((async () => {
         this.cacheSnapshot();
+        this.performScroll();
         this.adapter.visitRendered(this);
       }));
     }
   }
-  requestStarted() {
-    this.startRequest();
+  prepareHeadersForRequest(headers, request) {
+    if (this.acceptsStreamResponse) {
+      request.acceptResponseType(StreamMessage.contentType);
+    }
   }
-  requestPreventedHandlingResponse(request, response) {}
+  requestStarted() {
+    this.startRequest();
+  }
+  requestPreventedHandlingResponse(_request, _response) {}
   async requestSucceededWithResponse(request, response) {
     const responseHTML = await response.responseHTML;
+    const {redirected: redirected, statusCode: statusCode} = response;
     if (responseHTML == undefined) {
       this.recordResponse({
-        statusCode: SystemStatusCode.contentTypeMismatch
+        statusCode: SystemStatusCode.contentTypeMismatch,
+        redirected: redirected
       });
     } else {
       this.redirectedToLocation = response.redirected ? response.location : undefined;
       this.recordResponse({
-        statusCode: response.statusCode,
-        responseHTML: responseHTML
+        statusCode: statusCode,
+        responseHTML: responseHTML,
+        redirected: redirected
       });
     }
   }
   async requestFailedWithResponse(request, response) {
     const responseHTML = await response.responseHTML;
+    const {redirected: redirected, statusCode: statusCode} = response;
     if (responseHTML == undefined) {
       this.recordResponse({
-        statusCode: SystemStatusCode.contentTypeMismatch
+        statusCode: SystemStatusCode.contentTypeMismatch,
+        redirected: redirected
       });
     } else {
       this.recordResponse({
-        statusCode: response.statusCode,
-        responseHTML: responseHTML
+        statusCode: statusCode,
+        responseHTML: responseHTML,
+        redirected: redirected
       });
     }
   }
-  requestErrored(request, error) {
+  requestErrored(_request, _error) {
     this.recordResponse({
-      statusCode: SystemStatusCode.networkFailure
+      statusCode: SystemStatusCode.networkFailure,
+      redirected: false
     });
   }
   requestFinished() {
     this.finishRequest();
   }
   performScroll() {
-    if (!this.scrolled) {
+    if (!this.scrolled && !this.view.forceReloaded) {
       if (this.action == "restore") {
         this.scrollToRestoredPosition() || this.scrollToAnchor() || this.view.scrollToTop();
       } else {
@@ -1600,12 +1951,12 @@ class Visit {
     } else if (this.action == "restore") {
       return !this.hasCachedSnapshot();
     } else {
-      return true;
+      return this.willRender;
     }
   }
   cacheSnapshot() {
     if (!this.snapshotCached) {
-      this.view.cacheSnapshot();
+      this.view.cacheSnapshot().then((snapshot => snapshot && this.visitCachedSnapshot(snapshot)));
       this.snapshotCached = true;
     }
   }
@@ -1616,7 +1967,6 @@ class Visit {
     }));
     await callback();
     delete this.frame;
-    this.performScroll();
   }
   cancelRender() {
     if (this.frame) {
@@ -1639,13 +1989,13 @@ class BrowserAdapter {
     this.session = session;
   }
   visitProposedToLocation(location, options) {
-    this.navigator.startVisit(location, uuid(), options);
+    this.navigator.startVisit(location, (options === null || options === void 0 ? void 0 : options.restorationIdentifier) || uuid(), options);
   }
   visitStarted(visit) {
+    this.location = visit.location;
+    visit.loadCachedSnapshot();
     visit.issueRequest();
-    visit.changeHistory();
     visit.goToSamePageAnchor();
-    visit.loadCachedSnapshot();
   }
   visitRequestStarted(visit) {
     this.progressBar.setValue(0);
@@ -1663,27 +2013,32 @@ class BrowserAdapter {
      case SystemStatusCode.networkFailure:
      case SystemStatusCode.timeoutFailure:
      case SystemStatusCode.contentTypeMismatch:
-      return this.reload();
+      return this.reload({
+        reason: "request_failed",
+        context: {
+          statusCode: 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();
   }
@@ -1709,8 +2064,12 @@ class BrowserAdapter {
       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;
@@ -1720,103 +2079,89 @@ class BrowserAdapter {
 class CacheObserver {
   constructor() {
     this.started = false;
-  }
-  start() {
-    if (!this.started) {
-      this.started = true;
-      addEventListener("turbo:before-cache", this.removeStaleElements, false);
-    }
-  }
-  stop() {
-    if (this.started) {
-      this.started = false;
-      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 {
-  constructor(delegate) {
-    this.started = false;
-    this.submitCaptured = () => {
-      removeEventListener("submit", this.submitBubbled, false);
-      addEventListener("submit", this.submitBubbled, false);
-    };
-    this.submitBubbled = event => {
-      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.method;
-          if (method != "dialog" && this.delegate.willSubmitForm(form, submitter)) {
-            event.preventDefault();
-            this.delegate.formSubmitted(form, submitter);
-          }
-        }
+    this.removeStaleElements = _event => {
+      const staleElements = [ ...document.querySelectorAll('[data-turbo-cache="false"]') ];
+      for (const element of staleElements) {
+        element.remove();
       }
     };
-    this.delegate = delegate;
   }
   start() {
     if (!this.started) {
-      addEventListener("submit", this.submitCaptured, true);
       this.started = true;
+      addEventListener("turbo:before-cache", this.removeStaleElements, false);
     }
   }
   stop() {
     if (this.started) {
-      removeEventListener("submit", this.submitCaptured, true);
       this.started = false;
+      removeEventListener("turbo:before-cache", this.removeStaleElements, false);
     }
   }
 }
 
 class FrameRedirector {
-  constructor(element) {
+  constructor(session, element) {
+    this.session = session;
     this.element = element;
-    this.linkInterceptor = new LinkInterceptor(this, element);
-    this.formInterceptor = new FormInterceptor(this, element);
+    this.linkClickObserver = new LinkClickObserver(this, element);
+    this.formSubmitObserver = new FormSubmitObserver(this, element);
   }
   start() {
-    this.linkInterceptor.start();
-    this.formInterceptor.start();
+    this.linkClickObserver.start();
+    this.formSubmitObserver.start();
   }
   stop() {
-    this.linkInterceptor.stop();
-    this.formInterceptor.stop();
+    this.linkClickObserver.stop();
+    this.formSubmitObserver.stop();
   }
-  shouldInterceptLinkClick(element, url) {
-    return this.shouldRedirect(element);
+  willFollowLinkToLocation(element, location, event) {
+    return this.shouldRedirect(element) && this.frameAllowsVisitingLocation(element, location, event);
   }
-  linkClickIntercepted(element, url) {
+  followedLinkToLocation(element, url) {
     const frame = this.findFrameElement(element);
     if (frame) {
-      frame.setAttribute("reloadable", "");
-      frame.src = url;
+      frame.delegate.followedLinkToLocation(element, url);
     }
   }
-  shouldInterceptFormSubmission(element, submitter) {
-    return this.shouldRedirect(element, submitter);
+  willSubmitForm(element, submitter) {
+    return element.closest("turbo-frame") == null && this.shouldSubmit(element, submitter) && this.shouldRedirect(element, submitter);
   }
-  formSubmissionIntercepted(element, submitter) {
-    const frame = this.findFrameElement(element);
+  formSubmitted(element, submitter) {
+    const frame = this.findFrameElement(element, submitter);
     if (frame) {
-      frame.removeAttribute("reloadable");
-      frame.delegate.formSubmissionIntercepted(element, submitter);
+      frame.delegate.formSubmitted(element, submitter);
     }
   }
+  frameAllowsVisitingLocation(target, {href: url}, originalEvent) {
+    const event = dispatch("turbo:click", {
+      target: target,
+      detail: {
+        url: url,
+        originalEvent: originalEvent
+      },
+      cancelable: true
+    });
+    return !event.defaultPrevented;
+  }
+  shouldSubmit(form, submitter) {
+    var _a;
+    const action = getAction(form, submitter);
+    const meta = this.element.ownerDocument.querySelector(`meta[name="turbo-root"]`);
+    const rootLocation = expandURL((_a = meta === null || meta === void 0 ? void 0 : meta.content) !== null && _a !== void 0 ? _a : "/");
+    return this.shouldRedirect(form, submitter) && locationIsVisitable(action, rootLocation);
+  }
   shouldRedirect(element, submitter) {
-    const frame = this.findFrameElement(element);
-    return frame ? frame != element.closest("turbo-frame") : false;
+    const isNavigatable = element instanceof HTMLFormElement ? this.session.submissionIsNavigatable(element, submitter) : this.session.elementIsNavigatable(element);
+    if (isNavigatable) {
+      const frame = this.findFrameElement(element, submitter);
+      return frame ? frame != element.closest("turbo-frame") : false;
+    } else {
+      return false;
+    }
   }
-  findFrameElement(element) {
-    const id = element.getAttribute("data-turbo-frame");
+  findFrameElement(element, submitter) {
+    const id = (submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("data-turbo-frame")) || element.getAttribute("data-turbo-frame");
     if (id && id != "_top") {
       const frame = this.element.querySelector(`#${id}:not([disabled])`);
       if (frame instanceof FrameElement) {
@@ -1843,7 +2188,7 @@ class History {
         }
       }
     };
-    this.onPageLoad = async event => {
+    this.onPageLoad = async _event => {
       await nextMicrotask();
       this.pageLoaded = true;
     };
@@ -1909,67 +2254,21 @@ class History {
   }
 }
 
-class LinkClickObserver {
-  constructor(delegate) {
-    this.started = false;
-    this.clickCaptured = () => {
-      removeEventListener("click", this.clickBubbled, false);
-      addEventListener("click", this.clickBubbled, false);
-    };
-    this.clickBubbled = event => {
-      if (this.clickEventIsSignificant(event)) {
-        const target = event.composedPath && event.composedPath()[0] || event.target;
-        const link = this.findLinkFromClickTarget(target);
-        if (link) {
-          const location = this.getLocationForLink(link);
-          if (this.delegate.willFollowLinkToLocation(link, location)) {
-            event.preventDefault();
-            this.delegate.followedLinkToLocation(link, location);
-          }
-        }
-      }
-    };
-    this.delegate = delegate;
-  }
-  start() {
-    if (!this.started) {
-      addEventListener("click", this.clickCaptured, true);
-      this.started = true;
-    }
-  }
-  stop() {
-    if (this.started) {
-      removeEventListener("click", this.clickCaptured, true);
-      this.started = false;
-    }
-  }
-  clickEventIsSignificant(event) {
-    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) {
-      return target.closest("a[href]:not([target^=_]):not([download])");
-    }
-  }
-  getLocationForLink(link) {
-    return expandURL(link.getAttribute("href") || "");
-  }
-}
-
-function isAction(action) {
-  return action == "advance" || action == "replace" || action == "restore";
-}
-
 class Navigator {
   constructor(delegate) {
     this.delegate = delegate;
   }
   proposeVisit(location, options = {}) {
     if (this.delegate.allowsVisitingLocationWithAction(location, options.action)) {
-      this.delegate.visitProposedToLocation(location, options);
+      if (locationIsVisitable(location, this.view.snapshot.rootLocation)) {
+        this.delegate.visitProposedToLocation(location, options);
+      } else {
+        window.location.href = location.toString();
+      }
     }
   }
   startVisit(locatable, restorationIdentifier, options = {}) {
+    this.lastVisit = this.currentVisit;
     this.stop();
     this.currentVisit = new Visit(this, expandURL(locatable), restorationIdentifier, Object.assign({
       referrer: this.location
@@ -1979,13 +2278,7 @@ class Navigator {
   submitForm(form, submitter) {
     this.stop();
     this.formSubmission = new FormSubmission(this, form, submitter, true);
-    if (this.formSubmission.isIdempotent) {
-      this.proposeVisit(this.formSubmission.fetchRequest.url, {
-        action: this.getActionForFormSubmission(this.formSubmission)
-      });
-    } else {
-      this.formSubmission.start();
-    }
+    this.formSubmission.start();
   }
   stop() {
     if (this.formSubmission) {
@@ -2015,14 +2308,19 @@ class Navigator {
     if (formSubmission == this.formSubmission) {
       const responseHTML = await fetchResponse.responseHTML;
       if (responseHTML) {
-        if (formSubmission.method != FetchMethod.get) {
+        const shouldCacheSnapshot = formSubmission.method == FetchMethod.get;
+        if (!shouldCacheSnapshot) {
           this.view.clearSnapshotCache();
         }
-        const {statusCode: statusCode} = fetchResponse;
+        const {statusCode: statusCode, redirected: redirected} = fetchResponse;
+        const action = this.getActionForFormSubmission(formSubmission);
         const visitOptions = {
+          action: action,
+          shouldCacheSnapshot: shouldCacheSnapshot,
           response: {
             statusCode: statusCode,
-            responseHTML: responseHTML
+            responseHTML: responseHTML,
+            redirected: redirected
           }
         };
         this.proposeVisit(fetchResponse.location, visitOptions);
@@ -2034,9 +2332,9 @@ class Navigator {
     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();
@@ -2057,10 +2355,12 @@ class Navigator {
     this.delegate.visitCompleted(visit);
   }
   locationWithActionIsSamePage(location, action) {
+    var _a;
     const anchor = getAnchor(location);
-    const currentAnchor = getAnchor(this.view.lastRenderedLocation);
+    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(this.view.lastRenderedLocation) && (isRestorationToTop || anchor != null && anchor !== currentAnchor);
+    return action !== "replace" && getRequestURL(location) === getRequestURL(lastLocation) && (isRestorationToTop || anchor != null && anchor !== currentAnchor);
   }
   visitScrolledToSamePageLocation(oldURL, newURL) {
     this.delegate.visitScrolledToSamePageLocation(oldURL, newURL);
@@ -2073,7 +2373,7 @@ class Navigator {
   }
   getActionForFormSubmission(formSubmission) {
     const {formElement: formElement, submitter: submitter} = formSubmission;
-    const action = (submitter === null || submitter === void 0 ? void 0 : submitter.getAttribute("data-turbo-action")) || formElement.getAttribute("data-turbo-action");
+    const action = getAttribute("data-turbo-action", submitter, formElement);
     return isAction(action) ? action : "advance";
   }
 }
@@ -2168,6 +2468,31 @@ class ScrollObserver {
   }
 }
 
+class StreamMessageRenderer {
+  render({fragment: fragment}) {
+    Bardo.preservingPermanentElements(this, getPermanentElementMapForFragment(fragment), (() => document.documentElement.appendChild(fragment)));
+  }
+  enteringBardo(currentPermanentElement, newPermanentElement) {
+    newPermanentElement.replaceWith(currentPermanentElement.cloneNode(true));
+  }
+  leavingBardo() {}
+}
+
+function getPermanentElementMapForFragment(fragment) {
+  const permanentElementsInDocument = queryPermanentElementsAll(document.documentElement);
+  const permanentElementMap = {};
+  for (const permanentElementInDocument of permanentElementsInDocument) {
+    const {id: id} = permanentElementInDocument;
+    for (const streamElement of fragment.querySelectorAll("turbo-stream")) {
+      const elementInStream = getPermanentElementById(streamElement.templateElement.content, id);
+      if (elementInStream) {
+        permanentElementMap[id] = [ permanentElementInDocument, elementInStream ];
+      }
+    }
+  }
+  return permanentElementMap;
+}
+
 class StreamObserver {
   constructor(delegate) {
     this.sources = new Set;
@@ -2220,7 +2545,7 @@ class StreamObserver {
     }
   }
   receiveMessageHTML(html) {
-    this.delegate.receivedMessageFromStream(new StreamMessage(html));
+    this.delegate.receivedMessageFromStream(StreamMessage.wrap(html));
   }
 }
 
@@ -2239,20 +2564,24 @@ function fetchResponseIsStream(response) {
 }
 
 class ErrorRenderer extends Renderer {
+  static renderElement(currentElement, newElement) {
+    const {documentElement: documentElement, body: body} = document;
+    documentElement.replaceChild(newElement, body);
+  }
   async render() {
     this.replaceHeadAndBody();
     this.activateScriptElements();
   }
   replaceHeadAndBody() {
-    const {documentElement: documentElement, head: head, body: body} = document;
+    const {documentElement: documentElement, head: 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) {
       const parentNode = replaceableElement.parentNode;
       if (parentNode) {
-        const element = this.createScriptElement(replaceableElement);
+        const element = activateScriptElement(replaceableElement);
         parentNode.replaceChild(element, replaceableElement);
       }
     }
@@ -2261,19 +2590,40 @@ class ErrorRenderer extends Renderer {
     return this.newSnapshot.headSnapshot.element;
   }
   get scriptElements() {
-    return [ ...document.documentElement.querySelectorAll("script") ];
+    return document.documentElement.querySelectorAll("script");
   }
 }
 
 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;
   }
-  prepareToRender() {
-    this.mergeHead();
+  get reloadReason() {
+    if (!this.newSnapshot.isVisitable) {
+      return {
+        reason: "turbo_visit_control_is_reload"
+      };
+    }
+    if (!this.trackedElementsAreIdentical) {
+      return {
+        reason: "tracked_element_mismatch"
+      };
+    }
+  }
+  async prepareToRender() {
+    await this.mergeHead();
   }
   async render() {
-    this.replaceBody();
+    if (this.willRender) {
+      this.replaceBody();
+    }
   }
   finishRendering() {
     super.finishRendering();
@@ -2290,11 +2640,12 @@ class PageRenderer extends Renderer {
   get newElement() {
     return this.newSnapshot.element;
   }
-  mergeHead() {
-    this.copyNewHeadStylesheetElements();
+  async mergeHead() {
+    const newStylesheetElements = this.copyNewHeadStylesheetElements();
     this.copyNewHeadScriptElements();
     this.removeCurrentHeadProvisionalElements();
     this.copyNewHeadProvisionalElements();
+    await newStylesheetElements;
   }
   replaceBody() {
     this.preservingPermanentElements((() => {
@@ -2305,14 +2656,17 @@ class PageRenderer extends Renderer {
   get trackedElementsAreIdentical() {
     return this.currentHeadSnapshot.trackedElementSignature == this.newHeadSnapshot.trackedElementSignature;
   }
-  copyNewHeadStylesheetElements() {
+  async copyNewHeadStylesheetElements() {
+    const loadingElements = [];
     for (const element of this.newHeadStylesheetElements) {
+      loadingElements.push(waitForLoad(element));
       document.head.appendChild(element);
     }
+    await Promise.all(loadingElements);
   }
   copyNewHeadScriptElements() {
     for (const element of this.newHeadScriptElements) {
-      document.head.appendChild(this.createScriptElement(element));
+      document.head.appendChild(activateScriptElement(element));
     }
   }
   removeCurrentHeadProvisionalElements() {
@@ -2331,16 +2685,12 @@ class PageRenderer extends Renderer {
   }
   activateNewBodyScriptElements() {
     for (const inertScriptElement of this.newBodyScriptElements) {
-      const activatedScriptElement = this.createScriptElement(inertScriptElement);
+      const activatedScriptElement = activateScriptElement(inertScriptElement);
       inertScriptElement.replaceWith(activatedScriptElement);
     }
   }
   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);
@@ -2408,13 +2758,20 @@ class PageView extends View {
     super(...arguments);
     this.snapshotCache = new SnapshotCache(10);
     this.lastRenderedLocation = new URL(location.href);
+    this.forceReloaded = false;
   }
-  renderPage(snapshot, isPreview = false) {
-    const renderer = new PageRenderer(this.snapshot, snapshot, isPreview);
+  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() {
@@ -2425,7 +2782,9 @@ class PageView extends View {
       this.delegate.viewWillCacheSnapshot();
       const {snapshot: snapshot, lastRenderedLocation: location} = this;
       await nextEventLoopTick();
-      this.snapshotCache.put(location, snapshot.clone());
+      const cachedSnapshot = snapshot.clone();
+      this.snapshotCache.put(location, cachedSnapshot);
+      return cachedSnapshot;
     }
   }
   getCachedSnapshotForLocation(location) {
@@ -2439,34 +2798,81 @@ class PageView extends View {
   }
 }
 
+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);
     this.cacheObserver = new CacheObserver;
-    this.linkClickObserver = new LinkClickObserver(this);
-    this.formSubmitObserver = new FormSubmitObserver(this);
+    this.linkClickObserver = new LinkClickObserver(this, window);
+    this.formSubmitObserver = new FormSubmitObserver(this, document);
     this.scrollObserver = new ScrollObserver(this);
     this.streamObserver = new StreamObserver(this);
-    this.frameRedirector = new FrameRedirector(document.documentElement);
+    this.formLinkClickObserver = new FormLinkClickObserver(this, document.documentElement);
+    this.frameRedirector = new FrameRedirector(this, document.documentElement);
+    this.streamMessageRenderer = new StreamMessageRenderer;
     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.formLinkClickObserver.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;
     }
@@ -2478,6 +2884,7 @@ class Session {
     if (this.started) {
       this.pageObserver.stop();
       this.cacheObserver.stop();
+      this.formLinkClickObserver.stop();
       this.linkClickObserver.stop();
       this.formSubmitObserver.stop();
       this.scrollObserver.stop();
@@ -2491,7 +2898,13 @@ class Session {
     this.adapter = adapter;
   }
   visit(location, options = {}) {
-    this.navigator.proposeVisit(expandURL(location), options);
+    const frameElement = options.frame ? document.getElementById(options.frame) : null;
+    if (frameElement instanceof FrameElement) {
+      frameElement.src = location.toString();
+      frameElement.loaded;
+    } else {
+      this.navigator.proposeVisit(expandURL(location), options);
+    }
   }
   connectStreamSource(source) {
     this.streamObserver.connectStreamSource(source);
@@ -2500,7 +2913,7 @@ class Session {
     this.streamObserver.disconnectStreamSource(source);
   }
   renderStreamMessage(message) {
-    document.documentElement.appendChild(StreamMessage.wrap(message).fragment);
+    this.streamMessageRenderer.render(StreamMessage.wrap(message));
   }
   clearCache() {
     this.view.clearSnapshotCache();
@@ -2508,6 +2921,9 @@ class Session {
   setProgressBarDelay(delay) {
     this.progressBarDelay = delay;
   }
+  setFormMode(mode) {
+    this.formMode = mode;
+  }
   get location() {
     return this.history.location;
   }
@@ -2521,7 +2937,9 @@ class Session {
         historyChanged: true
       });
     } else {
-      this.adapter.pageInvalidated();
+      this.adapter.pageInvalidated({
+        reason: "turbo_disabled"
+      });
     }
   }
   scrollPositionChanged(position) {
@@ -2529,30 +2947,21 @@ class Session {
       scrollPosition: position
     });
   }
-  willFollowLinkToLocation(link, location) {
-    return this.elementDriveEnabled(link) && this.locationIsVisitable(location) && this.applicationAllowsFollowingLinkToLocation(link, location);
+  willSubmitFormLinkToLocation(link, location) {
+    return this.elementIsNavigatable(link) && locationIsVisitable(location, this.snapshot.rootLocation);
+  }
+  submittedFormLinkToLocation() {}
+  willFollowLinkToLocation(link, location, event) {
+    return this.elementIsNavigatable(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: action
+    const acceptsStreamResponse = link.hasAttribute("data-turbo-stream");
+    this.visit(location.href, {
+      action: action,
+      acceptsStreamResponse: acceptsStreamResponse
     });
   }
-  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";
-      document.body.appendChild(form);
-      return dispatch("submit", {
-        cancelable: true,
-        target: form
-      });
-    } else {
-      return false;
-    }
-  }
   allowsVisitingLocationWithAction(location, action) {
     return this.locationWithActionIsSamePage(location, action) || this.applicationAllowsVisitingLocation(location);
   }
@@ -2561,12 +2970,16 @@ class Session {
     this.adapter.visitProposedToLocation(location, options);
   }
   visitStarted(visit) {
+    if (!visit.acceptsStreamResponse) {
+      markAsBusy(document.documentElement);
+    }
     extendURLWithDeprecatedProperties(visit.location);
     if (!visit.silent) {
       this.notifyApplicationAfterVisitingLocation(visit.location, visit.action);
     }
   }
   visitCompleted(visit) {
+    clearBusyState(document.documentElement);
     this.notifyApplicationAfterPageLoad(visit.getTimingMetrics());
   }
   locationWithActionIsSamePage(location, action) {
@@ -2576,7 +2989,8 @@ class Session {
     this.notifyApplicationAfterVisitingSamePageLocation(oldURL, newURL);
   }
   willSubmitForm(form, submitter) {
-    return this.elementDriveEnabled(form) && this.elementDriveEnabled(submitter);
+    const action = getAction(form, submitter);
+    return this.submissionIsNavigatable(form, submitter) && locationIsVisitable(expandURL(action), this.snapshot.rootLocation);
   }
   formSubmitted(form, submitter) {
     this.navigator.submitForm(form, submitter);
@@ -2600,16 +3014,23 @@ class Session {
       this.notifyApplicationBeforeCachingSnapshot();
     }
   }
-  allowsImmediateRender({element: element}, resume) {
-    const event = this.notifyApplicationBeforeRender(element, resume);
-    return !event.defaultPrevented;
+  allowsImmediateRender({element: element}, options) {
+    const event = this.notifyApplicationBeforeRender(element, options);
+    const {defaultPrevented: defaultPrevented, detail: {render: 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);
@@ -2617,19 +3038,20 @@ class Session {
   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) {
+  notifyApplicationAfterClickingLinkToLocation(link, location, event) {
     return dispatch("turbo:click", {
       target: link,
       detail: {
-        url: location.href
+        url: location.href,
+        originalEvent: event
       },
       cancelable: true
     });
@@ -2653,12 +3075,11 @@ class Session {
   notifyApplicationBeforeCachingSnapshot() {
     return dispatch("turbo:before-cache");
   }
-  notifyApplicationBeforeRender(newBody, resume) {
+  notifyApplicationBeforeRender(newBody, options) {
     return dispatch("turbo:before-render", {
-      detail: {
-        newBody: newBody,
-        resume: resume
-      },
+      detail: Object.assign({
+        newBody: newBody
+      }, options),
       cancelable: true
     });
   }
@@ -2693,9 +3114,22 @@ class Session {
       cancelable: true
     });
   }
-  elementDriveEnabled(element) {
-    const container = element === null || element === void 0 ? void 0 : element.closest("[data-turbo]");
-    if (this.drive) {
+  submissionIsNavigatable(form, submitter) {
+    if (this.formMode == "off") {
+      return false;
+    } else {
+      const submitterIsNavigatable = submitter ? this.elementIsNavigatable(submitter) : true;
+      if (this.formMode == "optin") {
+        return submitterIsNavigatable && form.closest('[data-turbo="true"]') != null;
+      } else {
+        return submitterIsNavigatable && this.elementIsNavigatable(form);
+      }
+    }
+  }
+  elementIsNavigatable(element) {
+    const container = element.closest("[data-turbo]");
+    const withinFrame = element.closest("turbo-frame");
+    if (this.drive || withinFrame) {
       if (container) {
         return container.getAttribute("data-turbo") != "false";
       } else {
@@ -2713,9 +3147,6 @@ class Session {
     const action = link.getAttribute("data-turbo-action");
     return isAction(action) ? action : "advance";
   }
-  locationIsVisitable(location) {
-    return isPrefixedBy(location, this.snapshot.rootLocation) && isHTML(location);
-  }
   get snapshot() {
     return this.view.snapshot;
   }
@@ -2733,9 +3164,64 @@ const deprecatedLocationPropertyDescriptors = {
   }
 };
 
+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 {navigator: navigator} = session;
+const cache = new Cache(session);
+
+const {navigator: navigator$1} = session;
 
 function start() {
   session.start();
@@ -2762,6 +3248,7 @@ function 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();
 }
 
@@ -2769,12 +3256,22 @@ function setProgressBarDelay(delay) {
   session.setProgressBarDelay(delay);
 }
 
+function setConfirmMethod(confirmMethod) {
+  FormSubmission.confirmMethod = confirmMethod;
+}
+
+function setFormMode(mode) {
+  session.setFormMode(mode);
+}
+
 var Turbo = Object.freeze({
   __proto__: null,
-  navigator: navigator,
+  navigator: navigator$1,
   session: session,
+  cache: cache,
   PageRenderer: PageRenderer,
   PageSnapshot: PageSnapshot,
+  FrameRenderer: FrameRenderer,
   start: start,
   registerAdapter: registerAdapter,
   visit: visit,
@@ -2782,39 +3279,56 @@ var Turbo = Object.freeze({
   disconnectStreamSource: disconnectStreamSource,
   renderStreamMessage: renderStreamMessage,
   clearCache: clearCache,
-  setProgressBarDelay: setProgressBarDelay
+  setProgressBarDelay: setProgressBarDelay,
+  setConfirmMethod: setConfirmMethod,
+  setFormMode: setFormMode,
+  StreamActions: StreamActions
 });
 
 class FrameController {
   constructor(element) {
+    this.fetchResponseLoaded = _fetchResponse => {};
+    this.currentFetchRequest = null;
     this.resolveVisitPromise = () => {};
     this.connected = false;
     this.hasBeenLoaded = false;
-    this.settingSourceURL = false;
+    this.ignoredAttributes = new Set;
+    this.action = null;
+    this.visitCachedSnapshot = ({element: 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.linkInterceptor = new LinkInterceptor(this, this.element);
-    this.formInterceptor = new FormInterceptor(this, this.element);
+    this.formLinkClickObserver = new FormLinkClickObserver(this, this.element);
+    this.linkClickObserver = new LinkClickObserver(this, this.element);
+    this.restorationIdentifier = uuid();
+    this.formSubmitObserver = new FormSubmitObserver(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.linkInterceptor.start();
-      this.formInterceptor.start();
-      this.sourceURLChanged();
+      this.formLinkClickObserver.start();
+      this.linkClickObserver.start();
+      this.formSubmitObserver.start();
     }
   }
   disconnect() {
     if (this.connected) {
       this.connected = false;
       this.appearanceObserver.stop();
-      this.linkInterceptor.stop();
-      this.formInterceptor.stop();
+      this.formLinkClickObserver.stop();
+      this.linkClickObserver.stop();
+      this.formSubmitObserver.stop();
     }
   }
   disabledChanged() {
@@ -2823,10 +3337,18 @@ class FrameController {
     }
   }
   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();
@@ -2836,103 +3358,107 @@ class FrameController {
     }
   }
   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;
-          session.frameLoaded(this.element);
-        } 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) {
-    if (fetchResponse.redirected) {
+    if (fetchResponse.redirected || fetchResponse.succeeded && fetchResponse.isHTML) {
       this.sourceURL = fetchResponse.response.url;
     }
     try {
       const html = await fetchResponse.responseHTML;
       if (html) {
         const {body: body} = parseHTMLDocument(html);
-        const snapshot = new Snapshot(await this.extractForeignFrameElement(body));
-        const renderer = new FrameRenderer(this.view.snapshot, snapshot, false);
-        if (this.view.renderPromise) await this.view.renderPromise;
-        await this.view.render(renderer);
-        session.frameRendered(fetchResponse, this.element);
+        const newFrameElement = await this.extractForeignFrameElement(body);
+        if (newFrameElement) {
+          const snapshot = new Snapshot(newFrameElement);
+          const renderer = new FrameRenderer(this, this.view.snapshot, snapshot, FrameRenderer.renderElement, false, false);
+          if (this.view.renderPromise) await this.view.renderPromise;
+          this.changeHistory();
+          await this.view.render(renderer);
+          this.complete = true;
+          session.frameRendered(fetchResponse, this.element);
+          session.frameLoaded(this.element);
+          this.fetchResponseLoaded(fetchResponse);
+        } else if (this.willHandleFrameMissingFromResponse(fetchResponse)) {
+          console.warn(`A matching frame for #${this.element.id} was missing from the response, transforming into full-page Visit.`);
+          this.visitResponse(fetchResponse.response);
+        }
       }
     } catch (error) {
       console.error(error);
       this.view.invalidate();
+    } finally {
+      this.fetchResponseLoaded = () => {};
     }
   }
-  elementAppearedInViewport(element) {
+  elementAppearedInViewport(_element) {
     this.loadSourceURL();
   }
-  shouldInterceptLinkClick(element, url) {
-    if (element.hasAttribute("data-turbo-method")) {
-      return false;
-    } else {
-      return this.shouldInterceptNavigation(element);
-    }
+  willSubmitFormLinkToLocation(link) {
+    return link.closest("turbo-frame") == this.element && this.shouldInterceptNavigation(link);
+  }
+  submittedFormLinkToLocation(link, _location, form) {
+    const frame = this.findFrameElement(link);
+    if (frame) form.setAttribute("data-turbo-frame", frame.id);
+  }
+  willFollowLinkToLocation(element, location, event) {
+    return this.shouldInterceptNavigation(element) && this.frameAllowsVisitingLocation(element, location, event);
   }
-  linkClickIntercepted(element, url) {
-    this.reloadable = true;
-    this.navigateFrame(element, url);
+  followedLinkToLocation(element, location) {
+    this.navigateFrame(element, location.href);
   }
-  shouldInterceptFormSubmission(element, submitter) {
-    return this.shouldInterceptNavigation(element, submitter);
+  willSubmitForm(element, submitter) {
+    return element.closest("turbo-frame") == this.element && this.shouldInterceptNavigation(element, submitter);
   }
-  formSubmissionIntercepted(element, submitter) {
+  formSubmitted(element, submitter) {
     if (this.formSubmission) {
       this.formSubmission.stop();
     }
-    this.reloadable = false;
     this.formSubmission = new FormSubmission(this, element, submitter);
-    if (this.formSubmission.fetchRequest.isIdempotent) {
-      this.navigateFrame(element, this.formSubmission.fetchRequest.url.href);
-    } else {
-      const {fetchRequest: fetchRequest} = this.formSubmission;
-      this.prepareHeadersForRequest(fetchRequest.headers, fetchRequest);
-      this.formSubmission.start();
-    }
+    const {fetchRequest: fetchRequest} = this.formSubmission;
+    this.prepareHeadersForRequest(fetchRequest.headers, fetchRequest);
+    this.formSubmission.start();
   }
   prepareHeadersForRequest(headers, request) {
+    var _a;
     headers["Turbo-Frame"] = this.id;
+    if ((_a = this.currentNavigationElement) === null || _a === void 0 ? void 0 : _a.hasAttribute("data-turbo-stream")) {
+      request.acceptResponseType(StreamMessage.contentType);
+    }
   }
-  requestStarted(request) {
-    this.element.setAttribute("busy", "");
+  requestStarted(_request) {
+    markAsBusy(this.element);
   }
-  requestPreventedHandlingResponse(request, response) {
+  requestPreventedHandlingResponse(_request, _response) {
     this.resolveVisitPromise();
   }
   async requestSucceededWithResponse(request, response) {
     await this.loadResponse(response);
     this.resolveVisitPromise();
   }
-  requestFailedWithResponse(request, response) {
+  async requestFailedWithResponse(request, response) {
     console.error(response);
+    await this.loadResponse(response);
     this.resolveVisitPromise();
   }
   requestErrored(request, error) {
     console.error(error);
     this.resolveVisitPromise();
   }
-  requestFinished(request) {
-    this.element.removeAttribute("busy");
+  requestFinished(_request) {
+    clearBusyState(this.element);
   }
-  formSubmissionStarted(formSubmission) {
-    const frame = this.findFrameElement(formSubmission.formElement);
-    frame.setAttribute("busy", "");
+  formSubmissionStarted({formElement: formElement}) {
+    markAsBusy(formElement, this.findFrameElement(formElement));
   }
   formSubmissionSucceededWithResponse(formSubmission, response) {
-    const frame = this.findFrameElement(formSubmission.formElement);
+    const frame = this.findFrameElement(formSubmission.formElement, formSubmission.submitter);
+    this.proposeVisitIfNavigatedWithAction(frame, formSubmission.formElement, formSubmission.submitter);
     frame.delegate.loadResponse(response);
   }
   formSubmissionFailedWithResponse(formSubmission, fetchResponse) {
@@ -2941,53 +3467,150 @@ class FrameController {
   formSubmissionErrored(formSubmission, error) {
     console.error(error);
   }
-  formSubmissionFinished(formSubmission) {
-    const frame = this.findFrameElement(formSubmission.formElement);
-    frame.removeAttribute("busy");
+  formSubmissionFinished({formElement: 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: newFrame
+      }, options),
+      cancelable: true
+    });
+    const {defaultPrevented: defaultPrevented, detail: {render: render}} = event;
+    if (this.view.renderer && render) {
+      this.view.renderer.renderElement = render;
+    }
+    return !defaultPrevented;
+  }
+  viewRenderedSnapshot(_snapshot, _isPreview) {}
+  preloadOnLoadLinksForView(element) {
+    session.preloadOnLoadLinksForView(element);
   }
-  viewRenderedSnapshot(snapshot, isPreview) {}
   viewInvalidated() {}
+  willRenderFrame(currentElement, _newElement) {
+    this.previousFrameElement = currentElement.cloneNode(true);
+  }
   async visit(url) {
-    const request = new FetchRequest(this, FetchMethod.get, expandURL(url));
+    var _a;
+    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 => {
       this.resolveVisitPromise = () => {
         this.resolveVisitPromise = () => {};
+        this.currentFetchRequest = null;
         resolve();
       };
       request.perform();
     }));
   }
-  navigateFrame(element, url) {
-    const frame = this.findFrameElement(element);
-    frame.src = url;
+  navigateFrame(element, url, submitter) {
+    const frame = this.findFrameElement(element, submitter);
+    this.proposeVisitIfNavigatedWithAction(frame, element, submitter);
+    this.withCurrentNavigationElement(element, (() => {
+      frame.src = url;
+    }));
+  }
+  proposeVisitIfNavigatedWithAction(frame, element, submitter) {
+    this.action = getVisitAction(submitter, element, frame);
+    this.frame = frame;
+    if (isAction(this.action)) {
+      const {visitCachedSnapshot: visitCachedSnapshot} = frame.delegate;
+      frame.delegate.fetchResponseLoaded = fetchResponse => {
+        if (frame.src) {
+          const {statusCode: statusCode, redirected: redirected} = fetchResponse;
+          const responseHTML = frame.ownerDocument.documentElement.outerHTML;
+          const response = {
+            statusCode: statusCode,
+            redirected: redirected,
+            responseHTML: responseHTML
+          };
+          const options = {
+            response: response,
+            visitCachedSnapshot: visitCachedSnapshot,
+            willRender: false,
+            updateHistory: false,
+            restorationIdentifier: this.restorationIdentifier
+          };
+          if (this.action) options.action = this.action;
+          session.visit(frame.src, options);
+        }
+      };
+    }
+  }
+  changeHistory() {
+    if (this.action && this.frame) {
+      const method = getHistoryMethodForAction(this.action);
+      session.history.update(method, expandURL(this.frame.src || ""), this.restorationIdentifier);
+    }
+  }
+  willHandleFrameMissingFromResponse(fetchResponse) {
+    this.element.setAttribute("complete", "");
+    const response = fetchResponse.response;
+    const visit = async (url, options = {}) => {
+      if (url instanceof Response) {
+        this.visitResponse(url);
+      } else {
+        session.visit(url, options);
+      }
+    };
+    const event = dispatch("turbo:frame-missing", {
+      target: this.element,
+      detail: {
+        response: response,
+        visit: visit
+      },
+      cancelable: true
+    });
+    return !event.defaultPrevented;
+  }
+  async visitResponse(response) {
+    const wrapped = new FetchResponse(response);
+    const responseHTML = await wrapped.responseHTML;
+    const {location: location, redirected: redirected, statusCode: statusCode} = wrapped;
+    return session.visit(location, {
+      response: {
+        redirected: redirected,
+        statusCode: statusCode,
+        responseHTML: responseHTML
+      }
+    });
   }
-  findFrameElement(element) {
+  findFrameElement(element, submitter) {
     var _a;
-    const id = element.getAttribute("data-turbo-frame") || this.element.getAttribute("target");
+    const id = getAttribute("data-turbo-frame", submitter, element) || this.element.getAttribute("target");
     return (_a = getFrameElementById(id)) !== null && _a !== void 0 ? _a : this.element;
   }
   async extractForeignFrameElement(container) {
     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);
       }
-      console.error(`Response has no matching <turbo-frame id="${id}"> element`);
     } catch (error) {
       console.error(error);
+      return new FrameElement;
     }
-    return new FrameElement;
+    return null;
+  }
+  formActionIsVisitable(form, submitter) {
+    const action = getAction(form, submitter);
+    return locationIsVisitable(expandURL(action), this.rootLocation);
   }
   shouldInterceptNavigation(element, submitter) {
-    const id = element.getAttribute("data-turbo-frame") || this.element.getAttribute("target");
+    const id = getAttribute("data-turbo-frame", submitter, element) || this.element.getAttribute("target");
+    if (element instanceof HTMLFormElement && !this.formActionIsVisitable(element, submitter)) {
+      return false;
+    }
     if (!this.enabled || id == "_top") {
       return false;
     }
@@ -2997,10 +3620,10 @@ class FrameController {
         return !frameElement.disabled;
       }
     }
-    if (!session.elementDriveEnabled(element)) {
+    if (!session.elementIsNavigatable(element)) {
       return false;
     }
-    if (submitter && !session.elementDriveEnabled(submitter)) {
+    if (submitter && !session.elementIsNavigatable(submitter)) {
       return false;
     }
     return true;
@@ -3016,23 +3639,10 @@ class FrameController {
       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;
@@ -3040,9 +3650,51 @@ class FrameController {
   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;
   }
+  get rootLocation() {
+    var _a;
+    const meta = this.element.ownerDocument.querySelector(`meta[name="turbo-root"]`);
+    const root = (_a = meta === null || meta === void 0 ? void 0 : meta.content) !== null && _a !== void 0 ? _a : "/";
+    return expandURL(root);
+  }
+  frameAllowsVisitingLocation(target, {href: url}, originalEvent) {
+    const event = dispatch("turbo:click", {
+      target: target,
+      detail: {
+        url: url,
+        originalEvent: originalEvent
+      },
+      cancelable: true
+    });
+    return !event.defaultPrevented;
+  }
+  isIgnoringChangesTo(attributeName) {
+    return this.ignoredAttributes.has(attributeName);
+  }
+  ignoringChangesToAttribute(attributeName, callback) {
+    this.ignoredAttributes.add(attributeName);
+    callback();
+    this.ignoredAttributes.delete(attributeName);
+  }
+  withCurrentNavigationElement(element, callback) {
+    this.currentNavigationElement = element;
+    callback();
+    delete this.currentNavigationElement;
+  }
 }
 
 function getFrameElementById(id) {
@@ -3065,47 +3717,16 @@ function activateElement(element, currentURL) {
     }
     if (element instanceof FrameElement) {
       element.connectedCallback();
+      element.disconnectedCallback();
       return element;
     }
   }
 }
 
-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 {
+  static async renderElement(newElement) {
+    await newElement.performAction();
+  }
   async connectedCallback() {
     try {
       await this.render();
@@ -3118,9 +3739,10 @@ class StreamElement extends HTMLElement {
   async render() {
     var _a;
     return (_a = this.renderPromise) !== null && _a !== void 0 ? _a : this.renderPromise = (async () => {
-      if (this.dispatchEvent(this.beforeRenderEvent)) {
+      const event = this.beforeRenderEvent;
+      if (this.dispatchEvent(event)) {
         await nextAnimationFrame();
-        this.performAction();
+        await event.detail.render(this);
       }
     })();
   }
@@ -3135,7 +3757,7 @@ class StreamElement extends HTMLElement {
   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));
+    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() {
@@ -3161,7 +3783,11 @@ class StreamElement extends HTMLElement {
     return this.templateElement.content.cloneNode(true);
   }
   get templateElement() {
-    if (this.firstElementChild instanceof HTMLTemplateElement) {
+    if (this.firstElementChild === null) {
+      const template = this.ownerDocument.createElement("template");
+      this.appendChild(template);
+      return template;
+    } else if (this.firstElementChild instanceof HTMLTemplateElement) {
       return this.firstElementChild;
     }
     this.raise("first child element must be a <template> element");
@@ -3185,7 +3811,11 @@ class StreamElement extends HTMLElement {
   get beforeRenderEvent() {
     return new CustomEvent("turbo:before-stream-render", {
       bubbles: true,
-      cancelable: true
+      cancelable: true,
+      detail: {
+        newStream: this,
+        render: StreamElement.renderElement
+      }
     });
   }
   get targetElementsById() {
@@ -3208,17 +3838,45 @@ class StreamElement extends HTMLElement {
   }
 }
 
+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);
+if (customElements.get("turbo-frame") === undefined) {
+  customElements.define("turbo-frame", FrameElement);
+}
 
-customElements.define("turbo-stream", StreamElement);
+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;
   if (!element) 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!
@@ -3231,6 +3889,7 @@ customElements.define("turbo-stream", StreamElement);
         Suppress this warning by adding a "data-turbo-suppress-warning" attribute to: %s
       `, element.outerHTML);
     }
+    element = element.parentElement;
   }
 })();
 
@@ -3240,15 +3899,26 @@ start();
 
 var turbo_es2017Esm = Object.freeze({
   __proto__: null,
+  FrameElement: FrameElement,
+  get FrameLoadingStyle() {
+    return FrameLoadingStyle;
+  },
+  FrameRenderer: FrameRenderer,
   PageRenderer: PageRenderer,
   PageSnapshot: PageSnapshot,
+  StreamActions: StreamActions,
+  StreamElement: StreamElement,
+  StreamSourceElement: StreamSourceElement,
+  cache: cache,
   clearCache: clearCache,
   connectStreamSource: connectStreamSource,
   disconnectStreamSource: disconnectStreamSource,
-  navigator: navigator,
+  navigator: navigator$1,
   registerAdapter: registerAdapter,
   renderStreamMessage: renderStreamMessage,
   session: session,
+  setConfirmMethod: setConfirmMethod,
+  setFormMode: setFormMode,
   setProgressBarDelay: setProgressBarDelay,
   start: start,
   visit: visit
@@ -3284,6 +3954,19 @@ var cable = Object.freeze({
   subscribeTo: subscribeTo
 });
 
+function walk(obj) {
+  if (!obj || typeof obj !== "object") return obj;
+  if (obj instanceof Date || obj instanceof RegExp) return obj;
+  if (Array.isArray(obj)) return obj.map(walk);
+  return Object.keys(obj).reduce((function(acc, key) {
+    var camel = key[0].toLowerCase() + key.slice(1).replace(/([A-Z]+)/g, (function(m, x) {
+      return "_" + x.toLowerCase();
+    }));
+    acc[camel] = walk(obj[key]);
+    return acc;
+  }), {});
+}
+
 class TurboCableStreamSourceElement extends HTMLElement {
   async connectedCallback() {
     connectStreamSource(this);
@@ -3306,13 +3989,37 @@ class TurboCableStreamSourceElement extends HTMLElement {
     const signed_stream_name = this.getAttribute("signed-stream-name");
     return {
       channel: channel,
-      signed_stream_name: signed_stream_name
+      signed_stream_name: signed_stream_name,
+      ...walk({
+        ...this.dataset
+      })
     };
   }
 }
 
 customElements.define("turbo-cable-stream-source", TurboCableStreamSourceElement);
 
+function encodeMethodIntoRequestBody(event) {
+  if (event.target instanceof HTMLFormElement) {
+    const {target: form, detail: {fetchOptions: fetchOptions}} = event;
+    form.addEventListener("turbo:submit-start", (({detail: {formSubmission: {submitter: submitter}}}) => {
+      const method = submitter && submitter.formMethod || fetchOptions.body && fetchOptions.body.get("_method") || form.getAttribute("method");
+      if (!/get/i.test(method)) {
+        if (/post/i.test(method)) {
+          fetchOptions.body.delete("_method");
+        } else {
+          fetchOptions.body.set("_method", method);
+        }
+        fetchOptions.method = "post";
+      }
+    }), {
+      once: true
+    });
+  }
+}
+
+addEventListener("turbo:before-fetch-request", encodeMethodIntoRequestBody);
+
 var adapters = {
   logger: self.console,
   WebSocket: self.WebSocket
@@ -3331,8 +4038,6 @@ const now = () => (new Date).getTime();
 
 const secondsSince = time => (now() - time) / 1e3;
 
-const clamp = (number, min, max) => Math.max(min, Math.min(max, number));
-
 class ConnectionMonitor {
   constructor(connection) {
     this.visibilityDidChange = this.visibilityDidChange.bind(this);
@@ -3345,7 +4050,7 @@ class ConnectionMonitor {
       delete this.stoppedAt;
       this.startPolling();
       addEventListener("visibilitychange", this.visibilityDidChange);
-      logger.log(`ConnectionMonitor started. pollInterval = ${this.getPollInterval()} ms`);
+      logger.log(`ConnectionMonitor started. stale threshold = ${this.constructor.staleThreshold} s`);
     }
   }
   stop() {
@@ -3386,24 +4091,29 @@ class ConnectionMonitor {
     }), this.getPollInterval());
   }
   getPollInterval() {
-    const {min: min, max: max, multiplier: multiplier} = this.constructor.pollInterval;
-    const interval = multiplier * Math.log(this.reconnectAttempts + 1);
-    return Math.round(clamp(interval, min, max) * 1e3);
+    const {staleThreshold: staleThreshold, reconnectionBackoffRate: reconnectionBackoffRate} = this.constructor;
+    const backoff = Math.pow(1 + reconnectionBackoffRate, Math.min(this.reconnectAttempts, 10));
+    const jitterMax = this.reconnectAttempts === 0 ? 1 : reconnectionBackoffRate;
+    const jitter = jitterMax * Math.random();
+    return staleThreshold * 1e3 * backoff * (1 + jitter);
   }
   reconnectIfStale() {
     if (this.connectionIsStale()) {
-      logger.log(`ConnectionMonitor detected stale connection. reconnectAttempts = ${this.reconnectAttempts}, pollInterval = ${this.getPollInterval()} ms, time disconnected = ${secondsSince(this.disconnectedAt)} s, stale threshold = ${this.constructor.staleThreshold} s`);
+      logger.log(`ConnectionMonitor detected stale connection. reconnectAttempts = ${this.reconnectAttempts}, time stale = ${secondsSince(this.refreshedAt)} s, stale threshold = ${this.constructor.staleThreshold} s`);
       this.reconnectAttempts++;
       if (this.disconnectedRecently()) {
-        logger.log("ConnectionMonitor skipping reopening recent disconnect");
+        logger.log(`ConnectionMonitor skipping reopening recent disconnect. time disconnected = ${secondsSince(this.disconnectedAt)} s`);
       } else {
         logger.log("ConnectionMonitor reopening");
         this.connection.reopen();
       }
     }
   }
+  get refreshedAt() {
+    return this.pingedAt ? this.pingedAt : this.startedAt;
+  }
   connectionIsStale() {
-    return secondsSince(this.pingedAt ? this.pingedAt : this.startedAt) > this.constructor.staleThreshold;
+    return secondsSince(this.refreshedAt) > this.constructor.staleThreshold;
   }
   disconnectedRecently() {
     return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;
@@ -3420,14 +4130,10 @@ class ConnectionMonitor {
   }
 }
 
-ConnectionMonitor.pollInterval = {
-  min: 3,
-  max: 30,
-  multiplier: 5
-};
-
 ConnectionMonitor.staleThreshold = 6;
 
+ConnectionMonitor.reconnectionBackoffRate = .15;
+
 var INTERNAL = {
   message_types: {
     welcome: "welcome",
@@ -3570,6 +4276,7 @@ Connection.prototype.events = {
       return this.monitor.recordPing();
 
      case message_types.confirmation:
+      this.subscriptions.confirmSubscription(identifier);
       return this.subscriptions.notify(identifier, "connected");
 
      case message_types.rejection:
@@ -3637,9 +4344,47 @@ class Subscription {
   }
 }
 
+class SubscriptionGuarantor {
+  constructor(subscriptions) {
+    this.subscriptions = subscriptions;
+    this.pendingSubscriptions = [];
+  }
+  guarantee(subscription) {
+    if (this.pendingSubscriptions.indexOf(subscription) == -1) {
+      logger.log(`SubscriptionGuarantor guaranteeing ${subscription.identifier}`);
+      this.pendingSubscriptions.push(subscription);
+    } else {
+      logger.log(`SubscriptionGuarantor already guaranteeing ${subscription.identifier}`);
+    }
+    this.startGuaranteeing();
+  }
+  forget(subscription) {
+    logger.log(`SubscriptionGuarantor forgetting ${subscription.identifier}`);
+    this.pendingSubscriptions = this.pendingSubscriptions.filter((s => s !== subscription));
+  }
+  startGuaranteeing() {
+    this.stopGuaranteeing();
+    this.retrySubscribing();
+  }
+  stopGuaranteeing() {
+    clearTimeout(this.retryTimeout);
+  }
+  retrySubscribing() {
+    this.retryTimeout = setTimeout((() => {
+      if (this.subscriptions && typeof this.subscriptions.subscribe === "function") {
+        this.pendingSubscriptions.map((subscription => {
+          logger.log(`SubscriptionGuarantor resubscribing ${subscription.identifier}`);
+          this.subscriptions.subscribe(subscription);
+        }));
+      }
+    }), 500);
+  }
+}
+
 class Subscriptions {
   constructor(consumer) {
     this.consumer = consumer;
+    this.guarantor = new SubscriptionGuarantor(this);
     this.subscriptions = [];
   }
   create(channelName, mixin) {
@@ -3654,7 +4399,7 @@ class Subscriptions {
     this.subscriptions.push(subscription);
     this.consumer.ensureActiveConnection();
     this.notify(subscription, "initialized");
-    this.sendCommand(subscription, "subscribe");
+    this.subscribe(subscription);
     return subscription;
   }
   remove(subscription) {
@@ -3672,6 +4417,7 @@ class Subscriptions {
     }));
   }
   forget(subscription) {
+    this.guarantor.forget(subscription);
     this.subscriptions = this.subscriptions.filter((s => s !== subscription));
     return subscription;
   }
@@ -3679,7 +4425,7 @@ class Subscriptions {
     return this.subscriptions.filter((s => s.identifier === identifier));
   }
   reload() {
-    return this.subscriptions.map((subscription => this.sendCommand(subscription, "subscribe")));
+    return this.subscriptions.map((subscription => this.subscribe(subscription)));
   }
   notifyAll(callbackName, ...args) {
     return this.subscriptions.map((subscription => this.notify(subscription, callbackName, ...args)));
@@ -3693,6 +4439,15 @@ class Subscriptions {
     }
     return subscriptions.map((subscription => typeof subscription[callbackName] === "function" ? subscription[callbackName](...args) : undefined));
   }
+  subscribe(subscription) {
+    if (this.sendCommand(subscription, "subscribe")) {
+      this.guarantor.guarantee(subscription);
+    }
+  }
+  confirmSubscription(identifier) {
+    logger.log(`Subscription confirmed ${identifier}`);
+    this.findAll(identifier).map((subscription => this.guarantor.forget(subscription)));
+  }
   sendCommand(subscription, command) {
     const {identifier: identifier} = subscription;
     return this.consumer.send({
@@ -3763,6 +4518,7 @@ var index = Object.freeze({
   INTERNAL: INTERNAL,
   Subscription: Subscription,
   Subscriptions: Subscriptions,
+  SubscriptionGuarantor: SubscriptionGuarantor,
   adapters: adapters,
   createWebSocketURL: createWebSocketURL,
   logger: logger,