@alignable/bifrost 0.0.14 → 0.0.15

package/dist/chunk-ABW2IXO4.js

@@ -0,0 +1,936 @@
+// lib/renderReact.ts
+import { createRoot, hydrateRoot } from "react-dom/client";
+var root;
+function renderReact(page, isHydration) {
+  const container = document.getElementById("page-view");
+  if (isHydration) {
+    root = hydrateRoot(container, page);
+  } else {
+    if (!root) {
+      root = createRoot(container);
+    }
+    root.render(page);
+  }
+}
+
+// lib/turbolinks/util.ts
+function array(values) {
+  return Array.prototype.slice.call(values);
+}
+var closest = (() => {
+  const html = document.documentElement;
+  const match = html.matches || html.webkitMatchesSelector || html.msMatchesSelector || html.mozMatchesSelector;
+  const closest2 = html.closest || function(selector) {
+    let element = this;
+    while (element) {
+      if (match.call(element, selector)) {
+        return element;
+      } else {
+        element = element.parentElement;
+      }
+    }
+  };
+  return function(element, selector) {
+    return closest2.call(element, selector);
+  };
+})();
+function defer(callback) {
+  setTimeout(callback, 1);
+}
+function dispatch(eventName, { target, cancelable, data } = {}) {
+  const event = document.createEvent("Events");
+  event.initEvent(eventName, true, cancelable == true);
+  event.data = data || {};
+  if (event.cancelable && !preventDefaultSupported) {
+    const { preventDefault } = event;
+    event.preventDefault = function() {
+      if (!this.defaultPrevented) {
+        Object.defineProperty(this, "defaultPrevented", { get: () => true });
+      }
+      preventDefault.call(this);
+    };
+  }
+  (target || document).dispatchEvent(event);
+  return event;
+}
+var preventDefaultSupported = (() => {
+  const event = document.createEvent("Events");
+  event.initEvent("test", true, true);
+  event.preventDefault();
+  return event.defaultPrevented;
+})();
+function unindent(strings, ...values) {
+  const lines = trimLeft(interpolate(strings, values)).split("\n");
+  const match = lines[0].match(/^\s+/);
+  const indent = match ? match[0].length : 0;
+  return lines.map((line) => line.slice(indent)).join("\n");
+}
+function trimLeft(string) {
+  return string.replace(/^\n/, "");
+}
+function interpolate(strings, values) {
+  return strings.reduce((result, string, i) => {
+    const value = values[i] == void 0 ? "" : values[i];
+    return result + string + value;
+  }, "");
+}
+function uuid() {
+  return Array.apply(null, { length: 36 }).map((_, i) => {
+    if (i == 8 || i == 13 || i == 18 || i == 23) {
+      return "-";
+    } else if (i == 14) {
+      return "4";
+    } else if (i == 19) {
+      return (Math.floor(Math.random() * 4) + 8).toString(16);
+    } else {
+      return Math.floor(Math.random() * 15).toString(16);
+    }
+  }).join("");
+}
+function createScriptElement(element, cb) {
+  if (element.getAttribute("data-turbolinks-eval") == "false") {
+    return element;
+  } else {
+    const createdScriptElement = document.createElement("script");
+    createdScriptElement.textContent = element.textContent;
+    createdScriptElement.async = false;
+    copyElementAttributes(createdScriptElement, element);
+    if (cb) {
+      createdScriptElement.addEventListener("load", cb);
+    }
+    return createdScriptElement;
+  }
+}
+function copyElementAttributes(destinationElement, sourceElement) {
+  for (const { name, value } of array(sourceElement.attributes)) {
+    destinationElement.setAttribute(name, value);
+  }
+}
+function replaceElementWithElement(fromElement, toElement) {
+  const parentElement = fromElement.parentElement;
+  if (parentElement) {
+    return parentElement.replaceChild(toElement, fromElement);
+  }
+}
+function activateNewBodyScriptElements(newScriptElements) {
+  for (const inertScriptElement of newScriptElements) {
+    const activatedScriptElement = createScriptElement(inertScriptElement);
+    replaceElementWithElement(inertScriptElement, activatedScriptElement);
+  }
+}
+function focusFirstAutofocusableElement() {
+  const element = document.body.querySelector("[autofocus]");
+  if (element && "focus" in element && typeof element.focus === "function") {
+    element.focus();
+  }
+}
+
+// lib/turbolinks/mergeHead.ts
+var allHeadScriptsEverRun = {};
+var firstLoad = true;
+var lastTrackedScriptSignature;
+async function mergeHead(head, trackScripts, reload) {
+  const newHead = categorizeHead(head);
+  const oldHead = categorizeHead(document.head);
+  if (head.querySelector('meta[name="turbolinks-visit-control"]')?.getAttribute("content") === "reload") {
+    reload();
+  }
+  if (trackScripts) {
+    lastTrackedScriptSignature = lastTrackedScriptSignature || trackedElementSignature([...oldHead.scripts, ...oldHead.stylesheets]);
+    if (lastTrackedScriptSignature !== trackedElementSignature([...newHead.scripts, ...newHead.stylesheets])) {
+      reload();
+    }
+  }
+  if (firstLoad) {
+    for (const element of oldHead.scripts) {
+      allHeadScriptsEverRun[element.outerHTML] = {
+        tracked: elementIsTracked(element)
+      };
+    }
+    firstLoad = false;
+  }
+  copyNewHeadStylesheetElements(newHead.stylesheets, oldHead.stylesheets);
+  removeCurrentHeadProvisionalElements(oldHead.provisional);
+  copyNewHeadProvisionalElements(newHead.provisional);
+  return new Promise((resolve) => {
+    copyNewHeadScriptElements(newHead.scripts, resolve);
+  });
+}
+function trackedElementSignature(scripts) {
+  return scripts.filter(elementIsTracked).map((s) => s.outerHTML).join();
+}
+function copyNewHeadStylesheetElements(next, prev) {
+  const existing = prev.map((s) => s.outerHTML);
+  for (const element of next) {
+    if (!existing.includes(element.outerHTML)) {
+      document.head.appendChild(element);
+    }
+  }
+}
+function copyNewHeadScriptElements(next, onScriptsLoaded) {
+  let blockingLoaded = [];
+  function dispatch2() {
+    onScriptsLoaded();
+  }
+  for (const element of next) {
+    const runBefore = element.outerHTML in allHeadScriptsEverRun;
+    if (!runBefore) {
+      let cb;
+      if (!element.defer && element.src) {
+        const idx = blockingLoaded.length;
+        cb = () => {
+          blockingLoaded[idx] = true;
+          if (blockingLoaded.every((v) => v)) {
+            dispatch2();
+          }
+        };
+        blockingLoaded.push(false);
+      }
+      document.head.appendChild(createScriptElement(element, cb));
+      allHeadScriptsEverRun[element.outerHTML] = {
+        tracked: elementIsTracked(element)
+      };
+    }
+  }
+  if (blockingLoaded.length === 0) {
+    requestAnimationFrame(dispatch2);
+  }
+}
+function removeCurrentHeadProvisionalElements(prev) {
+  for (const element of prev) {
+    document.head.removeChild(element);
+  }
+}
+function copyNewHeadProvisionalElements(next) {
+  for (const element of next) {
+    document.head.appendChild(element);
+  }
+}
+function elementIsTracked(element) {
+  return element.getAttribute("data-turbolinks-track") == "reload";
+}
+function elementIsScript(element) {
+  const tagName = element.tagName.toLowerCase();
+  return tagName == "script";
+}
+function elementIsStylesheet(element) {
+  const tagName = element.tagName.toLowerCase();
+  return tagName == "style" || tagName == "link" && element.getAttribute("rel") == "stylesheet";
+}
+function categorizeHead(head) {
+  const scripts = [];
+  const stylesheets = [];
+  const provisional = [];
+  for (const element of head.children) {
+    if (elementIsScript(element)) {
+      scripts.push(element);
+    } else if (elementIsStylesheet(element)) {
+      stylesheets.push(element);
+    } else {
+      provisional.push(element);
+    }
+  }
+  return { scripts, stylesheets, provisional };
+}
+
+// lib/turbolinks/lruCache.ts
+var LruCache = class {
+  constructor(maxEntries) {
+    this.values = /* @__PURE__ */ new Map();
+    this.maxEntries = maxEntries;
+  }
+  get(key) {
+    const hasKey = this.values.has(key);
+    let entry;
+    if (hasKey) {
+      entry = this.values.get(key);
+      this.values.delete(key);
+      this.values.set(key, entry);
+    }
+    return entry;
+  }
+  put(key, value) {
+    if (this.values.size >= this.maxEntries) {
+      const keyToDelete = this.values.keys().next().value;
+      this.values.delete(keyToDelete);
+    }
+    this.values.set(key, value);
+  }
+};
+
+// lib/turbolinks/progress_bar.ts
+var _ProgressBar = class _ProgressBar {
+  constructor() {
+    this.stylesheetElement = this.createStylesheetElement();
+    this.progressElement = this.createProgressElement();
+    this.hiding = false;
+    this.value = 0;
+    this.visible = false;
+    this.trickle = () => {
+      this.setValue(this.value + Math.random() / 100);
+    };
+  }
+  /*ms*/
+  static get defaultCSS() {
+    return unindent`
+      .turbolinks-progress-bar {
+        position: fixed;
+        display: block;
+        top: 0;
+        left: 0;
+        height: 3px;
+        background: #0076ff;
+        z-index: 9999;
+        transition:
+          width ${_ProgressBar.animationDuration}ms ease-out,
+          opacity ${_ProgressBar.animationDuration / 2}ms ${_ProgressBar.animationDuration / 2}ms ease-in;
+        transform: translate3d(0, 0, 0);
+      }
+    `;
+  }
+  show() {
+    if (!this.visible) {
+      this.visible = true;
+      this.installStylesheetElement();
+      this.installProgressElement();
+      this.startTrickling();
+    }
+  }
+  hide() {
+    if (this.visible && !this.hiding) {
+      this.hiding = true;
+      this.fadeProgressElement(() => {
+        this.uninstallProgressElement();
+        this.stopTrickling();
+        this.visible = false;
+        this.hiding = false;
+      });
+    }
+  }
+  setValue(value) {
+    this.value = value;
+    this.refresh();
+  }
+  // Private
+  installStylesheetElement() {
+    document.head.insertBefore(
+      this.stylesheetElement,
+      document.head.firstChild
+    );
+  }
+  installProgressElement() {
+    this.progressElement.style.width = "0";
+    this.progressElement.style.opacity = "1";
+    document.documentElement.insertBefore(this.progressElement, document.body);
+    this.refresh();
+  }
+  fadeProgressElement(callback) {
+    this.progressElement.style.opacity = "0";
+    setTimeout(callback, _ProgressBar.animationDuration * 1.5);
+  }
+  uninstallProgressElement() {
+    if (this.progressElement.parentNode) {
+      document.documentElement.removeChild(this.progressElement);
+    }
+  }
+  startTrickling() {
+    if (!this.trickleInterval) {
+      this.trickleInterval = window.setInterval(
+        this.trickle,
+        _ProgressBar.animationDuration
+      );
+    }
+  }
+  stopTrickling() {
+    window.clearInterval(this.trickleInterval);
+    delete this.trickleInterval;
+  }
+  refresh() {
+    requestAnimationFrame(() => {
+      this.progressElement.style.width = `${10 + this.value * 90}%`;
+    });
+  }
+  createStylesheetElement() {
+    const element = document.createElement("style");
+    element.type = "text/css";
+    element.textContent = _ProgressBar.defaultCSS;
+    return element;
+  }
+  createProgressElement() {
+    const element = document.createElement("div");
+    element.className = "turbolinks-progress-bar";
+    return element;
+  }
+};
+_ProgressBar.animationDuration = 300;
+var ProgressBar = _ProgressBar;
+
+// lib/turbolinks/browser_adapter.ts
+var BrowserAdapter = class {
+  constructor(controller2) {
+    this.progressBar = new ProgressBar();
+    this.showProgressBar = () => {
+      this.progressBar.show();
+    };
+    this.controller = controller2;
+  }
+  visitProposedToLocationWithAction(location, action) {
+    this.controller.startVisitToLocationWithAction(
+      location,
+      action
+    );
+  }
+  visitStarted(visit) {
+    visit.issueRequest();
+    visit.changeHistory();
+    visit.loadCachedSnapshot();
+  }
+  visitRequestStarted(visit) {
+    this.progressBar.setValue(0);
+    if (visit.hasCachedSnapshot() || visit.action != "restore") {
+      this.showProgressBarAfterDelay();
+    } else {
+      this.showProgressBar();
+    }
+  }
+  visitRequestProgressed(visit) {
+    this.progressBar.setValue(visit.progress);
+  }
+  visitRequestCompleted(visit) {
+    visit.loadResponse();
+  }
+  visitRequestFailedWithStatusCode(visit, statusCode) {
+    switch (statusCode) {
+      default:
+        return visit.loadResponse();
+    }
+  }
+  visitRequestFinished(visit) {
+    this.hideProgressBar();
+  }
+  visitCompleted(visit) {
+  }
+  pageInvalidated() {
+    this.reload();
+  }
+  visitFailed(visit) {
+  }
+  visitRendered(visit) {
+  }
+  // Private
+  showProgressBarAfterDelay() {
+    this.progressBarTimeout = window.setTimeout(
+      this.showProgressBar,
+      this.controller.progressBarDelay
+    );
+  }
+  hideProgressBar() {
+    this.progressBar.hide();
+    if (this.progressBarTimeout != null) {
+      window.clearTimeout(this.progressBarTimeout);
+      delete this.progressBarTimeout;
+    }
+  }
+  reload() {
+    window.location.reload();
+  }
+};
+
+// lib/turbolinks/location.ts
+var Location = class {
+  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;
+    }
+  }
+  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);
+    }
+  }
+  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;
+  }
+  valueOf() {
+    return this.absoluteURL;
+  }
+};
+function getPrefixURL(location) {
+  return addTrailingSlash(location.getOrigin() + location.getPath());
+}
+function addTrailingSlash(url) {
+  return stringEndsWith(url, "/") ? url : url + "/";
+}
+function stringStartsWith(string, prefix) {
+  return string.slice(0, prefix.length) === prefix;
+}
+function stringEndsWith(string, suffix) {
+  return string.slice(-suffix.length) === suffix;
+}
+
+// lib/turbolinks/types.ts
+function isAction(action) {
+  return action == "advance" || action == "replace" || action == "restore";
+}
+
+// lib/turbolinks/visit.ts
+import { navigate } from "vite-plugin-ssr/client/router";
+var Visit = class {
+  constructor(controller2, location, action, restorationIdentifier = uuid()) {
+    this.identifier = uuid();
+    this.timingMetrics = {};
+    this.progress = 0;
+    this.snapshotCached = false;
+    this.state = "initialized" /* initialized */;
+    this.requestInFlight = false;
+    this.controller = controller2;
+    this.location = location;
+    this.action = action;
+    this.adapter = controller2.adapter;
+    this.restorationIdentifier = restorationIdentifier;
+  }
+  start() {
+    if (this.state == "initialized" /* initialized */) {
+      this.recordTimingMetric("visitStart" /* visitStart */);
+      this.state = "started" /* started */;
+      this.adapter.visitStarted(this);
+    }
+  }
+  cancel() {
+    if (this.state == "started" /* started */) {
+      this.requestInFlight = false;
+      this.cancelRender();
+      this.state = "canceled" /* canceled */;
+    }
+  }
+  complete() {
+    if (this.state == "started" /* started */) {
+      this.recordTimingMetric("visitEnd" /* visitEnd */);
+      this.state = "completed" /* completed */;
+      this.adapter.visitCompleted(this);
+      this.controller.visitCompleted(this);
+    }
+  }
+  fail() {
+    if (this.state == "started" /* started */) {
+      this.state = "failed" /* failed */;
+      this.adapter.visitFailed(this);
+    }
+  }
+  changeHistory() {
+    return;
+  }
+  issueRequest() {
+    if (!this.requestInFlight) {
+      if (this.shouldIssueRequest()) {
+        const url = new URL(
+          this.location.toString(),
+          this.location.getOrigin()
+        );
+        navigate(url.pathname + url.hash + url.search, {
+          overwriteLastHistoryEntry: this.action === "replace"
+        }).catch(console.error);
+        this.progress = 0;
+        this.requestInFlight = true;
+      }
+    }
+  }
+  getCachedSnapshot() {
+    const snapshot = this.controller.getCachedSnapshotForLocation(
+      this.location
+    );
+    if (snapshot) {
+      if (this.action == "restore") {
+        return snapshot;
+      }
+    }
+  }
+  hasCachedSnapshot() {
+    return this.getCachedSnapshot() != null;
+  }
+  loadCachedSnapshot() {
+    return;
+  }
+  loadResponse() {
+    this.render(async () => {
+      if (!this.renderFn)
+        throw new Error("Render details not set before rendering");
+      this.cacheSnapshot();
+      await this.renderFn();
+      this.complete();
+    });
+  }
+  // HTTP request delegate
+  /*
+    requestStarted() {
+      this.recordTimingMetric(TimingMetric.requestStart);
+      this.adapter.visitRequestStarted(this);
+    }
+  
+    requestProgressed(progress: number) {
+      this.progress = progress;
+      if (this.adapter.visitRequestProgressed) {
+        this.adapter.visitRequestProgressed(this);
+      }
+    }
+  
+    requestCompletedWithResponse(
+      response: string,
+      redirectedToLocation?: Location
+    ) {
+      this.response = response;
+      this.redirectedToLocation = redirectedToLocation;
+      this.adapter.visitRequestCompleted(this);
+    }
+  
+    requestFailedWithStatusCode(statusCode: number, response?: string) {
+      this.response = response;
+      this.adapter.visitRequestFailedWithStatusCode(this, statusCode);
+    }
+  
+    requestFinished() {
+      this.recordTimingMetric(TimingMetric.requestEnd);
+      this.adapter.visitRequestFinished(this);
+    }
+    */
+  // Instrumentation
+  recordTimingMetric(metric) {
+    this.timingMetrics[metric] = (/* @__PURE__ */ new Date()).getTime();
+  }
+  getTimingMetrics() {
+    return { ...this.timingMetrics };
+  }
+  // Private
+  shouldIssueRequest() {
+    return this.action == "restore" ? !this.hasCachedSnapshot() : true;
+  }
+  cacheSnapshot() {
+    if (!this.snapshotCached) {
+      this.controller.cacheSnapshot();
+      this.snapshotCached = true;
+    }
+  }
+  render(callback) {
+    this.cancelRender();
+    this.frame = requestAnimationFrame(() => {
+      delete this.frame;
+      callback.call(this);
+    });
+  }
+  cancelRender() {
+    if (this.frame) {
+      cancelAnimationFrame(this.frame);
+      delete this.frame;
+    }
+  }
+};
+
+// lib/turbolinks/controller.ts
+var Controller = class {
+  constructor() {
+    this.adapter = new BrowserAdapter(this);
+    this.cache = new LruCache(10);
+    this.enabled = true;
+    this.progressBarDelay = 500;
+    // This only exists for compatibility with iOS
+    this.started = false;
+    // Event handlers
+    this.clickCaptured = () => {
+      document.body.removeEventListener("click", this.clickBubbled, false);
+      document.body.addEventListener("click", this.clickBubbled, false);
+    };
+    this.clickBubbled = (event) => {
+      if (this.enabled && this.clickEventIsSignificant(event)) {
+        const link = this.getVisitableLinkForTarget(event.target);
+        if (link) {
+          const location = this.getVisitableLocationForLink(link);
+          if (location && this.applicationAllowsFollowingLinkToLocation(link, location)) {
+            event.preventDefault();
+            event.stopPropagation();
+            const action = this.getActionForLink(link);
+            this.visit(location, { action });
+          }
+        }
+      }
+    };
+  }
+  start() {
+    if (!this.started) {
+      document.body.addEventListener("click", this.clickCaptured, true);
+      this.location = Location.currentLocation;
+      this.restorationIdentifier = uuid();
+      this.lastRenderedLocation = this.location;
+      this.started = true;
+      this.enabled = true;
+    }
+  }
+  disable() {
+    this.enabled = false;
+  }
+  stop() {
+    if (this.started) {
+      document.body.removeEventListener("click", this.clickCaptured, true);
+      this.started = false;
+    }
+  }
+  clearCache() {
+    this.cache = new LruCache(10);
+  }
+  visit(location, options = {}) {
+    location = Location.wrap(location);
+    if (this.applicationAllowsVisitingLocation(location)) {
+      if (this.locationIsVisitable(location)) {
+        const action = options.action || "advance";
+        this.adapter.visitProposedToLocationWithAction(location, action);
+      } else {
+        window.location.href = location.toString();
+      }
+    }
+  }
+  startVisitToLocationWithAction(location, action, restorationIdentifier) {
+    this.startVisit(Location.wrap(location), action);
+  }
+  setProgressBarDelay(delay) {
+    this.progressBarDelay = delay;
+  }
+  // History delegate
+  historyPoppedToLocationWithRestorationIdentifier(location, restorationIdentifier) {
+    if (this.enabled) {
+      this.location = Location.wrap(location);
+      this.restorationIdentifier = restorationIdentifier;
+      this.startVisit(this.location, "restore");
+    } else {
+      this.adapter.pageInvalidated();
+    }
+  }
+  // Snapshot cache
+  getCachedSnapshotForLocation(location) {
+    return this.cache.get(Location.wrap(location).toCacheKey());
+  }
+  shouldCacheSnapshot() {
+    return document.body.querySelector("#proxied-body") && document.head.querySelector("meta[name='turbolinks-no-cache']")?.getAttribute("content") != "no-cache";
+  }
+  cacheSnapshot() {
+    if (this.shouldCacheSnapshot()) {
+      this.notifyApplicationBeforeCachingSnapshot();
+      const snapshot = {
+        bodyEl: document.body.cloneNode(true),
+        headEl: document.head.cloneNode(true),
+        pageContext: this.pageContext
+      };
+      const location = this.lastRenderedLocation || Location.currentLocation;
+      defer(() => this.cache.put(location.toCacheKey(), snapshot));
+    }
+  }
+  // View
+  viewInvalidated() {
+    this.adapter.pageInvalidated();
+  }
+  viewWillRender() {
+    this.notifyApplicationBeforeRender();
+  }
+  viewRendered() {
+    this.lastRenderedLocation = this.currentVisit.location;
+    this.notifyApplicationAfterRender();
+  }
+  // Application events
+  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("turbolinks:click", {
+      target: link,
+      data: { url: location.absoluteURL },
+      cancelable: true
+    });
+  }
+  notifyApplicationBeforeVisitingLocation(location) {
+    return dispatch("turbolinks:before-visit", {
+      data: { url: location.absoluteURL },
+      cancelable: true
+    });
+  }
+  notifyApplicationAfterVisitingLocation(location) {
+    return dispatch("turbolinks:visit", {
+      data: { url: location.absoluteURL }
+    });
+  }
+  notifyApplicationBeforeCachingSnapshot() {
+    return dispatch("turbolinks:before-cache");
+  }
+  notifyApplicationBeforeRender() {
+    return dispatch("turbolinks:before-render");
+  }
+  notifyApplicationAfterRender() {
+    return dispatch("turbolinks:render");
+  }
+  notifyApplicationAfterPageLoad(timing = {}) {
+    return dispatch("turbolinks:load", {
+      data: { url: this.location.absoluteURL, timing }
+    });
+  }
+  // Private
+  startVisit(location, action) {
+    if (this.currentVisit) {
+      this.currentVisit.cancel();
+    }
+    this.currentVisit = this.createVisit(location, action);
+    this.currentVisit.start();
+    this.notifyApplicationAfterVisitingLocation(location);
+  }
+  createVisit(location, action) {
+    const visit = new Visit(this, location, action);
+    visit.referrer = this.location;
+    if (action === "restore") {
+      visit.requestInFlight = true;
+    }
+    return visit;
+  }
+  visitCompleted(visit) {
+    this.notifyApplicationAfterPageLoad(visit.getTimingMetrics());
+  }
+  clickEventIsSignificant(event) {
+    return !(event.target && event.target.isContentEditable || event.defaultPrevented || event.which > 1 || event.altKey || event.ctrlKey || event.metaKey || event.shiftKey);
+  }
+  getVisitableLinkForTarget(target) {
+    if (target instanceof Element && this.elementIsVisitable(target)) {
+      return closest(target, "a[href]:not([target]):not([download])");
+    }
+  }
+  getVisitableLocationForLink(link) {
+    const location = new Location(link.getAttribute("href") || "");
+    if (this.locationIsVisitable(location)) {
+      return location;
+    }
+  }
+  getActionForLink(link) {
+    const action = link.getAttribute("data-turbolinks-action");
+    return isAction(action) ? action : "advance";
+  }
+  elementIsVisitable(element) {
+    const container = closest(element, "[data-turbolinks]");
+    if (container) {
+      return container.getAttribute("data-turbolinks") != "false";
+    } else {
+      return true;
+    }
+  }
+  locationIsVisitable(location) {
+    return location.isPrefixedBy(new Location("/")) && location.isHTML();
+  }
+};
+
+// lib/turbolinks/index.ts
+var controller = new Controller();
+var Turbolinks = {
+  get supported() {
+    return true;
+  },
+  controller,
+  visit(location, options) {
+    controller.visit(location, options);
+  },
+  clearCache() {
+    controller.clearCache();
+  },
+  setProgressBarDelay(delay) {
+    controller.setProgressBarDelay(delay);
+  },
+  start() {
+    if (window.Turbolinks !== Turbolinks && window.Turbolinks.controller.adapter) {
+      window.Turbolinks.controller.adapter.controller = controller;
+      controller.adapter = window.Turbolinks.controller.adapter;
+    }
+    window._disableAutomaticLinkInterception = true;
+    window.Turbolinks = Turbolinks;
+    controller.start();
+  },
+  _vpsCachePageContext(pageContext) {
+    controller.pageContext = pageContext;
+  },
+  _vpsOnRenderClient(newHead, trackScripts, renderBody) {
+    if (controller.currentVisit) {
+      const { currentVisit } = controller;
+      currentVisit.renderFn = async () => {
+        const scriptsLoaded = mergeHead(
+          newHead,
+          trackScripts,
+          () => controller.viewInvalidated()
+        );
+        controller.viewWillRender();
+        renderBody();
+        await scriptsLoaded;
+        activateNewBodyScriptElements(
+          Array.from(document.body.querySelectorAll("script"))
+        );
+        focusFirstAutofocusableElement();
+        controller.viewRendered();
+        controller.adapter.visitRendered(currentVisit);
+      };
+      controller.adapter.visitRequestCompleted(controller.currentVisit);
+      controller.adapter.visitRequestFinished(controller.currentVisit);
+    } else {
+      console.error(
+        "controller.currentVisit should exist when onRenderClient fires"
+      );
+    }
+  }
+};
+
+export {
+  renderReact,
+  copyElementAttributes,
+  Turbolinks
+};
+//# sourceMappingURL=chunk-ABW2IXO4.js.map