turbo-rails 0.5.7 → 0.5.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bde12fe28a415f37f7000160bfe9577c066d0a450b2a8b3a072acb11a620f229
-  data.tar.gz: 06e64c67ade4fa00e7ba13eabf31e3f78fef72e8e9faedd66861b0d370c9e94e
+  metadata.gz: 27a0cac6803a0e1e410fb4fce4aaa60a0998aee4dec7d1b4b4cbb674533ce5cf
+  data.tar.gz: a4a67e8cff6989445d669cd6aa3b64b39dfc7de4ca7afdfddfd41c1e9334558e
 SHA512:
-  metadata.gz: d18cfb444d1511997d07d15e6696ef4a22dafef448ddbe21b0037c60c1b565ab4a24a623393dd9dbadb8685336f0fd6487d0350d4895d336b041b5d07bca7f66
-  data.tar.gz: 1e094bc98631469c394117c65f8e73387c577c4d3e1fdfa329c9bf5ef3f5fd62ea7ba0a4efc394f8696e087f8f06c8870e7fe1ab4066bbe1049f659f22aa8163
+  metadata.gz: a2de3cde68a13beffda32366c8b209666b1bae8a8dc3423ed9f5645dcae00fe88ba9f8ff08582eb60c9212a209d24683adf14f220a670923eac6806268198583
+  data.tar.gz: be9f2251ca7bf7684d71ecfba9cbaaefbc64423d1b7f86428fc733facc9e1867ff6b54df1c756cc96ce0367ffe2cbb090af2bbf3319d432d88fbae005a3edd7b

data/README.md

@@ -40,13 +40,12 @@ The JavaScript for Turbo can either be run through the asset pipeline, which is
 
 Running `turbo:install` will install through NPM if Webpacker is installed in the application. Otherwise the asset pipeline version is used.
 
-If you're using Webpack and need to use either the cable consumer or the Turbo instance, you can import [`Turbo`](https://turbo.hotwire.dev/reference/drive) and/or [`cable`](https://github.com/hotwired/turbo-rails/blob/main/app/javascript/turbo/cable.js) (`import { Turbo, cable } from "@hotwired/turbo-rails"`), but ensure that your application actually *uses* the members it `import`s when using this style (see [turbo-rails#48](https://github.com/hotwired/turbo-rails/issues/48)).
+If you're using Webpack and need to use the cable consumer, you can import [`cable`](https://github.com/hotwired/turbo-rails/blob/main/app/javascript/turbo/cable.js) (`import { cable } from "@hotwired/turbo-rails"`), but ensure that your application actually *uses* the members it `import`s when using this style (see [turbo-rails#48](https://github.com/hotwired/turbo-rails/issues/48)).
 
-If you're using a [native adapter](https://turbo.hotwire.dev/handbook/native), you'll need to assign `window.Turbo`, even if it's not used for anything else:
+The `Turbo` instance is automatically assigned to `window.Turbo` upon import:
 
 ```js
-import { Turbo } from "@hotwired/turbo-rails"
-window.Turbo = Turbo
+import "@hotwired/turbo-rails"
 ```
 
 ## Usage
@@ -56,11 +55,7 @@ You can watch [the video introduction to Hotwire](https://hotwire.dev/#screencas
 
 ## Compatibility with Rails UJS
 
-Rails UJS includes helpers for sending links and forms over XMLHttpRequest, so you can respond with Ajax. Turbo supersedes this functionality, so you should ensure that you're either running Rails 6.1 with the defaults that turn this off for forms, or that you add `config.action_view.form_with_generates_remote_forms = false` to your `config/application.rb`.
-
-Note that the helpers that turn `link_to` into remote invocations will _not_ currently work with Turbo. Links that have been made remote will not stick within frames nor will they allow you to respond with turbo stream actions. The recommendation is to replace these links with styled `button_to`, so you'll flow through a regular form, and you'll be better off with a11y compliance.
-
-You can still use the `data-confirm` and `data-disable-with`.
+Turbo can coexist with Rails UJS, but you need to take a series of ugprade steps to make it happen. See [the upgrading guide](https://github.com/hotwired/turbo-rails/blob/main/UPGRADING.md).
 
 
 ## Development

data/Rakefile

@@ -2,6 +2,10 @@ require "bundler/setup"
 require "bundler/gem_tasks"
 require "rake/testtask"
 
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+load "rails/tasks/statistics.rake"
+
 Rake::TestTask.new do |test|
   test.libs << "test"
   test.test_files = FileList["test/**/*_test.rb"]

data/app/assets/javascripts/turbo.js

@@ -55,7 +55,7 @@ class FrameElement extends HTMLElement {
     this.delegate = new FrameElement.delegateConstructor(this);
   }
   static get observedAttributes() {
-    return [ "loading", "src" ];
+    return [ "disabled", "loading", "src" ];
   }
   connectedCallback() {
     this.delegate.connect();
@@ -68,6 +68,8 @@ class FrameElement extends HTMLElement {
       this.delegate.loadingStyleChanged();
     } else if (name == "src") {
       this.delegate.sourceURLChanged();
+    } else {
+      this.delegate.disabledChanged();
     }
   }
   get src() {
@@ -132,82 +134,61 @@ function frameLoadingStyleFromString(style) {
   }
 }
 
-class Location {
-  constructor(url) {
-    const linkWithAnchor = document.createElement("a");
-    linkWithAnchor.href = url;
-    this.absoluteURL = linkWithAnchor.href;
-    const anchorLength = linkWithAnchor.hash.length;
-    if (anchorLength < 2) {
-      this.requestURL = this.absoluteURL;
-    } else {
-      this.requestURL = this.absoluteURL.slice(0, -anchorLength);
-      this.anchor = linkWithAnchor.hash.slice(1);
-    }
-  }
-  static get currentLocation() {
-    return this.wrap(window.location.toString());
-  }
-  static wrap(locatable) {
-    if (typeof locatable == "string") {
-      return new this(locatable);
-    } else if (locatable != null) {
-      return locatable;
-    }
-  }
-  getOrigin() {
-    return this.absoluteURL.split("/", 3).join("/");
-  }
-  getPath() {
-    return (this.requestURL.match(/\/\/[^/]*(\/[^?;]*)/) || [])[1] || "/";
-  }
-  getPathComponents() {
-    return this.getPath().split("/").slice(1);
-  }
-  getLastPathComponent() {
-    return this.getPathComponents().slice(-1)[0];
-  }
-  getExtension() {
-    return (this.getLastPathComponent().match(/\.[^.]*$/) || [])[0] || "";
-  }
-  isHTML() {
-    return !!this.getExtension().match(/^(?:|\.(?:htm|html|xhtml))$/);
-  }
-  isPrefixedBy(location) {
-    const prefixURL = getPrefixURL(location);
-    return this.isEqualTo(location) || stringStartsWith(this.absoluteURL, prefixURL);
-  }
-  isEqualTo(location) {
-    return location && this.absoluteURL === location.absoluteURL;
-  }
-  toCacheKey() {
-    return this.requestURL;
-  }
-  toJSON() {
-    return this.absoluteURL;
-  }
-  toString() {
-    return this.absoluteURL;
+function expandURL(locatable) {
+  return new URL(locatable.toString(), document.baseURI);
+}
+
+function getAnchor(url) {
+  let anchorMatch;
+  if (url.hash) {
+    return url.hash.slice(1);
+  } else if (anchorMatch = url.href.match(/#(.*)$/)) {
+    return anchorMatch[1];
+  } else {
+    return "";
   }
-  valueOf() {
-    return this.absoluteURL;
+}
+
+function getExtension(url) {
+  return (getLastPathComponent(url).match(/\.[^.]*$/) || [])[0] || "";
+}
+
+function isHTML(url) {
+  return !!getExtension(url).match(/^(?:|\.(?:htm|html|xhtml))$/);
+}
+
+function isPrefixedBy(baseURL, url) {
+  const prefix = getPrefix(url);
+  return baseURL.href === expandURL(prefix).href || baseURL.href.startsWith(prefix);
+}
+
+function toCacheKey(url) {
+  const anchorLength = url.hash.length;
+  if (anchorLength < 2) {
+    return url.href;
+  } else {
+    return url.href.slice(0, -anchorLength);
   }
 }
 
-function getPrefixURL(location) {
-  return addTrailingSlash(location.getOrigin() + location.getPath());
+function urlsAreEqual(left, right) {
+  return expandURL(left).href == expandURL(right).href;
+}
+
+function getPathComponents(url) {
+  return url.pathname.split("/").slice(1);
 }
 
-function addTrailingSlash(url) {
-  return stringEndsWith(url, "/") ? url : url + "/";
+function getLastPathComponent(url) {
+  return getPathComponents(url).slice(-1)[0];
 }
 
-function stringStartsWith(string, prefix) {
-  return string.slice(0, prefix.length) === prefix;
+function getPrefix(url) {
+  return addTrailingSlash(url.origin + url.pathname);
 }
 
-function stringEndsWith(string, suffix) {
-  return string.slice(-suffix.length) === suffix;
+function addTrailingSlash(value) {
+  return value.endsWith("/") ? value : value + "/";
 }
 
 class FetchResponse {
@@ -230,7 +211,7 @@ class FetchResponse {
     return this.response.redirected;
   }
   get location() {
-    return Location.wrap(this.response.url);
+    return expandURL(this.response.url);
   }
   get isHTML() {
     return this.contentType && this.contentType.match(/^(?:text\/([^\s;,]+\b)?html|application\/xhtml\+xml)\b/);
@@ -270,10 +251,18 @@ function nextAnimationFrame() {
   return new Promise((resolve => requestAnimationFrame((() => resolve()))));
 }
 
+function nextEventLoopTick() {
+  return new Promise((resolve => setTimeout((() => resolve()), 0)));
+}
+
 function nextMicrotask() {
   return Promise.resolve();
 }
 
+function parseHTMLDocument(html = "") {
+  return (new DOMParser).parseFromString(html, "text/html");
+}
+
 function unindent(strings, ...values) {
   const lines = interpolate(strings, values).replace(/^\n/, "").split("\n");
   const match = lines[0].match(/^\s+/);
@@ -334,27 +323,23 @@ function fetchMethodFromString(method) {
 }
 
 class FetchRequest {
-  constructor(delegate, method, location, body) {
+  constructor(delegate, method, location, body = new URLSearchParams) {
     this.abortController = new AbortController;
     this.delegate = delegate;
     this.method = method;
-    this.location = location;
-    this.body = body;
-  }
-  get url() {
-    const url = this.location.absoluteURL;
-    const query = this.params.toString();
-    if (this.isIdempotent && query.length) {
-      return [ url, query ].join(url.includes("?") ? "&" : "?");
+    this.headers = this.defaultHeaders;
+    if (this.isIdempotent) {
+      this.url = mergeFormDataEntries(location, [ ...body.entries() ]);
     } else {
-      return url;
+      this.body = body;
+      this.url = location;
     }
   }
+  get location() {
+    return this.url;
+  }
   get params() {
-    return this.entries.reduce(((params, [name, value]) => {
-      params.append(name, value.toString());
-      return params;
-    }), new URLSearchParams);
+    return this.url.searchParams;
   }
   get entries() {
     return this.body ? Array.from(this.body.entries()) : [];
@@ -363,7 +348,9 @@ class FetchRequest {
     this.abortController.abort();
   }
   async perform() {
+    var _a, _b;
     const {fetchOptions: fetchOptions} = this;
+    (_b = (_a = this.delegate).prepareHeadersForRequest) === null || _b === void 0 ? void 0 : _b.call(_a, this.headers, this);
     dispatch("turbo:before-fetch-request", {
       detail: {
         fetchOptions: fetchOptions
@@ -371,7 +358,7 @@ class FetchRequest {
     });
     try {
       this.delegate.requestStarted(this);
-      const response = await fetch(this.url, fetchOptions);
+      const response = await fetch(this.url.href, fetchOptions);
       return await this.receive(response);
     } catch (error) {
       this.delegate.requestErrored(this, error);
@@ -403,28 +390,35 @@ class FetchRequest {
       credentials: "same-origin",
       headers: this.headers,
       redirect: "follow",
-      body: this.isIdempotent ? undefined : this.body,
+      body: this.body,
       signal: this.abortSignal
     };
   }
+  get defaultHeaders() {
+    return {
+      Accept: "text/html, application/xhtml+xml"
+    };
+  }
   get isIdempotent() {
     return this.method == FetchMethod.get;
   }
-  get headers() {
-    return Object.assign({
-      Accept: "text/html, application/xhtml+xml"
-    }, this.additionalHeaders);
+  get abortSignal() {
+    return this.abortController.signal;
   }
-  get additionalHeaders() {
-    if (typeof this.delegate.additionalHeadersForRequest == "function") {
-      return this.delegate.additionalHeadersForRequest(this);
+}
+
+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 {
-      return {};
+      url.searchParams.append(name, value);
     }
   }
-  get abortSignal() {
-    return this.abortController.signal;
-  }
+  return url;
 }
 
 class AppearanceObserver {
@@ -454,6 +448,41 @@ class AppearanceObserver {
   }
 }
 
+class StreamMessage {
+  constructor(html) {
+    this.templateElement = document.createElement("template");
+    this.templateElement.innerHTML = html;
+  }
+  static wrap(message) {
+    if (typeof message == "string") {
+      return new this(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";
+
 var FormSubmissionState;
 
 (function(FormSubmissionState) {
@@ -465,14 +494,35 @@ var FormSubmissionState;
   FormSubmissionState[FormSubmissionState["stopped"] = 5] = "stopped";
 })(FormSubmissionState || (FormSubmissionState = {}));
 
+var FormEnctype;
+
+(function(FormEnctype) {
+  FormEnctype["urlEncoded"] = "application/x-www-form-urlencoded";
+  FormEnctype["multipart"] = "multipart/form-data";
+  FormEnctype["plain"] = "text/plain";
+})(FormEnctype || (FormEnctype = {}));
+
+function formEnctypeFromString(encoding) {
+  switch (encoding.toLowerCase()) {
+   case FormEnctype.multipart:
+    return FormEnctype.multipart;
+
+   case FormEnctype.plain:
+    return FormEnctype.plain;
+
+   default:
+    return FormEnctype.urlEncoded;
+  }
+}
+
 class FormSubmission {
   constructor(delegate, formElement, submitter, mustRedirect = false) {
     this.state = FormSubmissionState.initialized;
     this.delegate = delegate;
     this.formElement = formElement;
-    this.formData = buildFormData(formElement, submitter);
     this.submitter = submitter;
-    this.fetchRequest = new FetchRequest(this, this.method, this.location, this.formData);
+    this.formData = buildFormData(formElement, submitter);
+    this.fetchRequest = new FetchRequest(this, this.method, this.location, this.body);
     this.mustRedirect = mustRedirect;
   }
   get method() {
@@ -485,7 +535,24 @@ class FormSubmission {
     return ((_a = this.submitter) === null || _a === void 0 ? void 0 : _a.getAttribute("formaction")) || this.formElement.action;
   }
   get location() {
-    return Location.wrap(this.action);
+    return expandURL(this.action);
+  }
+  get body() {
+    if (this.enctype == FormEnctype.urlEncoded || this.method == FetchMethod.get) {
+      return new URLSearchParams(this.stringFormData);
+    } else {
+      return this.formData;
+    }
+  }
+  get enctype() {
+    var _a;
+    return formEnctypeFromString(((_a = this.submitter) === null || _a === void 0 ? void 0 : _a.getAttribute("formenctype")) || this.formElement.enctype);
+  }
+  get isIdempotent() {
+    return this.fetchRequest.isIdempotent;
+  }
+  get stringFormData() {
+    return [ ...this.formData ].reduce(((entries, [name, value]) => entries.concat(typeof value == "string" ? [ [ name, value ] ] : [])), []);
   }
   async start() {
     const {initialized: initialized, requesting: requesting} = FormSubmissionState;
@@ -502,15 +569,14 @@ class FormSubmission {
       return true;
     }
   }
-  additionalHeadersForRequest(request) {
-    const headers = {};
-    if (this.method != FetchMethod.get) {
+  prepareHeadersForRequest(headers, request) {
+    if (!request.isIdempotent) {
       const token = getCookieValue(getMetaContent("csrf-param")) || getMetaContent("csrf-token");
       if (token) {
         headers["X-CSRF-Token"] = token;
       }
+      headers["Accept"] = [ StreamMessage.contentType, headers["Accept"] ].join(", ");
     }
-    return headers;
   }
   requestStarted(request) {
     this.state = FormSubmissionState.waiting;
@@ -576,8 +642,8 @@ 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 && formData.get(name) != value) {
-    formData.append(name, value || "");
+  if (name && value != null && formData.get(name) != value) {
+    formData.append(name, value);
   }
   return formData;
 }
@@ -602,6 +668,48 @@ function responseSucceededWithoutRedirect(response) {
   return response.statusCode == 200 && !response.redirected;
 }
 
+class Snapshot {
+  constructor(element) {
+    this.element = element;
+  }
+  get children() {
+    return [ ...this.element.children ];
+  }
+  hasAnchor(anchor) {
+    return this.getElementForAnchor(anchor) != null;
+  }
+  getElementForAnchor(anchor) {
+    try {
+      return this.element.querySelector(`[id='${anchor}'], a[name='${anchor}']`);
+    } catch (_a) {
+      return null;
+    }
+  }
+  get isConnected() {
+    return this.element.isConnected;
+  }
+  get firstAutofocusableElement() {
+    return this.element.querySelector("[autofocus]");
+  }
+  get permanentElements() {
+    return [ ...this.element.querySelectorAll("[id][data-turbo-permanent]") ];
+  }
+  getPermanentElementById(id) {
+    return this.element.querySelector(`#${id}[data-turbo-permanent]`);
+  }
+  getPermanentElementMapForSnapshot(snapshot) {
+    const permanentElementMap = {};
+    for (const currentPermanentElement of this.permanentElements) {
+      const {id: id} = currentPermanentElement;
+      const newPermanentElement = snapshot.getPermanentElementById(id);
+      if (newPermanentElement) {
+        permanentElementMap[id] = [ currentPermanentElement, newPermanentElement ];
+      }
+    }
+    return permanentElementMap;
+  }
+}
+
 class FormInterceptor {
   constructor(delegate, element) {
     this.submitBubbled = event => {
@@ -626,6 +734,82 @@ class FormInterceptor {
   }
 }
 
+class View {
+  constructor(delegate, element) {
+    this.delegate = delegate;
+    this.element = element;
+  }
+  scrollToAnchor(anchor) {
+    const element = this.snapshot.getElementForAnchor(anchor);
+    if (element) {
+      this.scrollToElement(element);
+    } else {
+      this.scrollToPosition({
+        x: 0,
+        y: 0
+      });
+    }
+  }
+  scrollToElement(element) {
+    element.scrollIntoView();
+  }
+  scrollToPosition({x: x, y: y}) {
+    this.scrollRoot.scrollTo(x, y);
+  }
+  get scrollRoot() {
+    return window;
+  }
+  async render(renderer) {
+    if (this.renderer) {
+      throw new Error("rendering is already in progress");
+    }
+    const {isPreview: isPreview, shouldRender: shouldRender, newSnapshot: snapshot} = renderer;
+    if (shouldRender) {
+      try {
+        this.renderer = renderer;
+        this.prepareToRenderSnapshot(renderer);
+        this.delegate.viewWillRenderSnapshot(snapshot, isPreview);
+        await this.renderSnapshot(renderer);
+        this.delegate.viewRenderedSnapshot(snapshot, isPreview);
+        this.finishRenderingSnapshot(renderer);
+      } finally {
+        delete this.renderer;
+      }
+    } else {
+      this.invalidate();
+    }
+  }
+  invalidate() {
+    this.delegate.viewInvalidated();
+  }
+  prepareToRenderSnapshot(renderer) {
+    this.markAsPreview(renderer.isPreview);
+    renderer.prepareToRender();
+  }
+  markAsPreview(isPreview) {
+    if (isPreview) {
+      this.element.setAttribute("data-turbo-preview", "");
+    } else {
+      this.element.removeAttribute("data-turbo-preview");
+    }
+  }
+  async renderSnapshot(renderer) {
+    await renderer.render();
+  }
+  finishRenderingSnapshot(renderer) {
+    renderer.finishRendering();
+  }
+}
+
+class FrameView extends View {
+  invalidate() {
+    this.element.innerHTML = "";
+  }
+  get snapshot() {
+    return new Snapshot(this.element);
+  }
+}
+
 class LinkInterceptor {
   constructor(delegate, element) {
     this.clickBubbled = event => {
@@ -640,7 +824,7 @@ class LinkInterceptor {
         if (this.delegate.shouldInterceptLinkClick(event.target, event.detail.url)) {
           this.clickEvent.preventDefault();
           event.preventDefault();
-          this.delegate.linkClickIntercepted(event.target, event.detail.url);
+          this.convertLinkWithMethodClickToFormSubmission(event.target) || this.delegate.linkClickIntercepted(event.target, event.detail.url);
         }
       }
       delete this.clickEvent;
@@ -661,183 +845,181 @@ class LinkInterceptor {
     document.removeEventListener("turbo:click", this.linkClicked);
     document.removeEventListener("turbo:before-visit", this.willVisit);
   }
+  convertLinkWithMethodClickToFormSubmission(link) {
+    var _a;
+    const linkMethod = link.getAttribute("data-turbo-method") || link.getAttribute("data-method");
+    if (linkMethod) {
+      const form = document.createElement("form");
+      form.method = linkMethod;
+      form.action = link.getAttribute("href") || "undefined";
+      (_a = link.parentNode) === null || _a === void 0 ? void 0 : _a.insertBefore(form, link);
+      return dispatch("submit", {
+        target: form
+      });
+    } else {
+      return false;
+    }
+  }
   respondsToEventTarget(target) {
     const element = target instanceof Element ? target : target instanceof Node ? target.parentElement : null;
     return element && element.closest("turbo-frame, html") == this.element;
   }
 }
 
-class FrameController {
-  constructor(element) {
-    this.resolveVisitPromise = () => {};
-    this.element = element;
-    this.appearanceObserver = new AppearanceObserver(this, this.element);
-    this.linkInterceptor = new LinkInterceptor(this, this.element);
-    this.formInterceptor = new FormInterceptor(this, this.element);
-  }
-  connect() {
-    if (this.loadingStyle == FrameLoadingStyle.lazy) {
-      this.appearanceObserver.start();
-    }
-    this.linkInterceptor.start();
-    this.formInterceptor.start();
+class Bardo {
+  constructor(permanentElementMap) {
+    this.permanentElementMap = permanentElementMap;
   }
-  disconnect() {
-    this.appearanceObserver.stop();
-    this.linkInterceptor.stop();
-    this.formInterceptor.stop();
+  static preservingPermanentElements(permanentElementMap, callback) {
+    const bardo = new this(permanentElementMap);
+    bardo.enter();
+    callback();
+    bardo.leave();
   }
-  sourceURLChanged() {
-    if (this.loadingStyle == FrameLoadingStyle.eager) {
-      this.loadSourceURL();
+  enter() {
+    for (const id in this.permanentElementMap) {
+      const [, newPermanentElement] = this.permanentElementMap[id];
+      this.replaceNewPermanentElementWithPlaceholder(newPermanentElement);
     }
   }
-  loadingStyleChanged() {
-    if (this.loadingStyle == FrameLoadingStyle.lazy) {
-      this.appearanceObserver.start();
-    } else {
-      this.appearanceObserver.stop();
-      this.loadSourceURL();
+  leave() {
+    for (const id in this.permanentElementMap) {
+      const [currentPermanentElement] = this.permanentElementMap[id];
+      this.replaceCurrentPermanentElementWithClone(currentPermanentElement);
+      this.replacePlaceholderWithPermanentElement(currentPermanentElement);
     }
   }
-  async loadSourceURL() {
-    if (this.isActive && this.sourceURL && this.sourceURL != this.loadingURL) {
-      try {
-        this.loadingURL = this.sourceURL;
-        this.element.loaded = this.visit(this.sourceURL);
-        this.appearanceObserver.stop();
-        await this.element.loaded;
-      } finally {
-        delete this.loadingURL;
-      }
-    }
+  replaceNewPermanentElementWithPlaceholder(permanentElement) {
+    const placeholder = createPlaceholderForPermanentElement(permanentElement);
+    permanentElement.replaceWith(placeholder);
   }
-  async loadResponse(response) {
-    const fragment = fragmentFromHTML(await response.responseHTML);
-    if (fragment) {
-      const element = await this.extractForeignFrameElement(fragment);
-      await nextAnimationFrame();
-      this.loadFrameElement(element);
-      this.scrollFrameIntoView(element);
-      await nextAnimationFrame();
-      this.focusFirstAutofocusableElement();
-    }
+  replaceCurrentPermanentElementWithClone(permanentElement) {
+    const clone = permanentElement.cloneNode(true);
+    permanentElement.replaceWith(clone);
   }
-  elementAppearedInViewport(element) {
-    this.loadSourceURL();
+  replacePlaceholderWithPermanentElement(permanentElement) {
+    const placeholder = this.getPlaceholderById(permanentElement.id);
+    placeholder === null || placeholder === void 0 ? void 0 : placeholder.replaceWith(permanentElement);
   }
-  shouldInterceptLinkClick(element, url) {
-    return this.shouldInterceptNavigation(element);
+  getPlaceholderById(id) {
+    return this.placeholders.find((element => element.content == id));
   }
-  linkClickIntercepted(element, url) {
-    this.navigateFrame(element, url);
+  get placeholders() {
+    return [ ...document.querySelectorAll("meta[name=turbo-permanent-placeholder][content]") ];
   }
-  shouldInterceptFormSubmission(element) {
-    return this.shouldInterceptNavigation(element);
+}
+
+function createPlaceholderForPermanentElement(permanentElement) {
+  const element = document.createElement("meta");
+  element.setAttribute("name", "turbo-permanent-placeholder");
+  element.setAttribute("content", permanentElement.id);
+  return element;
+}
+
+class Renderer {
+  constructor(currentSnapshot, newSnapshot, isPreview) {
+    this.currentSnapshot = currentSnapshot;
+    this.newSnapshot = newSnapshot;
+    this.isPreview = isPreview;
+    this.promise = new Promise(((resolve, reject) => this.resolvingFunctions = {
+      resolve: resolve,
+      reject: reject
+    }));
   }
-  formSubmissionIntercepted(element, submitter) {
-    if (this.formSubmission) {
-      this.formSubmission.stop();
+  get shouldRender() {
+    return true;
+  }
+  prepareToRender() {
+    return;
+  }
+  finishRendering() {
+    if (this.resolvingFunctions) {
+      this.resolvingFunctions.resolve();
+      delete this.resolvingFunctions;
     }
-    this.formSubmission = new FormSubmission(this, element, submitter);
-    if (this.formSubmission.fetchRequest.isIdempotent) {
-      this.navigateFrame(element, this.formSubmission.fetchRequest.url);
+  }
+  createScriptElement(element) {
+    if (element.getAttribute("data-turbo-eval") == "false") {
+      return element;
     } else {
-      this.formSubmission.start();
+      const createdScriptElement = document.createElement("script");
+      if (this.cspNonce) {
+        createdScriptElement.nonce = this.cspNonce;
+      }
+      createdScriptElement.textContent = element.textContent;
+      createdScriptElement.async = false;
+      copyElementAttributes(createdScriptElement, element);
+      return createdScriptElement;
     }
   }
-  additionalHeadersForRequest(request) {
-    return {
-      "Turbo-Frame": this.id
-    };
+  preservingPermanentElements(callback) {
+    Bardo.preservingPermanentElements(this.permanentElementMap, callback);
   }
-  requestStarted(request) {
-    this.element.setAttribute("busy", "");
+  focusFirstAutofocusableElement() {
+    const element = this.connectedSnapshot.firstAutofocusableElement;
+    if (elementIsFocusable(element)) {
+      element.focus();
+    }
   }
-  requestPreventedHandlingResponse(request, response) {
-    this.resolveVisitPromise();
+  get connectedSnapshot() {
+    return this.newSnapshot.isConnected ? this.newSnapshot : this.currentSnapshot;
   }
-  async requestSucceededWithResponse(request, response) {
-    await this.loadResponse(response);
-    this.resolveVisitPromise();
+  get currentElement() {
+    return this.currentSnapshot.element;
   }
-  requestFailedWithResponse(request, response) {
-    console.error(response);
-    this.resolveVisitPromise();
+  get newElement() {
+    return this.newSnapshot.element;
   }
-  requestErrored(request, error) {
-    console.error(error);
-    this.resolveVisitPromise();
+  get permanentElementMap() {
+    return this.currentSnapshot.getPermanentElementMapForSnapshot(this.newSnapshot);
   }
-  requestFinished(request) {
-    this.element.removeAttribute("busy");
+  get cspNonce() {
+    var _a;
+    return (_a = document.head.querySelector('meta[name="csp-nonce"]')) === null || _a === void 0 ? void 0 : _a.getAttribute("content");
   }
-  formSubmissionStarted(formSubmission) {}
-  formSubmissionSucceededWithResponse(formSubmission, response) {
-    const frame = this.findFrameElement(formSubmission.formElement);
-    frame.delegate.loadResponse(response);
+}
+
+function copyElementAttributes(destinationElement, sourceElement) {
+  for (const {name: name, value: value} of [ ...sourceElement.attributes ]) {
+    destinationElement.setAttribute(name, value);
   }
-  formSubmissionFailedWithResponse(formSubmission, fetchResponse) {
-    this.element.delegate.loadResponse(fetchResponse);
+}
+
+function elementIsFocusable(element) {
+  return element && typeof element.focus == "function";
+}
+
+class FrameRenderer extends Renderer {
+  get shouldRender() {
+    return true;
   }
-  formSubmissionErrored(formSubmission, error) {}
-  formSubmissionFinished(formSubmission) {}
-  async visit(url) {
-    const location = Location.wrap(url);
-    const request = new FetchRequest(this, FetchMethod.get, location);
-    return new Promise((resolve => {
-      this.resolveVisitPromise = () => {
-        this.resolveVisitPromise = () => {};
-        resolve();
-      };
-      request.perform();
+  async render() {
+    await nextAnimationFrame();
+    this.preservingPermanentElements((() => {
+      this.loadFrameElement();
     }));
+    this.scrollFrameIntoView();
+    await nextAnimationFrame();
+    this.focusFirstAutofocusableElement();
+    await nextAnimationFrame();
+    this.activateScriptElements();
   }
-  navigateFrame(element, url) {
-    const frame = this.findFrameElement(element);
-    frame.src = url;
-  }
-  findFrameElement(element) {
-    var _a;
-    const id = element.getAttribute("data-turbo-frame");
-    return (_a = getFrameElementById(id)) !== null && _a !== void 0 ? _a : this.element;
-  }
-  async extractForeignFrameElement(container) {
-    let element;
-    const id = CSS.escape(this.id);
-    if (element = activateElement(container.querySelector(`turbo-frame#${id}`))) {
-      return element;
-    }
-    if (element = activateElement(container.querySelector(`turbo-frame[src][recurse~=${id}]`))) {
-      await element.loaded;
-      return await this.extractForeignFrameElement(element);
-    }
-    console.error(`Response has no matching <turbo-frame id="${id}"> element`);
-    return new FrameElement;
-  }
-  loadFrameElement(frameElement) {
+  loadFrameElement() {
     var _a;
     const destinationRange = document.createRange();
-    destinationRange.selectNodeContents(this.element);
+    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.element.appendChild(sourceRange.extractContents());
+      this.currentElement.appendChild(sourceRange.extractContents());
     }
   }
-  focusFirstAutofocusableElement() {
-    const element = this.firstAutofocusableElement;
-    if (element) {
-      element.focus();
-      return true;
-    }
-    return false;
-  }
-  scrollFrameIntoView(frame) {
-    if (this.element.autoscroll || frame.autoscroll) {
-      const element = this.element.firstElementChild;
-      const block = readScrollLogicalPosition(this.element.getAttribute("data-autoscroll-block"), "end");
+  scrollFrameIntoView() {
+    if (this.currentElement.autoscroll || this.newElement.autoscroll) {
+      const element = this.currentElement.firstElementChild;
+      const block = readScrollLogicalPosition(this.currentElement.getAttribute("data-autoscroll-block"), "end");
       if (element) {
         element.scrollIntoView({
           block: block
@@ -847,49 +1029,14 @@ class FrameController {
     }
     return false;
   }
-  shouldInterceptNavigation(element) {
-    const id = element.getAttribute("data-turbo-frame") || this.element.getAttribute("target");
-    if (!this.enabled || id == "_top") {
-      return false;
-    }
-    if (id) {
-      const frameElement = getFrameElementById(id);
-      if (frameElement) {
-        return !frameElement.disabled;
-      }
+  activateScriptElements() {
+    for (const inertScriptElement of this.newScriptElements) {
+      const activatedScriptElement = this.createScriptElement(inertScriptElement);
+      inertScriptElement.replaceWith(activatedScriptElement);
     }
-    return true;
-  }
-  get firstAutofocusableElement() {
-    const element = this.element.querySelector("[autofocus]");
-    return element instanceof HTMLElement ? element : null;
-  }
-  get id() {
-    return this.element.id;
-  }
-  get enabled() {
-    return !this.element.disabled;
-  }
-  get sourceURL() {
-    return this.element.src;
-  }
-  get loadingStyle() {
-    return this.element.loading;
-  }
-  get isLoading() {
-    return this.formSubmission !== undefined || this.loadingURL !== undefined;
-  }
-  get isActive() {
-    return this.element.isActive;
   }
-}
-
-function getFrameElementById(id) {
-  if (id != null) {
-    const element = document.getElementById(id);
-    if (element instanceof FrameElement) {
-      return element;
-    }
+  get newScriptElements() {
+    return this.currentElement.querySelectorAll("script");
   }
 }
 
@@ -901,144 +1048,6 @@ function readScrollLogicalPosition(value, defaultValue) {
   }
 }
 
-function fragmentFromHTML(html) {
-  if (html) {
-    const foreignDocument = document.implementation.createHTMLDocument();
-    return foreignDocument.createRange().createContextualFragment(html);
-  }
-}
-
-function activateElement(element) {
-  if (element && element.ownerDocument !== document) {
-    element = document.importNode(element, true);
-  }
-  if (element instanceof FrameElement) {
-    return element;
-  }
-}
-
-const StreamActions = {
-  append() {
-    var _a;
-    (_a = this.targetElement) === null || _a === void 0 ? void 0 : _a.append(this.templateContent);
-  },
-  prepend() {
-    var _a;
-    (_a = this.targetElement) === null || _a === void 0 ? void 0 : _a.prepend(this.templateContent);
-  },
-  remove() {
-    var _a;
-    (_a = this.targetElement) === null || _a === void 0 ? void 0 : _a.remove();
-  },
-  replace() {
-    var _a;
-    (_a = this.targetElement) === null || _a === void 0 ? void 0 : _a.replaceWith(this.templateContent);
-  },
-  update() {
-    if (this.targetElement) {
-      this.targetElement.innerHTML = "";
-      this.targetElement.append(this.templateContent);
-    }
-  }
-};
-
-class StreamElement extends HTMLElement {
-  async connectedCallback() {
-    try {
-      await this.render();
-    } catch (error) {
-      console.error(error);
-    } finally {
-      this.disconnect();
-    }
-  }
-  async render() {
-    var _a;
-    return (_a = this.renderPromise) !== null && _a !== void 0 ? _a : this.renderPromise = (async () => {
-      if (this.dispatchEvent(this.beforeRenderEvent)) {
-        await nextAnimationFrame();
-        this.performAction();
-      }
-    })();
-  }
-  disconnect() {
-    try {
-      this.remove();
-    } catch (_a) {}
-  }
-  get performAction() {
-    if (this.action) {
-      const actionFunction = StreamActions[this.action];
-      if (actionFunction) {
-        return actionFunction;
-      }
-      this.raise("unknown action");
-    }
-    this.raise("action attribute is missing");
-  }
-  get targetElement() {
-    var _a;
-    if (this.target) {
-      return (_a = this.ownerDocument) === null || _a === void 0 ? void 0 : _a.getElementById(this.target);
-    }
-    this.raise("target attribute is missing");
-  }
-  get templateContent() {
-    return this.templateElement.content;
-  }
-  get templateElement() {
-    if (this.firstElementChild instanceof HTMLTemplateElement) {
-      return this.firstElementChild;
-    }
-    this.raise("first child element must be a <template> element");
-  }
-  get action() {
-    return this.getAttribute("action");
-  }
-  get target() {
-    return this.getAttribute("target");
-  }
-  raise(message) {
-    throw new Error(`${this.description}: ${message}`);
-  }
-  get description() {
-    var _a, _b;
-    return (_b = ((_a = this.outerHTML.match(/<[^>]+>/)) !== null && _a !== void 0 ? _a : [])[0]) !== null && _b !== void 0 ? _b : "<turbo-stream>";
-  }
-  get beforeRenderEvent() {
-    return new CustomEvent("turbo:before-stream-render", {
-      bubbles: true,
-      cancelable: true
-    });
-  }
-}
-
-FrameElement.delegateConstructor = FrameController;
-
-customElements.define("turbo-frame", FrameElement);
-
-customElements.define("turbo-stream", StreamElement);
-
-(() => {
-  let element = document.currentScript;
-  if (!element) return;
-  if (element.hasAttribute("data-turbo-suppress-warning")) return;
-  while (element = element.parentElement) {
-    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!
-
-        Load your application’s JavaScript bundle inside the <head> element instead. <script> elements in <body> are evaluated with each page change.
-
-        For more information, see: https://turbo.hotwire.dev/handbook/building#working-with-script-elements
-
-        ——
-        Suppress this warning by adding a "data-turbo-suppress-warning" attribute to: %s
-      `, element.outerHTML);
-    }
-  }
-})();
-
 class ProgressBar {
   constructor() {
     this.hiding = false;
@@ -1138,9 +1147,10 @@ class ProgressBar {
 
 ProgressBar.animationDuration = 300;
 
-class HeadDetails {
-  constructor(children) {
-    this.detailsByOuterHTML = children.reduce(((result, element) => {
+class HeadSnapshot extends Snapshot {
+  constructor() {
+    super(...arguments);
+    this.detailsByOuterHTML = this.children.reduce(((result, element) => {
       const {outerHTML: outerHTML} = element;
       const details = outerHTML in result ? result[outerHTML] : {
         type: elementType(element),
@@ -1154,23 +1164,19 @@ class HeadDetails {
       });
     }), {});
   }
-  static fromHeadElement(headElement) {
-    const children = headElement ? [ ...headElement.children ] : [];
-    return new this(children);
-  }
-  getTrackedElementSignature() {
+  get trackedElementSignature() {
     return Object.keys(this.detailsByOuterHTML).filter((outerHTML => this.detailsByOuterHTML[outerHTML].tracked)).join("");
   }
-  getScriptElementsNotInDetails(headDetails) {
-    return this.getElementsMatchingTypeNotInDetails("script", headDetails);
+  getScriptElementsNotInSnapshot(snapshot) {
+    return this.getElementsMatchingTypeNotInSnapshot("script", snapshot);
   }
-  getStylesheetElementsNotInDetails(headDetails) {
-    return this.getElementsMatchingTypeNotInDetails("stylesheet", headDetails);
+  getStylesheetElementsNotInSnapshot(snapshot) {
+    return this.getElementsMatchingTypeNotInSnapshot("stylesheet", snapshot);
   }
-  getElementsMatchingTypeNotInDetails(matchedType, headDetails) {
-    return Object.keys(this.detailsByOuterHTML).filter((outerHTML => !(outerHTML in headDetails.detailsByOuterHTML))).map((outerHTML => this.detailsByOuterHTML[outerHTML])).filter((({type: type}) => type == matchedType)).map((({elements: [element]}) => element));
+  getElementsMatchingTypeNotInSnapshot(matchedType, snapshot) {
+    return Object.keys(this.detailsByOuterHTML).filter((outerHTML => !(outerHTML in snapshot.detailsByOuterHTML))).map((outerHTML => this.detailsByOuterHTML[outerHTML])).filter((({type: type}) => type == matchedType)).map((({elements: [element]}) => element));
   }
-  getProvisionalElements() {
+  get provisionalElements() {
     return Object.keys(this.detailsByOuterHTML).reduce(((result, outerHTML) => {
       const {type: type, tracked: tracked, elements: elements} = this.detailsByOuterHTML[outerHTML];
       if (type == null && !tracked) {
@@ -1221,75 +1227,45 @@ function elementIsMetaElementWithName(element, name) {
   return tagName == "meta" && element.getAttribute("name") == name;
 }
 
-class Snapshot {
-  constructor(headDetails, bodyElement) {
-    this.headDetails = headDetails;
-    this.bodyElement = bodyElement;
-  }
-  static wrap(value) {
-    if (value instanceof this) {
-      return value;
-    } else if (typeof value == "string") {
-      return this.fromHTMLString(value);
-    } else {
-      return this.fromHTMLElement(value);
-    }
-  }
-  static fromHTMLString(html) {
-    const {documentElement: documentElement} = (new DOMParser).parseFromString(html, "text/html");
-    return this.fromHTMLElement(documentElement);
+class PageSnapshot extends Snapshot {
+  constructor(element, headSnapshot) {
+    super(element);
+    this.headSnapshot = headSnapshot;
   }
-  static fromHTMLElement(htmlElement) {
-    const headElement = htmlElement.querySelector("head");
-    const bodyElement = htmlElement.querySelector("body") || document.createElement("body");
-    const headDetails = HeadDetails.fromHeadElement(headElement);
-    return new this(headDetails, bodyElement);
+  static fromHTMLString(html = "") {
+    return this.fromDocument(parseHTMLDocument(html));
   }
-  clone() {
-    const {bodyElement: bodyElement} = Snapshot.fromHTMLString(this.bodyElement.outerHTML);
-    return new Snapshot(this.headDetails, bodyElement);
-  }
-  getRootLocation() {
-    const root = this.getSetting("root", "/");
-    return new Location(root);
-  }
-  getCacheControlValue() {
-    return this.getSetting("cache-control");
-  }
-  getElementForAnchor(anchor) {
-    try {
-      return this.bodyElement.querySelector(`[id='${anchor}'], a[name='${anchor}']`);
-    } catch (_a) {
-      return null;
-    }
+  static fromElement(element) {
+    return this.fromDocument(element.ownerDocument);
   }
-  getPermanentElements() {
-    return [ ...this.bodyElement.querySelectorAll("[id][data-turbo-permanent]") ];
+  static fromDocument({head: head, body: body}) {
+    return new this(body, new HeadSnapshot(head));
   }
-  getPermanentElementById(id) {
-    return this.bodyElement.querySelector(`#${id}[data-turbo-permanent]`);
+  clone() {
+    return new PageSnapshot(this.element.cloneNode(true), this.headSnapshot);
   }
-  getPermanentElementsPresentInSnapshot(snapshot) {
-    return this.getPermanentElements().filter((({id: id}) => snapshot.getPermanentElementById(id)));
+  get headElement() {
+    return this.headSnapshot.element;
   }
-  findFirstAutofocusableElement() {
-    return this.bodyElement.querySelector("[autofocus]");
+  get rootLocation() {
+    var _a;
+    const root = (_a = this.getSetting("root")) !== null && _a !== void 0 ? _a : "/";
+    return expandURL(root);
   }
-  hasAnchor(anchor) {
-    return this.getElementForAnchor(anchor) != null;
+  get cacheControlValue() {
+    return this.getSetting("cache-control");
   }
-  isPreviewable() {
-    return this.getCacheControlValue() != "no-preview";
+  get isPreviewable() {
+    return this.cacheControlValue != "no-preview";
   }
-  isCacheable() {
-    return this.getCacheControlValue() != "no-cache";
+  get isCacheable() {
+    return this.cacheControlValue != "no-cache";
   }
-  isVisitable() {
+  get isVisitable() {
     return this.getSetting("visit-control") != "reload";
   }
-  getSetting(name, defaultValue) {
-    const value = this.headDetails.getMetaValue(`turbo-${name}`);
-    return value == null ? defaultValue : value;
+  getSetting(name) {
+    return this.headSnapshot.getMetaValue(`turbo-${name}`);
   }
 }
 
@@ -1334,16 +1310,6 @@ class Visit {
     this.scrolled = false;
     this.snapshotCached = false;
     this.state = VisitState.initialized;
-    this.performScroll = () => {
-      if (!this.scrolled) {
-        if (this.action == "restore") {
-          this.scrollToRestoredPosition() || this.scrollToTop();
-        } else {
-          this.scrollToAnchor() || this.scrollToTop();
-        }
-        this.scrolled = true;
-      }
-    };
     this.delegate = delegate;
     this.location = location;
     this.restorationIdentifier = restorationIdentifier || uuid();
@@ -1398,8 +1364,9 @@ class Visit {
     }
   }
   changeHistory() {
+    var _a;
     if (!this.historyChanged) {
-      const actionForHistory = this.location.isEqualTo(this.referrer) ? "replace" : this.action;
+      const actionForHistory = this.location.href === ((_a = this.referrer) === null || _a === void 0 ? void 0 : _a.href) ? "replace" : this.action;
       const method = this.getHistoryMethodForAction(actionForHistory);
       this.history.update(method, this.location, this.restorationIdentifier);
       this.historyChanged = true;
@@ -1442,18 +1409,14 @@ class Visit {
   loadResponse() {
     if (this.response) {
       const {statusCode: statusCode, responseHTML: responseHTML} = this.response;
-      this.render((() => {
+      this.render((async () => {
         this.cacheSnapshot();
         if (isSuccessful(statusCode) && responseHTML != null) {
-          this.view.render({
-            snapshot: Snapshot.fromHTMLString(responseHTML)
-          }, this.performScroll);
+          await this.view.renderPage(PageSnapshot.fromHTMLString(responseHTML));
           this.adapter.visitRendered(this);
           this.complete();
         } else {
-          this.view.render({
-            error: responseHTML
-          }, this.performScroll);
+          await this.view.renderError(PageSnapshot.fromHTMLString(responseHTML));
           this.adapter.visitRendered(this);
           this.fail();
         }
@@ -1462,15 +1425,15 @@ class Visit {
   }
   getCachedSnapshot() {
     const snapshot = this.view.getCachedSnapshotForLocation(this.location) || this.getPreloadedSnapshot();
-    if (snapshot && (!this.location.anchor || snapshot.hasAnchor(this.location.anchor))) {
-      if (this.action == "restore" || snapshot.isPreviewable()) {
+    if (snapshot && (!getAnchor(this.location) || snapshot.hasAnchor(getAnchor(this.location)))) {
+      if (this.action == "restore" || snapshot.isPreviewable) {
         return snapshot;
       }
     }
   }
   getPreloadedSnapshot() {
     if (this.snapshotHTML) {
-      return Snapshot.wrap(this.snapshotHTML);
+      return PageSnapshot.fromHTMLString(this.snapshotHTML);
     }
   }
   hasCachedSnapshot() {
@@ -1480,12 +1443,9 @@ class Visit {
     const snapshot = this.getCachedSnapshot();
     if (snapshot) {
       const isPreview = this.shouldIssueRequest();
-      this.render((() => {
+      this.render((async () => {
         this.cacheSnapshot();
-        this.view.render({
-          snapshot: snapshot,
-          isPreview: isPreview
-        }, this.performScroll);
+        await this.view.renderPage(snapshot, isPreview);
         this.adapter.visitRendered(this);
         if (!isPreview) {
           this.complete();
@@ -1539,16 +1499,26 @@ class Visit {
   requestFinished() {
     this.finishRequest();
   }
-  scrollToRestoredPosition() {
-    const {scrollPosition: scrollPosition} = this.restorationData;
-    if (scrollPosition) {
+  performScroll() {
+    if (!this.scrolled) {
+      if (this.action == "restore") {
+        this.scrollToRestoredPosition() || this.scrollToTop();
+      } else {
+        this.scrollToAnchor() || this.scrollToTop();
+      }
+      this.scrolled = true;
+    }
+  }
+  scrollToRestoredPosition() {
+    const {scrollPosition: scrollPosition} = this.restorationData;
+    if (scrollPosition) {
       this.view.scrollToPosition(scrollPosition);
       return true;
     }
   }
   scrollToAnchor() {
-    if (this.location.anchor != null) {
-      this.view.scrollToAnchor(this.location.anchor);
+    if (getAnchor(this.location)) {
+      this.view.scrollToAnchor(getAnchor(this.location));
       return true;
     }
   }
@@ -1586,12 +1556,14 @@ class Visit {
       this.snapshotCached = true;
     }
   }
-  render(callback) {
+  async render(callback) {
     this.cancelRender();
-    this.frame = requestAnimationFrame((() => {
-      delete this.frame;
-      callback.call(this);
+    await new Promise((resolve => {
+      this.frame = requestAnimationFrame((() => resolve()));
     }));
+    callback();
+    delete this.frame;
+    this.performScroll();
   }
   cancelRender() {
     if (this.frame) {
@@ -1673,6 +1645,30 @@ 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;
@@ -1766,11 +1762,10 @@ class History {
       if (this.shouldHandlePopState()) {
         const {turbo: turbo} = event.state || {};
         if (turbo) {
-          const location = Location.currentLocation;
-          this.location = location;
+          this.location = new URL(window.location.href);
           const {restorationIdentifier: restorationIdentifier} = turbo;
           this.restorationIdentifier = restorationIdentifier;
-          this.delegate.historyPoppedToLocationWithRestorationIdentifier(location, restorationIdentifier);
+          this.delegate.historyPoppedToLocationWithRestorationIdentifier(this.location, restorationIdentifier);
         }
       }
     };
@@ -1785,7 +1780,7 @@ class History {
       addEventListener("popstate", this.onPopState, false);
       addEventListener("load", this.onPageLoad, false);
       this.started = true;
-      this.replace(Location.currentLocation);
+      this.replace(new URL(window.location.href));
     }
   }
   stop() {
@@ -1807,7 +1802,7 @@ class History {
         restorationIdentifier: restorationIdentifier
       }
     };
-    method.call(history, state, "", location.absoluteURL);
+    method.call(history, state, "", location.href);
     this.location = location;
     this.restorationIdentifier = restorationIdentifier;
   }
@@ -1882,10 +1877,14 @@ class LinkClickObserver {
     }
   }
   getLocationForLink(link) {
-    return new Location(link.getAttribute("href") || "");
+    return expandURL(link.getAttribute("href") || "");
   }
 }
 
+function isAction(action) {
+  return action == "advance" || action == "replace" || action == "restore";
+}
+
 class Navigator {
   constructor(delegate) {
     this.delegate = delegate;
@@ -1895,9 +1894,9 @@ class Navigator {
       this.delegate.visitProposedToLocation(location, options);
     }
   }
-  startVisit(location, restorationIdentifier, options = {}) {
+  startVisit(locatable, restorationIdentifier, options = {}) {
     this.stop();
-    this.currentVisit = new Visit(this, Location.wrap(location), restorationIdentifier, Object.assign({
+    this.currentVisit = new Visit(this, expandURL(locatable), restorationIdentifier, Object.assign({
       referrer: this.location
     }, options));
     this.currentVisit.start();
@@ -1905,7 +1904,13 @@ class Navigator {
   submitForm(form, submitter) {
     this.stop();
     this.formSubmission = new FormSubmission(this, form, submitter, true);
-    this.formSubmission.start();
+    if (this.formSubmission.isIdempotent) {
+      this.proposeVisit(this.formSubmission.fetchRequest.url, {
+        action: this.getActionForFormSubmission(this.formSubmission)
+      });
+    } else {
+      this.formSubmission.start();
+    }
   }
   stop() {
     if (this.formSubmission) {
@@ -1948,14 +1953,14 @@ class Navigator {
   async formSubmissionFailedWithResponse(formSubmission, fetchResponse) {
     const responseHTML = await fetchResponse.responseHTML;
     if (responseHTML) {
-      const snapshot = Snapshot.fromHTMLString(responseHTML);
-      this.view.render({
-        snapshot: snapshot
-      }, (() => {}));
+      const snapshot = PageSnapshot.fromHTMLString(responseHTML);
+      await this.view.renderPage(snapshot);
       this.view.clearSnapshotCache();
     }
   }
-  formSubmissionErrored(formSubmission, error) {}
+  formSubmissionErrored(formSubmission, error) {
+    console.error(error);
+  }
   formSubmissionFinished(formSubmission) {}
   visitStarted(visit) {
     this.delegate.visitStarted(visit);
@@ -1969,6 +1974,11 @@ class Navigator {
   get restorationIdentifier() {
     return this.history.restorationIdentifier;
   }
+  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");
+    return isAction(action) ? action : "advance";
+  }
 }
 
 var PageStage;
@@ -2061,51 +2071,10 @@ class ScrollObserver {
   }
 }
 
-class StreamMessage {
-  constructor(html) {
-    this.templateElement = document.createElement("template");
-    this.templateElement.innerHTML = html;
-  }
-  static wrap(message) {
-    if (typeof message == "string") {
-      return new this(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);
-  }
-}
-
 class StreamObserver {
   constructor(delegate) {
     this.sources = new Set;
     this.started = false;
-    this.prepareFetchRequest = event => {
-      var _a;
-      const fetchOptions = (_a = event.detail) === null || _a === void 0 ? void 0 : _a.fetchOptions;
-      if (fetchOptions) {
-        const {headers: headers} = fetchOptions;
-        headers.Accept = [ "text/vnd.turbo-stream.html", headers.Accept ].join(", ");
-      }
-    };
     this.inspectFetchResponse = event => {
       const response = fetchResponseFromEvent(event);
       if (response && fetchResponseIsStream(response)) {
@@ -2123,14 +2092,12 @@ class StreamObserver {
   start() {
     if (!this.started) {
       this.started = true;
-      addEventListener("turbo:before-fetch-request", this.prepareFetchRequest, true);
       addEventListener("turbo:before-fetch-response", this.inspectFetchResponse, false);
     }
   }
   stop() {
     if (this.started) {
       this.started = false;
-      removeEventListener("turbo:before-fetch-request", this.prepareFetchRequest, true);
       removeEventListener("turbo:before-fetch-response", this.inspectFetchResponse, false);
     }
   }
@@ -2171,70 +2138,21 @@ function fetchResponseFromEvent(event) {
 function fetchResponseIsStream(response) {
   var _a;
   const contentType = (_a = response.contentType) !== null && _a !== void 0 ? _a : "";
-  return /^text\/vnd\.turbo-stream\.html\b/.test(contentType);
-}
-
-function isAction(action) {
-  return action == "advance" || action == "replace" || action == "restore";
-}
-
-class Renderer {
-  renderView(callback) {
-    this.delegate.viewWillRender(this.newBody);
-    callback();
-    this.delegate.viewRendered(this.newBody);
-  }
-  invalidateView() {
-    this.delegate.viewInvalidated();
-  }
-  createScriptElement(element) {
-    if (element.getAttribute("data-turbo-eval") == "false") {
-      return element;
-    } else {
-      const createdScriptElement = document.createElement("script");
-      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);
-  }
+  return contentType.startsWith(StreamMessage.contentType);
 }
 
 class ErrorRenderer extends Renderer {
-  constructor(delegate, html) {
-    super();
-    this.delegate = delegate;
-    this.htmlElement = (() => {
-      const htmlElement = document.createElement("html");
-      htmlElement.innerHTML = html;
-      return htmlElement;
-    })();
-    this.newHead = this.htmlElement.querySelector("head") || document.createElement("head");
-    this.newBody = this.htmlElement.querySelector("body") || document.createElement("body");
-  }
-  static render(delegate, callback, html) {
-    return new this(delegate, html).render(callback);
-  }
-  render(callback) {
-    this.renderView((() => {
-      this.replaceHeadAndBody();
-      this.activateBodyScriptElements();
-      callback();
-    }));
+  async render() {
+    this.replaceHeadAndBody();
+    this.activateScriptElements();
   }
   replaceHeadAndBody() {
     const {documentElement: documentElement, head: head, body: body} = document;
     documentElement.replaceChild(this.newHead, head);
-    documentElement.replaceChild(this.newBody, body);
+    documentElement.replaceChild(this.newElement, body);
   }
-  activateBodyScriptElements() {
-    for (const replaceableElement of this.getScriptElements()) {
+  activateScriptElements() {
+    for (const replaceableElement of this.scriptElements) {
       const parentNode = replaceableElement.parentNode;
       if (parentNode) {
         const element = this.createScriptElement(replaceableElement);
@@ -2242,82 +2160,38 @@ class ErrorRenderer extends Renderer {
       }
     }
   }
-  getScriptElements() {
+  get newHead() {
+    return this.newSnapshot.headSnapshot.element;
+  }
+  get scriptElements() {
     return [ ...document.documentElement.querySelectorAll("script") ];
   }
 }
 
-class SnapshotCache {
-  constructor(size) {
-    this.keys = [];
-    this.snapshots = {};
-    this.size = size;
-  }
-  has(location) {
-    return location.toCacheKey() in this.snapshots;
-  }
-  get(location) {
-    if (this.has(location)) {
-      const snapshot = this.read(location);
-      this.touch(location);
-      return snapshot;
-    }
-  }
-  put(location, snapshot) {
-    this.write(location, snapshot);
-    this.touch(location);
-    return snapshot;
-  }
-  clear() {
-    this.snapshots = {};
-  }
-  read(location) {
-    return this.snapshots[location.toCacheKey()];
+class PageRenderer extends Renderer {
+  get shouldRender() {
+    return this.newSnapshot.isVisitable && this.trackedElementsAreIdentical;
   }
-  write(location, snapshot) {
-    this.snapshots[location.toCacheKey()] = snapshot;
+  prepareToRender() {
+    this.mergeHead();
   }
-  touch(location) {
-    const key = location.toCacheKey();
-    const index = this.keys.indexOf(key);
-    if (index > -1) this.keys.splice(index, 1);
-    this.keys.unshift(key);
-    this.trim();
+  async render() {
+    this.replaceBody();
   }
-  trim() {
-    for (const key of this.keys.splice(this.size)) {
-      delete this.snapshots[key];
+  finishRendering() {
+    super.finishRendering();
+    if (!this.isPreview) {
+      this.focusFirstAutofocusableElement();
     }
   }
-}
-
-class SnapshotRenderer extends Renderer {
-  constructor(delegate, currentSnapshot, newSnapshot, isPreview) {
-    super();
-    this.delegate = delegate;
-    this.currentSnapshot = currentSnapshot;
-    this.currentHeadDetails = currentSnapshot.headDetails;
-    this.newSnapshot = newSnapshot;
-    this.newHeadDetails = newSnapshot.headDetails;
-    this.newBody = newSnapshot.bodyElement;
-    this.isPreview = isPreview;
+  get currentHeadSnapshot() {
+    return this.currentSnapshot.headSnapshot;
   }
-  static render(delegate, callback, currentSnapshot, newSnapshot, isPreview) {
-    return new this(delegate, currentSnapshot, newSnapshot, isPreview).render(callback);
+  get newHeadSnapshot() {
+    return this.newSnapshot.headSnapshot;
   }
-  render(callback) {
-    if (this.shouldRender()) {
-      this.mergeHead();
-      this.renderView((() => {
-        this.replaceBody();
-        if (!this.isPreview) {
-          this.focusFirstAutofocusableElement();
-        }
-        callback();
-      }));
-    } else {
-      this.invalidateView();
-    }
+  get newElement() {
+    return this.newSnapshot.element;
   }
   mergeHead() {
     this.copyNewHeadStylesheetElements();
@@ -2326,190 +2200,145 @@ class SnapshotRenderer extends Renderer {
     this.copyNewHeadProvisionalElements();
   }
   replaceBody() {
-    const placeholders = this.relocateCurrentBodyPermanentElements();
-    this.activateNewBody();
-    this.assignNewBody();
-    this.replacePlaceholderElementsWithClonedPermanentElements(placeholders);
-  }
-  shouldRender() {
-    return this.newSnapshot.isVisitable() && this.trackedElementsAreIdentical();
+    this.preservingPermanentElements((() => {
+      this.activateNewBody();
+      this.assignNewBody();
+    }));
   }
-  trackedElementsAreIdentical() {
-    return this.currentHeadDetails.getTrackedElementSignature() == this.newHeadDetails.getTrackedElementSignature();
+  get trackedElementsAreIdentical() {
+    return this.currentHeadSnapshot.trackedElementSignature == this.newHeadSnapshot.trackedElementSignature;
   }
   copyNewHeadStylesheetElements() {
-    for (const element of this.getNewHeadStylesheetElements()) {
+    for (const element of this.newHeadStylesheetElements) {
       document.head.appendChild(element);
     }
   }
   copyNewHeadScriptElements() {
-    for (const element of this.getNewHeadScriptElements()) {
+    for (const element of this.newHeadScriptElements) {
       document.head.appendChild(this.createScriptElement(element));
     }
   }
   removeCurrentHeadProvisionalElements() {
-    for (const element of this.getCurrentHeadProvisionalElements()) {
+    for (const element of this.currentHeadProvisionalElements) {
       document.head.removeChild(element);
     }
   }
   copyNewHeadProvisionalElements() {
-    for (const element of this.getNewHeadProvisionalElements()) {
+    for (const element of this.newHeadProvisionalElements) {
       document.head.appendChild(element);
     }
   }
-  relocateCurrentBodyPermanentElements() {
-    return this.getCurrentBodyPermanentElements().reduce(((placeholders, permanentElement) => {
-      const newElement = this.newSnapshot.getPermanentElementById(permanentElement.id);
-      if (newElement) {
-        const placeholder = createPlaceholderForPermanentElement(permanentElement);
-        replaceElementWithElement(permanentElement, placeholder.element);
-        replaceElementWithElement(newElement, permanentElement);
-        return [ ...placeholders, placeholder ];
-      } else {
-        return placeholders;
-      }
-    }), []);
-  }
-  replacePlaceholderElementsWithClonedPermanentElements(placeholders) {
-    for (const {element: element, permanentElement: permanentElement} of placeholders) {
-      const clonedElement = permanentElement.cloneNode(true);
-      replaceElementWithElement(element, clonedElement);
-    }
-  }
   activateNewBody() {
-    document.adoptNode(this.newBody);
+    document.adoptNode(this.newElement);
     this.activateNewBodyScriptElements();
   }
   activateNewBodyScriptElements() {
-    for (const inertScriptElement of this.getNewBodyScriptElements()) {
+    for (const inertScriptElement of this.newBodyScriptElements) {
       const activatedScriptElement = this.createScriptElement(inertScriptElement);
-      replaceElementWithElement(inertScriptElement, activatedScriptElement);
+      inertScriptElement.replaceWith(activatedScriptElement);
     }
   }
   assignNewBody() {
-    if (document.body) {
-      replaceElementWithElement(document.body, this.newBody);
+    if (document.body && this.newElement instanceof HTMLBodyElement) {
+      document.body.replaceWith(this.newElement);
     } else {
-      document.documentElement.appendChild(this.newBody);
-    }
-  }
-  focusFirstAutofocusableElement() {
-    const element = this.newSnapshot.findFirstAutofocusableElement();
-    if (elementIsFocusable(element)) {
-      element.focus();
+      document.documentElement.appendChild(this.newElement);
     }
   }
-  getNewHeadStylesheetElements() {
-    return this.newHeadDetails.getStylesheetElementsNotInDetails(this.currentHeadDetails);
-  }
-  getNewHeadScriptElements() {
-    return this.newHeadDetails.getScriptElementsNotInDetails(this.currentHeadDetails);
+  get newHeadStylesheetElements() {
+    return this.newHeadSnapshot.getStylesheetElementsNotInSnapshot(this.currentHeadSnapshot);
   }
-  getCurrentHeadProvisionalElements() {
-    return this.currentHeadDetails.getProvisionalElements();
+  get newHeadScriptElements() {
+    return this.newHeadSnapshot.getScriptElementsNotInSnapshot(this.currentHeadSnapshot);
   }
-  getNewHeadProvisionalElements() {
-    return this.newHeadDetails.getProvisionalElements();
+  get currentHeadProvisionalElements() {
+    return this.currentHeadSnapshot.provisionalElements;
   }
-  getCurrentBodyPermanentElements() {
-    return this.currentSnapshot.getPermanentElementsPresentInSnapshot(this.newSnapshot);
+  get newHeadProvisionalElements() {
+    return this.newHeadSnapshot.provisionalElements;
   }
-  getNewBodyScriptElements() {
-    return [ ...this.newBody.querySelectorAll("script") ];
+  get newBodyScriptElements() {
+    return this.newElement.querySelectorAll("script");
   }
 }
 
-function createPlaceholderForPermanentElement(permanentElement) {
-  const element = document.createElement("meta");
-  element.setAttribute("name", "turbo-permanent-placeholder");
-  element.setAttribute("content", permanentElement.id);
-  return {
-    element: element,
-    permanentElement: permanentElement
-  };
-}
-
-function replaceElementWithElement(fromElement, toElement) {
-  const parentElement = fromElement.parentElement;
-  if (parentElement) {
-    return parentElement.replaceChild(toElement, fromElement);
+class SnapshotCache {
+  constructor(size) {
+    this.keys = [];
+    this.snapshots = {};
+    this.size = size;
+  }
+  has(location) {
+    return toCacheKey(location) in this.snapshots;
+  }
+  get(location) {
+    if (this.has(location)) {
+      const snapshot = this.read(location);
+      this.touch(location);
+      return snapshot;
+    }
+  }
+  put(location, snapshot) {
+    this.write(location, snapshot);
+    this.touch(location);
+    return snapshot;
+  }
+  clear() {
+    this.snapshots = {};
+  }
+  read(location) {
+    return this.snapshots[toCacheKey(location)];
+  }
+  write(location, snapshot) {
+    this.snapshots[toCacheKey(location)] = snapshot;
+  }
+  touch(location) {
+    const key = toCacheKey(location);
+    const index = this.keys.indexOf(key);
+    if (index > -1) this.keys.splice(index, 1);
+    this.keys.unshift(key);
+    this.trim();
+  }
+  trim() {
+    for (const key of this.keys.splice(this.size)) {
+      delete this.snapshots[key];
+    }
   }
 }
 
-function elementIsFocusable(element) {
-  return element && typeof element.focus == "function";
-}
-
-class View {
-  constructor(delegate) {
-    this.htmlElement = document.documentElement;
+class PageView extends View {
+  constructor() {
+    super(...arguments);
     this.snapshotCache = new SnapshotCache(10);
-    this.delegate = delegate;
+    this.lastRenderedLocation = new URL(location.href);
   }
-  getRootLocation() {
-    return this.getSnapshot().getRootLocation();
-  }
-  getElementForAnchor(anchor) {
-    return this.getSnapshot().getElementForAnchor(anchor);
+  renderPage(snapshot, isPreview = false) {
+    const renderer = new PageRenderer(this.snapshot, snapshot, isPreview);
+    return this.render(renderer);
   }
-  getSnapshot() {
-    return Snapshot.fromHTMLElement(this.htmlElement);
+  renderError(snapshot) {
+    const renderer = new ErrorRenderer(this.snapshot, snapshot, false);
+    this.render(renderer);
   }
   clearSnapshotCache() {
     this.snapshotCache.clear();
   }
-  shouldCacheSnapshot() {
-    return this.getSnapshot().isCacheable();
-  }
   async cacheSnapshot() {
-    if (this.shouldCacheSnapshot()) {
+    if (this.shouldCacheSnapshot) {
       this.delegate.viewWillCacheSnapshot();
-      const snapshot = this.getSnapshot();
-      const location = this.lastRenderedLocation || Location.currentLocation;
-      await nextMicrotask();
+      const {snapshot: snapshot, lastRenderedLocation: location} = this;
+      await nextEventLoopTick();
       this.snapshotCache.put(location, snapshot.clone());
     }
   }
   getCachedSnapshotForLocation(location) {
     return this.snapshotCache.get(location);
   }
-  render({snapshot: snapshot, error: error, isPreview: isPreview}, callback) {
-    this.markAsPreview(isPreview);
-    if (snapshot) {
-      this.renderSnapshot(snapshot, isPreview, callback);
-    } else {
-      this.renderError(error, callback);
-    }
-  }
-  scrollToAnchor(anchor) {
-    const element = this.getElementForAnchor(anchor);
-    if (element) {
-      this.scrollToElement(element);
-    } else {
-      this.scrollToPosition({
-        x: 0,
-        y: 0
-      });
-    }
-  }
-  scrollToElement(element) {
-    element.scrollIntoView();
+  get snapshot() {
+    return PageSnapshot.fromElement(this.element);
   }
-  scrollToPosition({x: x, y: y}) {
-    window.scrollTo(x, y);
-  }
-  markAsPreview(isPreview) {
-    if (isPreview) {
-      this.htmlElement.setAttribute("data-turbo-preview", "");
-    } else {
-      this.htmlElement.removeAttribute("data-turbo-preview");
-    }
-  }
-  renderSnapshot(snapshot, isPreview, callback) {
-    SnapshotRenderer.render(this.delegate, callback, this.getSnapshot(), snapshot, isPreview || false);
-  }
-  renderError(error, callback) {
-    ErrorRenderer.render(this.delegate, callback, error || "");
+  get shouldCacheSnapshot() {
+    return this.snapshot.isCacheable;
   }
 }
 
@@ -2517,9 +2346,10 @@ class Session {
   constructor() {
     this.navigator = new Navigator(this);
     this.history = new History(this);
-    this.view = new View(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.scrollObserver = new ScrollObserver(this);
@@ -2532,6 +2362,7 @@ class Session {
   start() {
     if (!this.started) {
       this.pageObserver.start();
+      this.cacheObserver.start();
       this.linkClickObserver.start();
       this.formSubmitObserver.start();
       this.scrollObserver.start();
@@ -2548,6 +2379,7 @@ class Session {
   stop() {
     if (this.started) {
       this.pageObserver.stop();
+      this.cacheObserver.stop();
       this.linkClickObserver.stop();
       this.formSubmitObserver.stop();
       this.scrollObserver.stop();
@@ -2561,7 +2393,7 @@ class Session {
     this.adapter = adapter;
   }
   visit(location, options = {}) {
-    this.navigator.proposeVisit(Location.wrap(location), options);
+    this.navigator.proposeVisit(expandURL(location), options);
   }
   connectStreamSource(source) {
     this.streamObserver.connectStreamSource(source);
@@ -2584,9 +2416,9 @@ class Session {
   get restorationIdentifier() {
     return this.history.restorationIdentifier;
   }
-  historyPoppedToLocationWithRestorationIdentifier(location) {
+  historyPoppedToLocationWithRestorationIdentifier(location, restorationIdentifier) {
     if (this.enabled) {
-      this.navigator.proposeVisit(location, {
+      this.navigator.startVisit(location, restorationIdentifier, {
         action: "restore",
         historyChanged: true
       });
@@ -2594,134 +2426,577 @@ class Session {
       this.adapter.pageInvalidated();
     }
   }
-  scrollPositionChanged(position) {
-    this.history.updateRestorationData({
-      scrollPosition: position
-    });
+  scrollPositionChanged(position) {
+    this.history.updateRestorationData({
+      scrollPosition: position
+    });
+  }
+  willFollowLinkToLocation(link, location) {
+    return elementIsNavigable(link) && this.locationIsVisitable(location) && this.applicationAllowsFollowingLinkToLocation(link, location);
+  }
+  followedLinkToLocation(link, location) {
+    const action = this.getActionForLink(link);
+    this.visit(location.href, {
+      action: action
+    });
+  }
+  allowsVisitingLocation(location) {
+    return this.applicationAllowsVisitingLocation(location);
+  }
+  visitProposedToLocation(location, options) {
+    extendURLWithDeprecatedProperties(location);
+    this.adapter.visitProposedToLocation(location, options);
+  }
+  visitStarted(visit) {
+    extendURLWithDeprecatedProperties(visit.location);
+    this.notifyApplicationAfterVisitingLocation(visit.location);
+  }
+  visitCompleted(visit) {
+    this.notifyApplicationAfterPageLoad(visit.getTimingMetrics());
+  }
+  willSubmitForm(form, submitter) {
+    return elementIsNavigable(form) && elementIsNavigable(submitter);
+  }
+  formSubmitted(form, submitter) {
+    this.navigator.submitForm(form, submitter);
+  }
+  pageBecameInteractive() {
+    this.view.lastRenderedLocation = this.location;
+    this.notifyApplicationAfterPageLoad();
+  }
+  pageLoaded() {
+    this.history.assumeControlOfScrollRestoration();
+  }
+  pageWillUnload() {
+    this.history.relinquishControlOfScrollRestoration();
+  }
+  receivedMessageFromStream(message) {
+    this.renderStreamMessage(message);
+  }
+  viewWillCacheSnapshot() {
+    this.notifyApplicationBeforeCachingSnapshot();
+  }
+  viewWillRenderSnapshot({element: element}, isPreview) {
+    this.notifyApplicationBeforeRender(element);
+  }
+  viewRenderedSnapshot(snapshot, isPreview) {
+    this.view.lastRenderedLocation = this.history.location;
+    this.notifyApplicationAfterRender();
+  }
+  viewInvalidated() {
+    this.adapter.pageInvalidated();
+  }
+  applicationAllowsFollowingLinkToLocation(link, location) {
+    const event = this.notifyApplicationAfterClickingLinkToLocation(link, location);
+    return !event.defaultPrevented;
+  }
+  applicationAllowsVisitingLocation(location) {
+    const event = this.notifyApplicationBeforeVisitingLocation(location);
+    return !event.defaultPrevented;
+  }
+  notifyApplicationAfterClickingLinkToLocation(link, location) {
+    return dispatch("turbo:click", {
+      target: link,
+      detail: {
+        url: location.href
+      },
+      cancelable: true
+    });
+  }
+  notifyApplicationBeforeVisitingLocation(location) {
+    return dispatch("turbo:before-visit", {
+      detail: {
+        url: location.href
+      },
+      cancelable: true
+    });
+  }
+  notifyApplicationAfterVisitingLocation(location) {
+    return dispatch("turbo:visit", {
+      detail: {
+        url: location.href
+      }
+    });
+  }
+  notifyApplicationBeforeCachingSnapshot() {
+    return dispatch("turbo:before-cache");
+  }
+  notifyApplicationBeforeRender(newBody) {
+    return dispatch("turbo:before-render", {
+      detail: {
+        newBody: newBody
+      }
+    });
+  }
+  notifyApplicationAfterRender() {
+    return dispatch("turbo:render");
+  }
+  notifyApplicationAfterPageLoad(timing = {}) {
+    return dispatch("turbo:load", {
+      detail: {
+        url: this.location.href,
+        timing: timing
+      }
+    });
+  }
+  getActionForLink(link) {
+    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;
+  }
+}
+
+function elementIsNavigable(element) {
+  const container = element === null || element === void 0 ? void 0 : element.closest("[data-turbo]");
+  if (container) {
+    return container.getAttribute("data-turbo") != "false";
+  } else {
+    return true;
+  }
+}
+
+function extendURLWithDeprecatedProperties(url) {
+  Object.defineProperties(url, deprecatedLocationPropertyDescriptors);
+}
+
+const deprecatedLocationPropertyDescriptors = {
+  absoluteURL: {
+    get() {
+      return this.toString();
+    }
+  }
+};
+
+class FrameController {
+  constructor(element) {
+    this.resolveVisitPromise = () => {};
+    this.connected = false;
+    this.hasBeenLoaded = false;
+    this.settingSourceURL = false;
+    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);
+  }
+  connect() {
+    if (!this.connected) {
+      this.connected = true;
+      if (this.loadingStyle == FrameLoadingStyle.lazy) {
+        this.appearanceObserver.start();
+      }
+      this.linkInterceptor.start();
+      this.formInterceptor.start();
+      this.sourceURLChanged();
+    }
+  }
+  disconnect() {
+    if (this.connected) {
+      this.connected = false;
+      this.appearanceObserver.stop();
+      this.linkInterceptor.stop();
+      this.formInterceptor.stop();
+    }
+  }
+  disabledChanged() {
+    if (this.loadingStyle == FrameLoadingStyle.eager) {
+      this.loadSourceURL();
+    }
+  }
+  sourceURLChanged() {
+    if (this.loadingStyle == FrameLoadingStyle.eager || this.hasBeenLoaded) {
+      this.loadSourceURL();
+    }
+  }
+  loadingStyleChanged() {
+    if (this.loadingStyle == FrameLoadingStyle.lazy) {
+      this.appearanceObserver.start();
+    } else {
+      this.appearanceObserver.stop();
+      this.loadSourceURL();
+    }
+  }
+  async loadSourceURL() {
+    if (!this.settingSourceURL && this.enabled && this.isActive && this.sourceURL != this.currentURL) {
+      const previousURL = this.currentURL;
+      this.currentURL = this.sourceURL;
+      if (this.sourceURL) {
+        try {
+          this.element.loaded = this.visit(this.sourceURL);
+          this.appearanceObserver.stop();
+          await this.element.loaded;
+          this.hasBeenLoaded = true;
+        } catch (error) {
+          this.currentURL = previousURL;
+          throw error;
+        }
+      }
+    }
+  }
+  async loadResponse(fetchResponse) {
+    if (fetchResponse.redirected) {
+      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);
+        await this.view.render(renderer);
+      }
+    } catch (error) {
+      console.error(error);
+      this.view.invalidate();
+    }
+  }
+  elementAppearedInViewport(element) {
+    this.loadSourceURL();
+  }
+  shouldInterceptLinkClick(element, url) {
+    return this.shouldInterceptNavigation(element);
+  }
+  linkClickIntercepted(element, url) {
+    this.navigateFrame(element, url);
+  }
+  shouldInterceptFormSubmission(element, submitter) {
+    return this.shouldInterceptNavigation(element, submitter);
+  }
+  formSubmissionIntercepted(element, submitter) {
+    if (this.formSubmission) {
+      this.formSubmission.stop();
+    }
+    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();
+    }
+  }
+  prepareHeadersForRequest(headers, request) {
+    headers["Turbo-Frame"] = this.id;
+  }
+  requestStarted(request) {
+    this.element.setAttribute("busy", "");
+  }
+  requestPreventedHandlingResponse(request, response) {
+    this.resolveVisitPromise();
+  }
+  async requestSucceededWithResponse(request, response) {
+    await this.loadResponse(response);
+    this.resolveVisitPromise();
+  }
+  requestFailedWithResponse(request, response) {
+    console.error(response);
+    this.resolveVisitPromise();
+  }
+  requestErrored(request, error) {
+    console.error(error);
+    this.resolveVisitPromise();
+  }
+  requestFinished(request) {
+    this.element.removeAttribute("busy");
+  }
+  formSubmissionStarted(formSubmission) {
+    const frame = this.findFrameElement(formSubmission.formElement);
+    frame.setAttribute("busy", "");
+  }
+  formSubmissionSucceededWithResponse(formSubmission, response) {
+    const frame = this.findFrameElement(formSubmission.formElement);
+    frame.delegate.loadResponse(response);
+  }
+  formSubmissionFailedWithResponse(formSubmission, fetchResponse) {
+    this.element.delegate.loadResponse(fetchResponse);
+  }
+  formSubmissionErrored(formSubmission, error) {
+    console.error(error);
+  }
+  formSubmissionFinished(formSubmission) {
+    const frame = this.findFrameElement(formSubmission.formElement);
+    frame.removeAttribute("busy");
+  }
+  viewWillRenderSnapshot(snapshot, isPreview) {}
+  viewRenderedSnapshot(snapshot, isPreview) {}
+  viewInvalidated() {}
+  async visit(url) {
+    const request = new FetchRequest(this, FetchMethod.get, expandURL(url));
+    return new Promise((resolve => {
+      this.resolveVisitPromise = () => {
+        this.resolveVisitPromise = () => {};
+        resolve();
+      };
+      request.perform();
+    }));
+  }
+  navigateFrame(element, url) {
+    const frame = this.findFrameElement(element);
+    frame.src = url;
+  }
+  findFrameElement(element) {
+    var _a;
+    const id = element.getAttribute("data-turbo-frame") || 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)) {
+        return element;
+      }
+      if (element = activateElement(container.querySelector(`turbo-frame[src][recurse~=${id}]`), this.currentURL)) {
+        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;
+  }
+  shouldInterceptNavigation(element, submitter) {
+    const id = element.getAttribute("data-turbo-frame") || this.element.getAttribute("target");
+    if (!this.enabled || id == "_top") {
+      return false;
+    }
+    if (id) {
+      const frameElement = getFrameElementById(id);
+      if (frameElement) {
+        return !frameElement.disabled;
+      }
+    }
+    if (!elementIsNavigable(element)) {
+      return false;
+    }
+    if (submitter && !elementIsNavigable(submitter)) {
+      return false;
+    }
+    return true;
   }
-  willFollowLinkToLocation(link, location) {
-    return this.elementIsNavigable(link) && this.locationIsVisitable(location) && this.applicationAllowsFollowingLinkToLocation(link, location);
+  get id() {
+    return this.element.id;
   }
-  followedLinkToLocation(link, location) {
-    const action = this.getActionForLink(link);
-    this.visit(location, {
-      action: action
-    });
+  get enabled() {
+    return !this.element.disabled;
   }
-  allowsVisitingLocation(location) {
-    return this.applicationAllowsVisitingLocation(location);
+  get sourceURL() {
+    if (this.element.src) {
+      return this.element.src;
+    }
   }
-  visitProposedToLocation(location, options) {
-    this.adapter.visitProposedToLocation(location, options);
+  set sourceURL(sourceURL) {
+    this.settingSourceURL = true;
+    this.element.src = sourceURL !== null && sourceURL !== void 0 ? sourceURL : null;
+    this.currentURL = this.element.src;
+    this.settingSourceURL = false;
   }
-  visitStarted(visit) {
-    this.notifyApplicationAfterVisitingLocation(visit.location);
+  get loadingStyle() {
+    return this.element.loading;
   }
-  visitCompleted(visit) {
-    this.notifyApplicationAfterPageLoad(visit.getTimingMetrics());
+  get isLoading() {
+    return this.formSubmission !== undefined || this.resolveVisitPromise() !== undefined;
   }
-  willSubmitForm(form, submitter) {
-    return this.elementIsNavigable(form) && this.elementIsNavigable(submitter);
+  get isActive() {
+    return this.element.isActive && this.connected;
   }
-  formSubmitted(form, submitter) {
-    this.navigator.submitForm(form, submitter);
+}
+
+function getFrameElementById(id) {
+  if (id != null) {
+    const element = document.getElementById(id);
+    if (element instanceof FrameElement) {
+      return element;
+    }
   }
-  pageBecameInteractive() {
-    this.view.lastRenderedLocation = this.location;
-    this.notifyApplicationAfterPageLoad();
+}
+
+function activateElement(element, currentURL) {
+  if (element) {
+    const src = element.getAttribute("src");
+    if (src != null && currentURL != null && urlsAreEqual(src, currentURL)) {
+      throw new Error(`Matching <turbo-frame id="${element.id}"> element has a source URL which references itself`);
+    }
+    if (element.ownerDocument !== document) {
+      element = document.importNode(element, true);
+    }
+    if (element instanceof FrameElement) {
+      element.connectedCallback();
+      return element;
+    }
   }
-  pageLoaded() {
-    this.history.assumeControlOfScrollRestoration();
+}
+
+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);
+    }));
   }
-  pageWillUnload() {
-    this.history.relinquishControlOfScrollRestoration();
+};
+
+class StreamElement extends HTMLElement {
+  async connectedCallback() {
+    try {
+      await this.render();
+    } catch (error) {
+      console.error(error);
+    } finally {
+      this.disconnect();
+    }
   }
-  receivedMessageFromStream(message) {
-    this.renderStreamMessage(message);
+  async render() {
+    var _a;
+    return (_a = this.renderPromise) !== null && _a !== void 0 ? _a : this.renderPromise = (async () => {
+      if (this.dispatchEvent(this.beforeRenderEvent)) {
+        await nextAnimationFrame();
+        this.performAction();
+      }
+    })();
   }
-  viewWillRender(newBody) {
-    this.notifyApplicationBeforeRender(newBody);
+  disconnect() {
+    try {
+      this.remove();
+    } catch (_a) {}
   }
-  viewRendered() {
-    this.view.lastRenderedLocation = this.history.location;
-    this.notifyApplicationAfterRender();
+  removeDuplicateTargetChildren() {
+    this.duplicateChildren.forEach((c => c.remove()));
   }
-  viewInvalidated() {
-    this.adapter.pageInvalidated();
+  get duplicateChildren() {
+    var _a;
+    const existingChildren = this.targetElements.flatMap((e => [ ...e.children ])).filter((c => !!c.id));
+    const newChildrenIds = [ ...(_a = this.templateContent) === null || _a === void 0 ? void 0 : _a.children ].filter((c => !!c.id)).map((c => c.id));
+    return existingChildren.filter((c => newChildrenIds.includes(c.id)));
   }
-  viewWillCacheSnapshot() {
-    this.notifyApplicationBeforeCachingSnapshot();
+  get performAction() {
+    if (this.action) {
+      const actionFunction = StreamActions[this.action];
+      if (actionFunction) {
+        return actionFunction;
+      }
+      this.raise("unknown action");
+    }
+    this.raise("action attribute is missing");
   }
-  applicationAllowsFollowingLinkToLocation(link, location) {
-    const event = this.notifyApplicationAfterClickingLinkToLocation(link, location);
-    return !event.defaultPrevented;
+  get targetElements() {
+    if (this.target) {
+      return this.targetElementsById;
+    } else if (this.targets) {
+      return this.targetElementsByQuery;
+    } else {
+      this.raise("target or targets attribute is missing");
+    }
   }
-  applicationAllowsVisitingLocation(location) {
-    const event = this.notifyApplicationBeforeVisitingLocation(location);
-    return !event.defaultPrevented;
+  get templateContent() {
+    return this.templateElement.content.cloneNode(true);
   }
-  notifyApplicationAfterClickingLinkToLocation(link, location) {
-    return dispatch("turbo:click", {
-      target: link,
-      detail: {
-        url: location.absoluteURL
-      },
-      cancelable: true
-    });
+  get templateElement() {
+    if (this.firstElementChild instanceof HTMLTemplateElement) {
+      return this.firstElementChild;
+    }
+    this.raise("first child element must be a <template> element");
   }
-  notifyApplicationBeforeVisitingLocation(location) {
-    return dispatch("turbo:before-visit", {
-      detail: {
-        url: location.absoluteURL
-      },
-      cancelable: true
-    });
+  get action() {
+    return this.getAttribute("action");
   }
-  notifyApplicationAfterVisitingLocation(location) {
-    return dispatch("turbo:visit", {
-      detail: {
-        url: location.absoluteURL
-      }
-    });
+  get target() {
+    return this.getAttribute("target");
   }
-  notifyApplicationBeforeCachingSnapshot() {
-    return dispatch("turbo:before-cache");
+  get targets() {
+    return this.getAttribute("targets");
   }
-  notifyApplicationBeforeRender(newBody) {
-    return dispatch("turbo:before-render", {
-      detail: {
-        newBody: newBody
-      }
-    });
+  raise(message) {
+    throw new Error(`${this.description}: ${message}`);
   }
-  notifyApplicationAfterRender() {
-    return dispatch("turbo:render");
+  get description() {
+    var _a, _b;
+    return (_b = ((_a = this.outerHTML.match(/<[^>]+>/)) !== null && _a !== void 0 ? _a : [])[0]) !== null && _b !== void 0 ? _b : "<turbo-stream>";
   }
-  notifyApplicationAfterPageLoad(timing = {}) {
-    return dispatch("turbo:load", {
-      detail: {
-        url: this.location.absoluteURL,
-        timing: timing
-      }
+  get beforeRenderEvent() {
+    return new CustomEvent("turbo:before-stream-render", {
+      bubbles: true,
+      cancelable: true
     });
   }
-  getActionForLink(link) {
-    const action = link.getAttribute("data-turbo-action");
-    return isAction(action) ? action : "advance";
-  }
-  elementIsNavigable(element) {
-    const container = element === null || element === void 0 ? void 0 : element.closest("[data-turbo]");
-    if (container) {
-      return container.getAttribute("data-turbo") != "false";
+  get targetElementsById() {
+    var _a;
+    const element = (_a = this.ownerDocument) === null || _a === void 0 ? void 0 : _a.getElementById(this.target);
+    if (element !== null) {
+      return [ element ];
     } else {
-      return true;
+      return [];
     }
   }
-  locationIsVisitable(location) {
-    return location.isPrefixedBy(this.view.getRootLocation()) && location.isHTML();
+  get targetElementsByQuery() {
+    var _a;
+    const elements = (_a = this.ownerDocument) === null || _a === void 0 ? void 0 : _a.querySelectorAll(this.targets);
+    if (elements.length !== 0) {
+      return Array.prototype.slice.call(elements);
+    } else {
+      return [];
+    }
   }
 }
 
+FrameElement.delegateConstructor = FrameController;
+
+customElements.define("turbo-frame", FrameElement);
+
+customElements.define("turbo-stream", StreamElement);
+
+(() => {
+  let element = document.currentScript;
+  if (!element) return;
+  if (element.hasAttribute("data-turbo-suppress-warning")) return;
+  while (element = element.parentElement) {
+    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!
+
+        Load your application’s JavaScript bundle inside the <head> element instead. <script> elements in <body> are evaluated with each page change.
+
+        For more information, see: https://turbo.hotwire.dev/handbook/building#working-with-script-elements
+
+        ——
+        Suppress this warning by adding a "data-turbo-suppress-warning" attribute to: %s
+      `, element.outerHTML);
+    }
+  }
+})();
+
 const session = new Session;
 
 const {navigator: navigator} = session;
@@ -2758,6 +3033,21 @@ function setProgressBarDelay(delay) {
   session.setProgressBarDelay(delay);
 }
 
+var Turbo = Object.freeze({
+  __proto__: null,
+  navigator: navigator,
+  start: start,
+  registerAdapter: registerAdapter,
+  visit: visit,
+  connectStreamSource: connectStreamSource,
+  disconnectStreamSource: disconnectStreamSource,
+  renderStreamMessage: renderStreamMessage,
+  clearCache: clearCache,
+  setProgressBarDelay: setProgressBarDelay
+});
+
+window.Turbo = Turbo;
+
 start();
 
 var turbo_es2017Esm = Object.freeze({
@@ -2776,17 +3066,20 @@ var turbo_es2017Esm = Object.freeze({
 let consumer;
 
 async function getConsumer() {
-  if (consumer) return consumer;
-  const {createConsumer: createConsumer} = await Promise.resolve().then((function() {
-    return index;
-  }));
-  return setConsumer(createConsumer());
+  return consumer || setConsumer(createConsumer().then(setConsumer));
 }
 
 function setConsumer(newConsumer) {
   return consumer = newConsumer;
 }
 
+async function createConsumer() {
+  const {createConsumer: createConsumer} = await Promise.resolve().then((function() {
+    return index;
+  }));
+  return createConsumer();
+}
+
 async function subscribeTo(channel, mixin) {
   const {subscriptions: subscriptions} = await getConsumer();
   return subscriptions.create(channel, mixin);
@@ -2796,6 +3089,7 @@ var cable = Object.freeze({
   __proto__: null,
   getConsumer: getConsumer,
   setConsumer: setConsumer,
+  createConsumer: createConsumer,
   subscribeTo: subscribeTo
 });
 
@@ -3259,7 +3553,7 @@ function createWebSocketURL(url) {
   }
 }
 
-function createConsumer(url = getConfig("url") || INTERNAL.default_mount_path) {
+function createConsumer$1(url = getConfig("url") || INTERNAL.default_mount_path) {
   return new Consumer(url);
 }
 
@@ -3281,7 +3575,7 @@ var index = Object.freeze({
   adapters: adapters,
   createWebSocketURL: createWebSocketURL,
   logger: logger,
-  createConsumer: createConsumer,
+  createConsumer: createConsumer$1,
   getConfig: getConfig
 });