https://reflet.ai/assets/application-126468c9.js

1var __defProp = Object.defineProperty;
2var __getOwnPropNames = Object.getOwnPropertyNames;
3var __esm = (fn, res) => function __init() {
4  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
5};
6var __export = (target, all) => {
7  for (var name in all)
8    __defProp(target, name, { get: all[name], enumerable: true });
9};
10

11// node_modules/@rails/actioncable/src/adapters.js
12var adapters_default;
13var init_adapters = __esm({
14  "node_modules/@rails/actioncable/src/adapters.js"() {
15    adapters_default = {
16      logger: typeof console !== "undefined" ? console : void 0,
17      WebSocket: typeof WebSocket !== "undefined" ? WebSocket : void 0
18    };
19  }
20});
21

22// node_modules/@rails/actioncable/src/logger.js
23var logger_default;
24var init_logger = __esm({
25  "node_modules/@rails/actioncable/src/logger.js"() {
26    init_adapters();
27    logger_default = {
28      log(...messages) {
29        if (this.enabled) {
30          messages.push(Date.now());
31          adapters_default.logger.log("[ActionCable]", ...messages);
32        }
33      }
34    };
35  }
36});
37

38// node_modules/@rails/actioncable/src/connection_monitor.js
39var now, secondsSince, ConnectionMonitor, connection_monitor_default;
40var init_connection_monitor = __esm({
41  "node_modules/@rails/actioncable/src/connection_monitor.js"() {
42    init_logger();
43    now = () => (/* @__PURE__ */ new Date()).getTime();
44    secondsSince = (time) => (now() - time) / 1e3;
45    ConnectionMonitor = class {
46      constructor(connection) {
47        this.visibilityDidChange = this.visibilityDidChange.bind(this);
48        this.connection = connection;
49        this.reconnectAttempts = 0;
50      }
51      start() {
52        if (!this.isRunning()) {
53          this.startedAt = now();
54          delete this.stoppedAt;
55          this.startPolling();
56          addEventListener("visibilitychange", this.visibilityDidChange);
57          logger_default.log(`ConnectionMonitor started. stale threshold = ${this.constructor.staleThreshold} s`);
58        }
59      }
60      stop() {
61        if (this.isRunning()) {
62          this.stoppedAt = now();
63          this.stopPolling();
64          removeEventListener("visibilitychange", this.visibilityDidChange);
65          logger_default.log("ConnectionMonitor stopped");
66        }
67      }
68      isRunning() {
69        return this.startedAt && !this.stoppedAt;
70      }
71      recordMessage() {
72        this.pingedAt = now();
73      }
74      recordConnect() {
75        this.reconnectAttempts = 0;
76        delete this.disconnectedAt;
77        logger_default.log("ConnectionMonitor recorded connect");
78      }
79      recordDisconnect() {
80        this.disconnectedAt = now();
81        logger_default.log("ConnectionMonitor recorded disconnect");
82      }
83      // Private
84      startPolling() {
85        this.stopPolling();
86        this.poll();
87      }
88      stopPolling() {
89        clearTimeout(this.pollTimeout);
90      }
91      poll() {
92        this.pollTimeout = setTimeout(
93          () => {
94            this.reconnectIfStale();
95            this.poll();
96          },
97          this.getPollInterval()
98        );
99      }
100      getPollInterval() {
101        const { staleThreshold, reconnectionBackoffRate } = this.constructor;
102        const backoff = Math.pow(1 + reconnectionBackoffRate, Math.min(this.reconnectAttempts, 10));
103        const jitterMax = this.reconnectAttempts === 0 ? 1 : reconnectionBackoffRate;
104        const jitter = jitterMax * Math.random();
105        return staleThreshold * 1e3 * backoff * (1 + jitter);
106      }
107      reconnectIfStale() {
108        if (this.connectionIsStale()) {
109          logger_default.log(`ConnectionMonitor detected stale connection. reconnectAttempts = ${this.reconnectAttempts}, time stale = ${secondsSince(this.refreshedAt)} s, stale threshold = ${this.constructor.staleThreshold} s`);
110          this.reconnectAttempts++;
111          if (this.disconnectedRecently()) {
112            logger_default.log(`ConnectionMonitor skipping reopening recent disconnect. time disconnected = ${secondsSince(this.disconnectedAt)} s`);
113          } else {
114            logger_default.log("ConnectionMonitor reopening");
115            this.connection.reopen();
116          }
117        }
118      }
119      get refreshedAt() {
120        return this.pingedAt ? this.pingedAt : this.startedAt;
121      }
122      connectionIsStale() {
123        return secondsSince(this.refreshedAt) > this.constructor.staleThreshold;
124      }
125      disconnectedRecently() {
126        return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;
127      }
128      visibilityDidChange() {
129        if (document.visibilityState === "visible") {
130          setTimeout(
131            () => {
132              if (this.connectionIsStale() || !this.connection.isOpen()) {
133                logger_default.log(`ConnectionMonitor reopening stale connection on visibilitychange. visibilityState = ${document.visibilityState}`);
134                this.connection.reopen();
135              }
136            },
137            200
138          );
139        }
140      }
141    };
142    ConnectionMonitor.staleThreshold = 6;
143    ConnectionMonitor.reconnectionBackoffRate = 0.15;
144    connection_monitor_default = ConnectionMonitor;
145  }
146});
147

148// node_modules/@rails/actioncable/src/internal.js
149var internal_default;
150var init_internal = __esm({
151  "node_modules/@rails/actioncable/src/internal.js"() {
152    internal_default = {
153      "message_types": {
154        "welcome": "welcome",
155        "disconnect": "disconnect",
156        "ping": "ping",
157        "confirmation": "confirm_subscription",
158        "rejection": "reject_subscription"
159      },
160      "disconnect_reasons": {
161        "unauthorized": "unauthorized",
162        "invalid_request": "invalid_request",
163        "server_restart": "server_restart",
164        "remote": "remote"
165      },
166      "default_mount_path": "/cable",
167      "protocols": [
168        "actioncable-v1-json",
169        "actioncable-unsupported"
170      ]
171    };
172  }
173});
174

175// node_modules/@rails/actioncable/src/connection.js
176var message_types, protocols, supportedProtocols, indexOf, Connection, connection_default;
177var init_connection = __esm({
178  "node_modules/@rails/actioncable/src/connection.js"() {
179    init_adapters();
180    init_connection_monitor();
181    init_internal();
182    init_logger();
183    ({ message_types, protocols } = internal_default);
184    supportedProtocols = protocols.slice(0, protocols.length - 1);
185    indexOf = [].indexOf;
186    Connection = class {
187      constructor(consumer2) {
188        this.open = this.open.bind(this);
189        this.consumer = consumer2;
190        this.subscriptions = this.consumer.subscriptions;
191        this.monitor = new connection_monitor_default(this);
192        this.disconnected = true;
193      }
194      send(data) {
195        if (this.isOpen()) {
196          this.webSocket.send(JSON.stringify(data));
197          return true;
198        } else {
199          return false;
200        }
201      }
202      open() {
203        if (this.isActive()) {
204          logger_default.log(`Attempted to open WebSocket, but existing socket is ${this.getState()}`);
205          return false;
206        } else {
207          const socketProtocols = [...protocols, ...this.consumer.subprotocols || []];
208          logger_default.log(`Opening WebSocket, current state is ${this.getState()}, subprotocols: ${socketProtocols}`);
209          if (this.webSocket) {
210            this.uninstallEventHandlers();
211          }
212          this.webSocket = new adapters_default.WebSocket(this.consumer.url, socketProtocols);
213          this.installEventHandlers();
214          this.monitor.start();
215          return true;
216        }
217      }
218      close({ allowReconnect } = { allowReconnect: true }) {
219        if (!allowReconnect) {
220          this.monitor.stop();
221        }
222        if (this.isOpen()) {
223          return this.webSocket.close();
224        }
225      }
226      reopen() {
227        logger_default.log(`Reopening WebSocket, current state is ${this.getState()}`);
228        if (this.isActive()) {
229          try {
230            return this.close();
231          } catch (error) {
232            logger_default.log("Failed to reopen WebSocket", error);
233          } finally {
234            logger_default.log(`Reopening WebSocket in ${this.constructor.reopenDelay}ms`);
235            setTimeout(this.open, this.constructor.reopenDelay);
236          }
237        } else {
238          return this.open();
239        }
240      }
241      getProtocol() {
242        if (this.webSocket) {
243          return this.webSocket.protocol;
244        }
245      }
246      isOpen() {
247        return this.isState("open");
248      }
249      isActive() {
250        return this.isState("open", "connecting");
251      }
252      triedToReconnect() {
253        return this.monitor.reconnectAttempts > 0;
254      }
255      // Private
256      isProtocolSupported() {
257        return indexOf.call(supportedProtocols, this.getProtocol()) >= 0;
258      }
259      isState(...states) {
260        return indexOf.call(states, this.getState()) >= 0;
261      }
262      getState() {
263        if (this.webSocket) {
264          for (let state in adapters_default.WebSocket) {
265            if (adapters_default.WebSocket[state] === this.webSocket.readyState) {
266              return state.toLowerCase();
267            }
268          }
269        }
270        return null;
271      }
272      installEventHandlers() {
273        for (let eventName in this.events) {
274          const handler = this.events[eventName].bind(this);
275          this.webSocket[`on${eventName}`] = handler;
276        }
277      }
278      uninstallEventHandlers() {
279        for (let eventName in this.events) {
280          this.webSocket[`on${eventName}`] = function() {
281          };
282        }
283      }
284    };
285    Connection.reopenDelay = 500;
286    Connection.prototype.events = {
287      message(event) {
288        if (!this.isProtocolSupported()) {
289          return;
290        }
291        const { identifier, message, reason, reconnect, type } = JSON.parse(event.data);
292        this.monitor.recordMessage();
293        switch (type) {
294          case message_types.welcome:
295            if (this.triedToReconnect()) {
296              this.reconnectAttempted = true;
297            }
298            this.monitor.recordConnect();
299            return this.subscriptions.reload();
300          case message_types.disconnect:
301            logger_default.log(`Disconnecting. Reason: ${reason}`);
302            return this.close({ allowReconnect: reconnect });
303          case message_types.ping:
304            return null;
305          case message_types.confirmation:
306            this.subscriptions.confirmSubscription(identifier);
307            if (this.reconnectAttempted) {
308              this.reconnectAttempted = false;
309              return this.subscriptions.notify(identifier, "connected", { reconnected: true });
310            } else {
311              return this.subscriptions.notify(identifier, "connected", { reconnected: false });
312            }
313          case message_types.rejection:
314            return this.subscriptions.reject(identifier);
315          default:
316            return this.subscriptions.notify(identifier, "received", message);
317        }
318      },
319      open() {
320        logger_default.log(`WebSocket onopen event, using '${this.getProtocol()}' subprotocol`);
321        this.disconnected = false;
322        if (!this.isProtocolSupported()) {
323          logger_default.log("Protocol is unsupported. Stopping monitor and disconnecting.");
324          return this.close({ allowReconnect: false });
325        }
326      },
327      close(event) {
328        logger_default.log("WebSocket onclose event");
329        if (this.disconnected) {
330          return;
331        }
332        this.disconnected = true;
333        this.monitor.recordDisconnect();
334        return this.subscriptions.notifyAll("disconnected", { willAttemptReconnect: this.monitor.isRunning() });
335      },
336      error() {
337        logger_default.log("WebSocket onerror event");
338      }
339    };
340    connection_default = Connection;
341  }
342});
343

344// node_modules/@rails/actioncable/src/subscription.js
345var extend, Subscription;
346var init_subscription = __esm({
347  "node_modules/@rails/actioncable/src/subscription.js"() {
348    extend = function(object, properties) {
349      if (properties != null) {
350        for (let key in properties) {
351          const value = properties[key];
352          object[key] = value;
353        }
354      }
355      return object;
356    };
357    Subscription = class {
358      constructor(consumer2, params = {}, mixin) {
359        this.consumer = consumer2;
360        this.identifier = JSON.stringify(params);
361        extend(this, mixin);
362      }
363      // Perform a channel action with the optional data passed as an attribute
364      perform(action, data = {}) {
365        data.action = action;
366        return this.send(data);
367      }
368      send(data) {
369        return this.consumer.send({ command: "message", identifier: this.identifier, data: JSON.stringify(data) });
370      }
371      unsubscribe() {
372        return this.consumer.subscriptions.remove(this);
373      }
374    };
375  }
376});
377

378// node_modules/@rails/actioncable/src/subscription_guarantor.js
379var SubscriptionGuarantor, subscription_guarantor_default;
380var init_subscription_guarantor = __esm({
381  "node_modules/@rails/actioncable/src/subscription_guarantor.js"() {
382    init_logger();
383    SubscriptionGuarantor = class {
384      constructor(subscriptions) {
385        this.subscriptions = subscriptions;
386        this.pendingSubscriptions = [];
387      }
388      guarantee(subscription) {
389        if (this.pendingSubscriptions.indexOf(subscription) == -1) {
390          logger_default.log(`SubscriptionGuarantor guaranteeing ${subscription.identifier}`);
391          this.pendingSubscriptions.push(subscription);
392        } else {
393          logger_default.log(`SubscriptionGuarantor already guaranteeing ${subscription.identifier}`);
394        }
395        this.startGuaranteeing();
396      }
397      forget(subscription) {
398        logger_default.log(`SubscriptionGuarantor forgetting ${subscription.identifier}`);
399        this.pendingSubscriptions = this.pendingSubscriptions.filter((s) => s !== subscription);
400      }
401      startGuaranteeing() {
402        this.stopGuaranteeing();
403        this.retrySubscribing();
404      }
405      stopGuaranteeing() {
406        clearTimeout(this.retryTimeout);
407      }
408      retrySubscribing() {
409        this.retryTimeout = setTimeout(
410          () => {
411            if (this.subscriptions && typeof this.subscriptions.subscribe === "function") {
412              this.pendingSubscriptions.map((subscription) => {
413                logger_default.log(`SubscriptionGuarantor resubscribing ${subscription.identifier}`);
414                this.subscriptions.subscribe(subscription);
415              });
416            }
417          },
418          500
419        );
420      }
421    };
422    subscription_guarantor_default = SubscriptionGuarantor;
423  }
424});
425

426// node_modules/@rails/actioncable/src/subscriptions.js
427var Subscriptions;
428var init_subscriptions = __esm({
429  "node_modules/@rails/actioncable/src/subscriptions.js"() {
430    init_subscription();
431    init_subscription_guarantor();
432    init_logger();
433    Subscriptions = class {
434      constructor(consumer2) {
435        this.consumer = consumer2;
436        this.guarantor = new subscription_guarantor_default(this);
437        this.subscriptions = [];
438      }
439      create(channelName, mixin) {
440        const channel = channelName;
441        const params = typeof channel === "object" ? channel : { channel };
442        const subscription = new Subscription(this.consumer, params, mixin);
443        return this.add(subscription);
444      }
445      // Private
446      add(subscription) {
447        this.subscriptions.push(subscription);
448        this.consumer.ensureActiveConnection();
449        this.notify(subscription, "initialized");
450        this.subscribe(subscription);
451        return subscription;
452      }
453      remove(subscription) {
454        this.forget(subscription);
455        if (!this.findAll(subscription.identifier).length) {
456          this.sendCommand(subscription, "unsubscribe");
457        }
458        return subscription;
459      }
460      reject(identifier) {
461        return this.findAll(identifier).map((subscription) => {
462          this.forget(subscription);
463          this.notify(subscription, "rejected");
464          return subscription;
465        });
466      }
467      forget(subscription) {
468        this.guarantor.forget(subscription);
469        this.subscriptions = this.subscriptions.filter((s) => s !== subscription);
470        return subscription;
471      }
472      findAll(identifier) {
473        return this.subscriptions.filter((s) => s.identifier === identifier);
474      }
475      reload() {
476        return this.subscriptions.map((subscription) => this.subscribe(subscription));
477      }
478      notifyAll(callbackName, ...args) {
479        return this.subscriptions.map((subscription) => this.notify(subscription, callbackName, ...args));
480      }
481      notify(subscription, callbackName, ...args) {
482        let subscriptions;
483        if (typeof subscription === "string") {
484          subscriptions = this.findAll(subscription);
485        } else {
486          subscriptions = [subscription];
487        }
488        return subscriptions.map((subscription2) => typeof subscription2[callbackName] === "function" ? subscription2[callbackName](...args) : void 0);
489      }
490      subscribe(subscription) {
491        if (this.sendCommand(subscription, "subscribe")) {
492          this.guarantor.guarantee(subscription);
493        }
494      }
495      confirmSubscription(identifier) {
496        logger_default.log(`Subscription confirmed ${identifier}`);
497        this.findAll(identifier).map((subscription) => this.guarantor.forget(subscription));
498      }
499      sendCommand(subscription, command) {
500        const { identifier } = subscription;
501        return this.consumer.send({ command, identifier });
502      }
503    };
504  }
505});
506

507// node_modules/@rails/actioncable/src/consumer.js
508function createWebSocketURL(url) {
509  if (typeof url === "function") {
510    url = url();
511  }
512  if (url && !/^wss?:/i.test(url)) {
513    const a = document.createElement("a");
514    a.href = url;
515    a.href = a.href;
516    a.protocol = a.protocol.replace("http", "ws");
517    return a.href;
518  } else {
519    return url;
520  }
521}
522var Consumer;
523var init_consumer = __esm({
524  "node_modules/@rails/actioncable/src/consumer.js"() {
525    init_connection();
526    init_subscriptions();
527    Consumer = class {
528      constructor(url) {
529        this._url = url;
530        this.subscriptions = new Subscriptions(this);
531        this.connection = new connection_default(this);
532        this.subprotocols = [];
533      }
534      get url() {
535        return createWebSocketURL(this._url);
536      }
537      send(data) {
538        return this.connection.send(data);
539      }
540      connect() {
541        return this.connection.open();
542      }
543      disconnect() {
544        return this.connection.close({ allowReconnect: false });
545      }
546      ensureActiveConnection() {
547        if (!this.connection.isActive()) {
548          return this.connection.open();
549        }
550      }
551      addSubProtocol(subprotocol) {
552        this.subprotocols = [...this.subprotocols, subprotocol];
553      }
554    };
555  }
556});
557

558// node_modules/@rails/actioncable/src/index.js
559var src_exports = {};
560__export(src_exports, {
561  Connection: () => connection_default,
562  ConnectionMonitor: () => connection_monitor_default,
563  Consumer: () => Consumer,
564  INTERNAL: () => internal_default,
565  Subscription: () => Subscription,
566  SubscriptionGuarantor: () => subscription_guarantor_default,
567  Subscriptions: () => Subscriptions,
568  adapters: () => adapters_default,
569  createConsumer: () => createConsumer,
570  createWebSocketURL: () => createWebSocketURL,
571  getConfig: () => getConfig,
572  logger: () => logger_default
573});
574function createConsumer(url = getConfig("url") || internal_default.default_mount_path) {
575  return new Consumer(url);
576}
577function getConfig(name) {
578  const element = document.head.querySelector(`meta[name='action-cable-${name}']`);
579  if (element) {
580    return element.getAttribute("content");
581  }
582}
583var init_src = __esm({
584  "node_modules/@rails/actioncable/src/index.js"() {
585    init_connection();
586    init_connection_monitor();
587    init_consumer();
588    init_internal();
589    init_subscription();
590    init_subscriptions();
591    init_subscription_guarantor();
592    init_adapters();
593    init_logger();
594  }
595});
596

597// node_modules/@hotwired/turbo/dist/turbo.es2017-esm.js
598var turbo_es2017_esm_exports = {};
599__export(turbo_es2017_esm_exports, {
600  FetchEnctype: () => FetchEnctype,
601  FetchMethod: () => FetchMethod,
602  FetchRequest: () => FetchRequest,
603  FetchResponse: () => FetchResponse,
604  FrameElement: () => FrameElement,
605  FrameLoadingStyle: () => FrameLoadingStyle,
606  FrameRenderer: () => FrameRenderer,
607  PageRenderer: () => PageRenderer,
608  PageSnapshot: () => PageSnapshot,
609  StreamActions: () => StreamActions,
610  StreamElement: () => StreamElement,
611  StreamSourceElement: () => StreamSourceElement,
612  cache: () => cache,
613  clearCache: () => clearCache,
614  config: () => config,
615  connectStreamSource: () => connectStreamSource,
616  disconnectStreamSource: () => disconnectStreamSource,
617  fetch: () => fetchWithTurboHeaders,
618  fetchEnctypeFromString: () => fetchEnctypeFromString,
619  fetchMethodFromString: () => fetchMethodFromString,
620  isSafe: () => isSafe,
621  navigator: () => navigator$1,
622  registerAdapter: () => registerAdapter,
623  renderStreamMessage: () => renderStreamMessage,
624  session: () => session,
625  setConfirmMethod: () => setConfirmMethod,
626  setFormMode: () => setFormMode,
627  setProgressBarDelay: () => setProgressBarDelay,
628  start: () => start,
629  visit: () => visit
630});
631(function(prototype) {
632  if (typeof prototype.requestSubmit == "function") return;
633  prototype.requestSubmit = function(submitter2) {
634    if (submitter2) {
635      validateSubmitter(submitter2, this);
636      submitter2.click();
637    } else {
638      submitter2 = document.createElement("input");
639      submitter2.type = "submit";
640      submitter2.hidden = true;
641      this.appendChild(submitter2);
642      submitter2.click();
643      this.removeChild(submitter2);
644    }
645  };
646  function validateSubmitter(submitter2, form) {
647    submitter2 instanceof HTMLElement || raise(TypeError, "parameter 1 is not of type 'HTMLElement'");
648    submitter2.type == "submit" || raise(TypeError, "The specified element is not a submit button");
649    submitter2.form == form || raise(DOMException, "The specified element is not owned by this form element", "NotFoundError");
650  }
651  function raise(errorConstructor, message, name) {
652    throw new errorConstructor("Failed to execute 'requestSubmit' on 'HTMLFormElement': " + message + ".", name);
653  }
654})(HTMLFormElement.prototype);
655var submittersByForm = /* @__PURE__ */ new WeakMap();
656function findSubmitterFromClickTarget(target) {
657  const element = target instanceof Element ? target : target instanceof Node ? target.parentElement : null;
658  const candidate = element ? element.closest("input, button") : null;
659  return candidate?.type == "submit" ? candidate : null;
660}
661function clickCaptured(event) {
662  const submitter2 = findSubmitterFromClickTarget(event.target);
663  if (submitter2 && submitter2.form) {
664    submittersByForm.set(submitter2.form, submitter2);
665  }
666}
667(function() {
668  if ("submitter" in Event.prototype) return;
669  let prototype = window.Event.prototype;
670  if ("SubmitEvent" in window) {
671    const prototypeOfSubmitEvent = window.SubmitEvent.prototype;
672    if (/Apple Computer/.test(navigator.vendor) && !("submitter" in prototypeOfSubmitEvent)) {
673      prototype = prototypeOfSubmitEvent;
674    } else {
675      return;
676    }
677  }
678  addEventListener("click", clickCaptured, true);
679  Object.defineProperty(prototype, "submitter", {
680    get() {
681      if (this.type == "submit" && this.target instanceof HTMLFormElement) {
682        return submittersByForm.get(this.target);
683      }
684    }
685  });
686})();
687var FrameLoadingStyle = {
688  eager: "eager",
689  lazy: "lazy"
690};
691var FrameElement = class _FrameElement extends HTMLElement {
692  static delegateConstructor = void 0;
693  loaded = Promise.resolve();
694  static get observedAttributes() {
695    return ["disabled", "loading", "src"];
696  }
697  constructor() {
698    super();
699    this.delegate = new _FrameElement.delegateConstructor(this);
700  }
701  connectedCallback() {
702    this.delegate.connect();
703  }
704  disconnectedCallback() {
705    this.delegate.disconnect();
706  }
707  reload() {
708    return this.delegate.sourceURLReloaded();
709  }
710  attributeChangedCallback(name) {
711    if (name == "loading") {
712      this.delegate.loadingStyleChanged();
713    } else if (name == "src") {
714      this.delegate.sourceURLChanged();
715    } else if (name == "disabled") {
716      this.delegate.disabledChanged();
717    }
718  }
719  /**
720   * Gets the URL to lazily load source HTML from
721   */
722  get src() {
723    return this.getAttribute("src");
724  }
725  /**
726   * Sets the URL to lazily load source HTML from
727   */
728  set src(value) {
729    if (value) {
730      this.setAttribute("src", value);
731    } else {
732      this.removeAttribute("src");
733    }
734  }
735  /**
736   * Gets the refresh mode for the frame.
737   */
738  get refresh() {
739    return this.getAttribute("refresh");
740  }
741  /**
742   * Sets the refresh mode for the frame.
743   */
744  set refresh(value) {
745    if (value) {
746      this.setAttribute("refresh", value);
747    } else {
748      this.removeAttribute("refresh");
749    }
750  }
751  get shouldReloadWithMorph() {
752    return this.src && this.refresh === "morph";
753  }
754  /**
755   * Determines if the element is loading
756   */
757  get loading() {
758    return frameLoadingStyleFromString(this.getAttribute("loading") || "");
759  }
760  /**
761   * Sets the value of if the element is loading
762   */
763  set loading(value) {
764    if (value) {
765      this.setAttribute("loading", value);
766    } else {
767      this.removeAttribute("loading");
768    }
769  }
770  /**
771   * Gets the disabled state of the frame.
772   *
773   * If disabled, no requests will be intercepted by the frame.
774   */
775  get disabled() {
776    return this.hasAttribute("disabled");
777  }
778  /**
779   * Sets the disabled state of the frame.
780   *
781   * If disabled, no requests will be intercepted by the frame.
782   */
783  set disabled(value) {
784    if (value) {
785      this.setAttribute("disabled", "");
786    } else {
787      this.removeAttribute("disabled");
788    }
789  }
790  /**
791   * Gets the autoscroll state of the frame.
792   *
793   * If true, the frame will be scrolled into view automatically on update.
794   */
795  get autoscroll() {
796    return this.hasAttribute("autoscroll");
797  }
798  /**
799   * Sets the autoscroll state of the frame.
800   *
801   * If true, the frame will be scrolled into view automatically on update.
802   */
803  set autoscroll(value) {
804    if (value) {
805      this.setAttribute("autoscroll", "");
806    } else {
807      this.removeAttribute("autoscroll");
808    }
809  }
810  /**
811   * Determines if the element has finished loading
812   */
813  get complete() {
814    return !this.delegate.isLoading;
815  }
816  /**
817   * Gets the active state of the frame.
818   *
819   * If inactive, source changes will not be observed.
820   */
821  get isActive() {
822    return this.ownerDocument === document && !this.isPreview;
823  }
824  /**
825   * Sets the active state of the frame.
826   *
827   * If inactive, source changes will not be observed.
828   */
829  get isPreview() {
830    return this.ownerDocument?.documentElement?.hasAttribute("data-turbo-preview");
831  }
832};
833function frameLoadingStyleFromString(style) {
834  switch (style.toLowerCase()) {
835    case "lazy":
836      return FrameLoadingStyle.lazy;
837    default:
838      return FrameLoadingStyle.eager;
839  }
840}
841var drive = {
842  enabled: true,
843  progressBarDelay: 500,
844  unvisitableExtensions: /* @__PURE__ */ new Set(
845    [
846      ".7z",
847      ".aac",
848      ".apk",
849      ".avi",
850      ".bmp",
851      ".bz2",
852      ".css",
853      ".csv",
854      ".deb",
855      ".dmg",
856      ".doc",
857      ".docx",
858      ".exe",
859      ".gif",
860      ".gz",
861      ".heic",
862      ".heif",
863      ".ico",
864      ".iso",
865      ".jpeg",
866      ".jpg",
867      ".js",
868      ".json",
869      ".m4a",
870      ".mkv",
871      ".mov",
872      ".mp3",
873      ".mp4",
874      ".mpeg",
875      ".mpg",
876      ".msi",
877      ".ogg",
878      ".ogv",
879      ".pdf",
880      ".pkg",
881      ".png",
882      ".ppt",
883      ".pptx",
884      ".rar",
885      ".rtf",
886      ".svg",
887      ".tar",
888      ".tif",
889      ".tiff",
890      ".txt",
891      ".wav",
892      ".webm",
893      ".webp",
894      ".wma",
895      ".wmv",
896      ".xls",
897      ".xlsx",
898      ".xml",
899      ".zip"
900    ]
901  )
902};
903function activateScriptElement(element) {
904  if (element.getAttribute("data-turbo-eval") == "false") {
905    return element;
906  } else {
907    const createdScriptElement = document.createElement("script");
908    const cspNonce = getCspNonce();
909    if (cspNonce) {
910      createdScriptElement.nonce = cspNonce;
911    }
912    createdScriptElement.textContent = element.textContent;
913    createdScriptElement.async = false;
914    copyElementAttributes(createdScriptElement, element);
915    return createdScriptElement;
916  }
917}
918function copyElementAttributes(destinationElement, sourceElement) {
919  for (const { name, value } of sourceElement.attributes) {
920    destinationElement.setAttribute(name, value);
921  }
922}
923function createDocumentFragment(html) {
924  const template = document.createElement("template");
925  template.innerHTML = html;
926  return template.content;
927}
928function dispatch(eventName, { target, cancelable, detail } = {}) {
929  const event = new CustomEvent(eventName, {
930    cancelable,
931    bubbles: true,
932    composed: true,
933    detail
934  });
935  if (target && target.isConnected) {
936    target.dispatchEvent(event);
937  } else {
938    document.documentElement.dispatchEvent(event);
939  }
940  return event;
941}
942function cancelEvent(event) {
943  event.preventDefault();
944  event.stopImmediatePropagation();
945}
946function nextRepaint() {
947  if (document.visibilityState === "hidden") {
948    return nextEventLoopTick();
949  } else {
950    return nextAnimationFrame();
951  }
952}
953function nextAnimationFrame() {
954  return new Promise((resolve) => requestAnimationFrame(() => resolve()));
955}
956function nextEventLoopTick() {
957  return new Promise((resolve) => setTimeout(() => resolve(), 0));
958}
959function nextMicrotask() {
960  return Promise.resolve();
961}
962function parseHTMLDocument(html = "") {
963  return new DOMParser().parseFromString(html, "text/html");
964}
965function unindent(strings, ...values) {
966  const lines = interpolate(strings, values).replace(/^\n/, "").split("\n");
967  const match = lines[0].match(/^\s+/);
968  const indent = match ? match[0].length : 0;
969  return lines.map((line) => line.slice(indent)).join("\n");
970}
971function interpolate(strings, values) {
972  return strings.reduce((result, string, i) => {
973    const value = values[i] == void 0 ? "" : values[i];
974    return result + string + value;
975  }, "");
976}
977function uuid() {
978  return Array.from({ length: 36 }).map((_, i) => {
979    if (i == 8 || i == 13 || i == 18 || i == 23) {
980      return "-";
981    } else if (i == 14) {
982      return "4";
983    } else if (i == 19) {
984      return (Math.floor(Math.random() * 4) + 8).toString(16);
985    } else {
986      return Math.floor(Math.random() * 15).toString(16);
987    }
988  }).join("");
989}
990function getAttribute(attributeName, ...elements) {
991  for (const value of elements.map((element) => element?.getAttribute(attributeName))) {
992    if (typeof value == "string") return value;
993  }
994  return null;
995}
996function hasAttribute(attributeName, ...elements) {
997  return elements.some((element) => element && element.hasAttribute(attributeName));
998}
999function markAsBusy(...elements) {
1000  for (const element of elements) {
1001    if (element.localName == "turbo-frame") {
1002      element.setAttribute("busy", "");
1003    }
1004    element.setAttribute("aria-busy", "true");
1005  }
1006}
1007function clearBusyState(...elements) {
1008  for (const element of elements) {
1009    if (element.localName == "turbo-frame") {
1010      element.removeAttribute("busy");
1011    }
1012    element.removeAttribute("aria-busy");
1013  }
1014}
1015function waitForLoad(element, timeoutInMilliseconds = 2e3) {
1016  return new Promise((resolve) => {
1017    const onComplete = () => {
1018      element.removeEventListener("error", onComplete);
1019      element.removeEventListener("load", onComplete);
1020      resolve();
1021    };
1022    element.addEventListener("load", onComplete, { once: true });
1023    element.addEventListener("error", onComplete, { once: true });
1024    setTimeout(resolve, timeoutInMilliseconds);
1025  });
1026}
1027function getHistoryMethodForAction(action) {
1028  switch (action) {
1029    case "replace":
1030      return history.replaceState;
1031    case "advance":
1032    case "restore":
1033      return history.pushState;
1034  }
1035}
1036function isAction(action) {
1037  return action == "advance" || action == "replace" || action == "restore";
1038}
1039function getVisitAction(...elements) {
1040  const action = getAttribute("data-turbo-action", ...elements);
1041  return isAction(action) ? action : null;
1042}
1043function getMetaElement(name) {
1044  return document.querySelector(`meta[name="${name}"]`);
1045}
1046function getMetaContent(name) {
1047  const element = getMetaElement(name);
1048  return element && element.content;
1049}
1050function getCspNonce() {
1051  const element = getMetaElement("csp-nonce");
1052  if (element) {
1053    const { nonce, content } = element;
1054    return nonce == "" ? content : nonce;
1055  }
1056}
1057function setMetaContent(name, content) {
1058  let element = getMetaElement(name);
1059  if (!element) {
1060    element = document.createElement("meta");
1061    element.setAttribute("name", name);
1062    document.head.appendChild(element);
1063  }
1064  element.setAttribute("content", content);
1065  return element;
1066}
1067function findClosestRecursively(element, selector) {
1068  if (element instanceof Element) {
1069    return element.closest(selector) || findClosestRecursively(element.assignedSlot || element.getRootNode()?.host, selector);
1070  }
1071}
1072function elementIsFocusable(element) {
1073  const inertDisabledOrHidden = "[inert], :disabled, [hidden], details:not([open]), dialog:not([open])";
1074  return !!element && element.closest(inertDisabledOrHidden) == null && typeof element.focus == "function";
1075}
1076function queryAutofocusableElement(elementOrDocumentFragment) {
1077  return Array.from(elementOrDocumentFragment.querySelectorAll("[autofocus]")).find(elementIsFocusable);
1078}
1079async function around(callback, reader) {
1080  const before = reader();
1081  callback();
1082  await nextAnimationFrame();
1083  const after = reader();
1084  return [before, after];
1085}
1086function doesNotTargetIFrame(name) {
1087  if (name === "_blank") {
1088    return false;
1089  } else if (name) {
1090    for (const element of document.getElementsByName(name)) {
1091      if (element instanceof HTMLIFrameElement) return false;
1092    }
1093    return true;
1094  } else {
1095    return true;
1096  }
1097}
1098function findLinkFromClickTarget(target) {
1099  return findClosestRecursively(target, "a[href]:not([target^=_]):not([download])");
1100}
1101function getLocationForLink(link) {
1102  return expandURL(link.getAttribute("href") || "");
1103}
1104function debounce(fn, delay) {
1105  let timeoutId = null;
1106  return (...args) => {
1107    const callback = () => fn.apply(this, args);
1108    clearTimeout(timeoutId);
1109    timeoutId = setTimeout(callback, delay);
1110  };
1111}
1112var submitter = {
1113  "aria-disabled": {
1114    beforeSubmit: (submitter2) => {
1115      submitter2.setAttribute("aria-disabled", "true");
1116      submitter2.addEventListener("click", cancelEvent);
1117    },
1118    afterSubmit: (submitter2) => {
1119      submitter2.removeAttribute("aria-disabled");
1120      submitter2.removeEventListener("click", cancelEvent);
1121    }
1122  },
1123  "disabled": {
1124    beforeSubmit: (submitter2) => submitter2.disabled = true,
1125    afterSubmit: (submitter2) => submitter2.disabled = false
1126  }
1127};
1128var Config = class {
1129  #submitter = null;
1130  constructor(config2) {
1131    Object.assign(this, config2);
1132  }
1133  get submitter() {
1134    return this.#submitter;
1135  }
1136  set submitter(value) {
1137    this.#submitter = submitter[value] || value;
1138  }
1139};
1140var forms = new Config({
1141  mode: "on",
1142  submitter: "disabled"
1143});
1144var config = {
1145  drive,
1146  forms
1147};
1148function expandURL(locatable) {
1149  return new URL(locatable.toString(), document.baseURI);
1150}
1151function getAnchor(url) {
1152  let anchorMatch;
1153  if (url.hash) {
1154    return url.hash.slice(1);
1155  } else if (anchorMatch = url.href.match(/#(.*)$/)) {
1156    return anchorMatch[1];
1157  }
1158}
1159function getAction$1(form, submitter2) {
1160  const action = submitter2?.getAttribute("formaction") || form.getAttribute("action") || form.action;
1161  return expandURL(action);
1162}
1163function getExtension(url) {
1164  return (getLastPathComponent(url).match(/\.[^.]*$/) || [])[0] || "";
1165}
1166function isPrefixedBy(baseURL, url) {
1167  const prefix = getPrefix(url);
1168  return baseURL.href === expandURL(prefix).href || baseURL.href.startsWith(prefix);
1169}
1170function locationIsVisitable(location2, rootLocation) {
1171  return isPrefixedBy(location2, rootLocation) && !config.drive.unvisitableExtensions.has(getExtension(location2));
1172}
1173function getRequestURL(url) {
1174  const anchor = getAnchor(url);
1175  return anchor != null ? url.href.slice(0, -(anchor.length + 1)) : url.href;
1176}
1177function toCacheKey(url) {
1178  return getRequestURL(url);
1179}
1180function urlsAreEqual(left, right) {
1181  return expandURL(left).href == expandURL(right).href;
1182}
1183function getPathComponents(url) {
1184  return url.pathname.split("/").slice(1);
1185}
1186function getLastPathComponent(url) {
1187  return getPathComponents(url).slice(-1)[0];
1188}
1189function getPrefix(url) {
1190  return addTrailingSlash(url.origin + url.pathname);
1191}
1192function addTrailingSlash(value) {
1193  return value.endsWith("/") ? value : value + "/";
1194}
1195var FetchResponse = class {
1196  constructor(response) {
1197    this.response = response;
1198  }
1199  get succeeded() {
1200    return this.response.ok;
1201  }
1202  get failed() {
1203    return !this.succeeded;
1204  }
1205  get clientError() {
1206    return this.statusCode >= 400 && this.statusCode <= 499;
1207  }
1208  get serverError() {
1209    return this.statusCode >= 500 && this.statusCode <= 599;
1210  }
1211  get redirected() {
1212    return this.response.redirected;
1213  }
1214  get location() {
1215    return expandURL(this.response.url);
1216  }
1217  get isHTML() {
1218    return this.contentType && this.contentType.match(/^(?:text\/([^\s;,]+\b)?html|application\/xhtml\+xml)\b/);
1219  }
1220  get statusCode() {
1221    return this.response.status;
1222  }
1223  get contentType() {
1224    return this.header("Content-Type");
1225  }
1226  get responseText() {
1227    return this.response.clone().text();
1228  }
1229  get responseHTML() {
1230    if (this.isHTML) {
1231      return this.response.clone().text();
1232    } else {
1233      return Promise.resolve(void 0);
1234    }
1235  }
1236  header(name) {
1237    return this.response.headers.get(name);
1238  }
1239};
1240var LimitedSet = class extends Set {
1241  constructor(maxSize) {
1242    super();
1243    this.maxSize = maxSize;
1244  }
1245  add(value) {
1246    if (this.size >= this.maxSize) {
1247      const iterator = this.values();
1248      const oldestValue = iterator.next().value;
1249      this.delete(oldestValue);
1250    }
1251    super.add(value);
1252  }
1253};
1254var recentRequests = new LimitedSet(20);
1255var nativeFetch = window.fetch;
1256function fetchWithTurboHeaders(url, options = {}) {
1257  const modifiedHeaders = new Headers(options.headers || {});
1258  const requestUID = uuid();
1259  recentRequests.add(requestUID);
1260  modifiedHeaders.append("X-Turbo-Request-Id", requestUID);
1261  return nativeFetch(url, {
1262    ...options,
1263    headers: modifiedHeaders
1264  });
1265}
1266function fetchMethodFromString(method) {
1267  switch (method.toLowerCase()) {
1268    case "get":
1269      return FetchMethod.get;
1270    case "post":
1271      return FetchMethod.post;
1272    case "put":
1273      return FetchMethod.put;
1274    case "patch":
1275      return FetchMethod.patch;
1276    case "delete":
1277      return FetchMethod.delete;
1278  }
1279}
1280var FetchMethod = {
1281  get: "get",
1282  post: "post",
1283  put: "put",
1284  patch: "patch",
1285  delete: "delete"
1286};
1287function fetchEnctypeFromString(encoding) {
1288  switch (encoding.toLowerCase()) {
1289    case FetchEnctype.multipart:
1290      return FetchEnctype.multipart;
1291    case FetchEnctype.plain:
1292      return FetchEnctype.plain;
1293    default:
1294      return FetchEnctype.urlEncoded;
1295  }
1296}
1297var FetchEnctype = {
1298  urlEncoded: "application/x-www-form-urlencoded",
1299  multipart: "multipart/form-data",
1300  plain: "text/plain"
1301};
1302var FetchRequest = class {
1303  abortController = new AbortController();
1304  #resolveRequestPromise = (_value) => {
1305  };
1306  constructor(delegate, method, location2, requestBody = new URLSearchParams(), target = null, enctype = FetchEnctype.urlEncoded) {
1307    const [url, body] = buildResourceAndBody(expandURL(location2), method, requestBody, enctype);
1308    this.delegate = delegate;
1309    this.url = url;
1310    this.target = target;
1311    this.fetchOptions = {
1312      credentials: "same-origin",
1313      redirect: "follow",
1314      method: method.toUpperCase(),
1315      headers: { ...this.defaultHeaders },
1316      body,
1317      signal: this.abortSignal,
1318      referrer: this.delegate.referrer?.href
1319    };
1320    this.enctype = enctype;
1321  }
1322  get method() {
1323    return this.fetchOptions.method;
1324  }
1325  set method(value) {
1326    const fetchBody = this.isSafe ? this.url.searchParams : this.fetchOptions.body || new FormData();
1327    const fetchMethod = fetchMethodFromString(value) || FetchMethod.get;
1328    this.url.search = "";
1329    const [url, body] = buildResourceAndBody(this.url, fetchMethod, fetchBody, this.enctype);
1330    this.url = url;
1331    this.fetchOptions.body = body;
1332    this.fetchOptions.method = fetchMethod.toUpperCase();
1333  }
1334  get headers() {
1335    return this.fetchOptions.headers;
1336  }
1337  set headers(value) {
1338    this.fetchOptions.headers = value;
1339  }
1340  get body() {
1341    if (this.isSafe) {
1342      return this.url.searchParams;
1343    } else {
1344      return this.fetchOptions.body;
1345    }
1346  }
1347  set body(value) {
1348    this.fetchOptions.body = value;
1349  }
1350  get location() {
1351    return this.url;
1352  }
1353  get params() {
1354    return this.url.searchParams;
1355  }
1356  get entries() {
1357    return this.body ? Array.from(this.body.entries()) : [];
1358  }
1359  cancel() {
1360    this.abortController.abort();
1361  }
1362  async perform() {
1363    const { fetchOptions } = this;
1364    this.delegate.prepareRequest(this);
1365    const event = await this.#allowRequestToBeIntercepted(fetchOptions);
1366    try {
1367      this.delegate.requestStarted(this);
1368      if (event.detail.fetchRequest) {
1369        this.response = event.detail.fetchRequest.response;
1370      } else {
1371        this.response = fetchWithTurboHeaders(this.url.href, fetchOptions);
1372      }
1373      const response = await this.response;
1374      return await this.receive(response);
1375    } catch (error) {
1376      if (error.name !== "AbortError") {
1377        if (this.#willDelegateErrorHandling(error)) {
1378          this.delegate.requestErrored(this, error);
1379        }
1380        throw error;
1381      }
1382    } finally {
1383      this.delegate.requestFinished(this);
1384    }
1385  }
1386  async receive(response) {
1387    const fetchResponse = new FetchResponse(response);
1388    const event = dispatch("turbo:before-fetch-response", {
1389      cancelable: true,
1390      detail: { fetchResponse },
1391      target: this.target
1392    });
1393    if (event.defaultPrevented) {
1394      this.delegate.requestPreventedHandlingResponse(this, fetchResponse);
1395    } else if (fetchResponse.succeeded) {
1396      this.delegate.requestSucceededWithResponse(this, fetchResponse);
1397    } else {
1398      this.delegate.requestFailedWithResponse(this, fetchResponse);
1399    }
1400    return fetchResponse;
1401  }
1402  get defaultHeaders() {
1403    return {
1404      Accept: "text/html, application/xhtml+xml"
1405    };
1406  }
1407  get isSafe() {
1408    return isSafe(this.method);
1409  }
1410  get abortSignal() {
1411    return this.abortController.signal;
1412  }
1413  acceptResponseType(mimeType) {
1414    this.headers["Accept"] = [mimeType, this.headers["Accept"]].join(", ");
1415  }
1416  async #allowRequestToBeIntercepted(fetchOptions) {
1417    const requestInterception = new Promise((resolve) => this.#resolveRequestPromise = resolve);
1418    const event = dispatch("turbo:before-fetch-request", {
1419      cancelable: true,
1420      detail: {
1421        fetchOptions,
1422        url: this.url,
1423        resume: this.#resolveRequestPromise
1424      },
1425      target: this.target
1426    });
1427    this.url = event.detail.url;
1428    if (event.defaultPrevented) await requestInterception;
1429    return event;
1430  }
1431  #willDelegateErrorHandling(error) {
1432    const event = dispatch("turbo:fetch-request-error", {
1433      target: this.target,
1434      cancelable: true,
1435      detail: { request: this, error }
1436    });
1437    return !event.defaultPrevented;
1438  }
1439};
1440function isSafe(fetchMethod) {
1441  return fetchMethodFromString(fetchMethod) == FetchMethod.get;
1442}
1443function buildResourceAndBody(resource, method, requestBody, enctype) {
1444  const searchParams = Array.from(requestBody).length > 0 ? new URLSearchParams(entriesExcludingFiles(requestBody)) : resource.searchParams;
1445  if (isSafe(method)) {
1446    return [mergeIntoURLSearchParams(resource, searchParams), null];
1447  } else if (enctype == FetchEnctype.urlEncoded) {
1448    return [resource, searchParams];
1449  } else {
1450    return [resource, requestBody];
1451  }
1452}
1453function entriesExcludingFiles(requestBody) {
1454  const entries = [];
1455  for (const [name, value] of requestBody) {
1456    if (value instanceof File) continue;
1457    else entries.push([name, value]);
1458  }
1459  return entries;
1460}
1461function mergeIntoURLSearchParams(url, requestBody) {
1462  const searchParams = new URLSearchParams(entriesExcludingFiles(requestBody));
1463  url.search = searchParams.toString();
1464  return url;
1465}
1466var AppearanceObserver = class {
1467  started = false;
1468  constructor(delegate, element) {
1469    this.delegate = delegate;
1470    this.element = element;
1471    this.intersectionObserver = new IntersectionObserver(this.intersect);
1472  }
1473  start() {
1474    if (!this.started) {
1475      this.started = true;
1476      this.intersectionObserver.observe(this.element);
1477    }
1478  }
1479  stop() {
1480    if (this.started) {
1481      this.started = false;
1482      this.intersectionObserver.unobserve(this.element);
1483    }
1484  }
1485  intersect = (entries) => {
1486    const lastEntry = entries.slice(-1)[0];
1487    if (lastEntry?.isIntersecting) {
1488      this.delegate.elementAppearedInViewport(this.element);
1489    }
1490  };
1491};
1492var StreamMessage = class {
1493  static contentType = "text/vnd.turbo-stream.html";
1494  static wrap(message) {
1495    if (typeof message == "string") {
1496      return new this(createDocumentFragment(message));
1497    } else {
1498      return message;
1499    }
1500  }
1501  constructor(fragment) {
1502    this.fragment = importStreamElements(fragment);
1503  }
1504};
1505function importStreamElements(fragment) {
1506  for (const element of fragment.querySelectorAll("turbo-stream")) {
1507    const streamElement = document.importNode(element, true);
1508    for (const inertScriptElement of streamElement.templateElement.content.querySelectorAll("script")) {
1509      inertScriptElement.replaceWith(activateScriptElement(inertScriptElement));
1510    }
1511    element.replaceWith(streamElement);
1512  }
1513  return fragment;
1514}
1515var PREFETCH_DELAY = 100;
1516var PrefetchCache = class {
1517  #prefetchTimeout = null;
1518  #prefetched = null;
1519  get(url) {
1520    if (this.#prefetched && this.#prefetched.url === url && this.#prefetched.expire > Date.now()) {
1521      return this.#prefetched.request;
1522    }
1523  }
1524  setLater(url, request, ttl) {
1525    this.clear();
1526    this.#prefetchTimeout = setTimeout(() => {
1527      request.perform();
1528      this.set(url, request, ttl);
1529      this.#prefetchTimeout = null;
1530    }, PREFETCH_DELAY);
1531  }
1532  set(url, request, ttl) {
1533    this.#prefetched = { url, request, expire: new Date((/* @__PURE__ */ new Date()).getTime() + ttl) };
1534  }
1535  clear() {
1536    if (this.#prefetchTimeout) clearTimeout(this.#prefetchTimeout);
1537    this.#prefetched = null;
1538  }
1539};
1540var cacheTtl = 10 * 1e3;
1541var prefetchCache = new PrefetchCache();
1542var FormSubmissionState = {
1543  initialized: "initialized",
1544  requesting: "requesting",
1545  waiting: "waiting",
1546  receiving: "receiving",
1547  stopping: "stopping",
1548  stopped: "stopped"
1549};
1550var FormSubmission = class _FormSubmission {
1551  state = FormSubmissionState.initialized;
1552  static confirmMethod(message) {
1553    return Promise.resolve(confirm(message));
1554  }
1555  constructor(delegate, formElement, submitter2, mustRedirect = false) {
1556    const method = getMethod(formElement, submitter2);
1557    const action = getAction(getFormAction(formElement, submitter2), method);
1558    const body = buildFormData(formElement, submitter2);
1559    const enctype = getEnctype(formElement, submitter2);
1560    this.delegate = delegate;
1561    this.formElement = formElement;
1562    this.submitter = submitter2;
1563    this.fetchRequest = new FetchRequest(this, method, action, body, formElement, enctype);
1564    this.mustRedirect = mustRedirect;
1565  }
1566  get method() {
1567    return this.fetchRequest.method;
1568  }
1569  set method(value) {
1570    this.fetchRequest.method = value;
1571  }
1572  get action() {
1573    return this.fetchRequest.url.toString();
1574  }
1575  set action(value) {
1576    this.fetchRequest.url = expandURL(value);
1577  }
1578  get body() {
1579    return this.fetchRequest.body;
1580  }
1581  get enctype() {
1582    return this.fetchRequest.enctype;
1583  }
1584  get isSafe() {
1585    return this.fetchRequest.isSafe;
1586  }
1587  get location() {
1588    return this.fetchRequest.url;
1589  }
1590  // The submission process
1591  async start() {
1592    const { initialized, requesting } = FormSubmissionState;
1593    const confirmationMessage = getAttribute("data-turbo-confirm", this.submitter, this.formElement);
1594    if (typeof confirmationMessage === "string") {
1595      const confirmMethod = typeof config.forms.confirm === "function" ? config.forms.confirm : _FormSubmission.confirmMethod;
1596      const answer = await confirmMethod(confirmationMessage, this.formElement, this.submitter);
1597      if (!answer) {
1598        return;
1599      }
1600    }
1601    if (this.state == initialized) {
1602      this.state = requesting;
1603      return this.fetchRequest.perform();
1604    }
1605  }
1606  stop() {
1607    const { stopping, stopped } = FormSubmissionState;
1608    if (this.state != stopping && this.state != stopped) {
1609      this.state = stopping;
1610      this.fetchRequest.cancel();
1611      return true;
1612    }
1613  }
1614  // Fetch request delegate
1615  prepareRequest(request) {
1616    if (!request.isSafe) {
1617      const token = getCookieValue(getMetaContent("csrf-param")) || getMetaContent("csrf-token");
1618      if (token) {
1619        request.headers["X-CSRF-Token"] = token;
1620      }
1621    }
1622    if (this.requestAcceptsTurboStreamResponse(request)) {
1623      request.acceptResponseType(StreamMessage.contentType);
1624    }
1625  }
1626  requestStarted(_request) {
1627    this.state = FormSubmissionState.waiting;
1628    if (this.submitter) config.forms.submitter.beforeSubmit(this.submitter);
1629    this.setSubmitsWith();
1630    markAsBusy(this.formElement);
1631    dispatch("turbo:submit-start", {
1632      target: this.formElement,
1633      detail: { formSubmission: this }
1634    });
1635    this.delegate.formSubmissionStarted(this);
1636  }
1637  requestPreventedHandlingResponse(request, response) {
1638    prefetchCache.clear();
1639    this.result = { success: response.succeeded, fetchResponse: response };
1640  }
1641  requestSucceededWithResponse(request, response) {
1642    if (response.clientError || response.serverError) {
1643      this.delegate.formSubmissionFailedWithResponse(this, response);
1644      return;
1645    }
1646    prefetchCache.clear();
1647    if (this.requestMustRedirect(request) && responseSucceededWithoutRedirect(response)) {
1648      const error = new Error("Form responses must redirect to another location");
1649      this.delegate.formSubmissionErrored(this, error);
1650    } else {
1651      this.state = FormSubmissionState.receiving;
1652      this.result = { success: true, fetchResponse: response };
1653      this.delegate.formSubmissionSucceededWithResponse(this, response);
1654    }
1655  }
1656  requestFailedWithResponse(request, response) {
1657    this.result = { success: false, fetchResponse: response };
1658    this.delegate.formSubmissionFailedWithResponse(this, response);
1659  }
1660  requestErrored(request, error) {
1661    this.result = { success: false, error };
1662    this.delegate.formSubmissionErrored(this, error);
1663  }
1664  requestFinished(_request) {
1665    this.state = FormSubmissionState.stopped;
1666    if (this.submitter) config.forms.submitter.afterSubmit(this.submitter);
1667    this.resetSubmitterText();
1668    clearBusyState(this.formElement);
1669    dispatch("turbo:submit-end", {
1670      target: this.formElement,
1671      detail: { formSubmission: this, ...this.result }
1672    });
1673    this.delegate.formSubmissionFinished(this);
1674  }
1675  // Private
1676  setSubmitsWith() {
1677    if (!this.submitter || !this.submitsWith) return;
1678    if (this.submitter.matches("button")) {
1679      this.originalSubmitText = this.submitter.innerHTML;
1680      this.submitter.innerHTML = this.submitsWith;
1681    } else if (this.submitter.matches("input")) {
1682      const input = this.submitter;
1683      this.originalSubmitText = input.value;
1684      input.value = this.submitsWith;
1685    }
1686  }
1687  resetSubmitterText() {
1688    if (!this.submitter || !this.originalSubmitText) return;
1689    if (this.submitter.matches("button")) {
1690      this.submitter.innerHTML = this.originalSubmitText;
1691    } else if (this.submitter.matches("input")) {
1692      const input = this.submitter;
1693      input.value = this.originalSubmitText;
1694    }
1695  }
1696  requestMustRedirect(request) {
1697    return !request.isSafe && this.mustRedirect;
1698  }
1699  requestAcceptsTurboStreamResponse(request) {
1700    return !request.isSafe || hasAttribute("data-turbo-stream", this.submitter, this.formElement);
1701  }
1702  get submitsWith() {
1703    return this.submitter?.getAttribute("data-turbo-submits-with");
1704  }
1705};
1706function buildFormData(formElement, submitter2) {
1707  const formData = new FormData(formElement);
1708  const name = submitter2?.getAttribute("name");
1709  const value = submitter2?.getAttribute("value");
1710  if (name) {
1711    formData.append(name, value || "");
1712  }
1713  return formData;
1714}
1715function getCookieValue(cookieName) {
1716  if (cookieName != null) {
1717    const cookies = document.cookie ? document.cookie.split("; ") : [];
1718    const cookie = cookies.find((cookie2) => cookie2.startsWith(cookieName));
1719    if (cookie) {
1720      const value = cookie.split("=").slice(1).join("=");
1721      return value ? decodeURIComponent(value) : void 0;
1722    }
1723  }
1724}
1725function responseSucceededWithoutRedirect(response) {
1726  return response.statusCode == 200 && !response.redirected;
1727}
1728function getFormAction(formElement, submitter2) {
1729  const formElementAction = typeof formElement.action === "string" ? formElement.action : null;
1730  if (submitter2?.hasAttribute("formaction")) {
1731    return submitter2.getAttribute("formaction") || "";
1732  } else {
1733    return formElement.getAttribute("action") || formElementAction || "";
1734  }
1735}
1736function getAction(formAction, fetchMethod) {
1737  const action = expandURL(formAction);
1738  if (isSafe(fetchMethod)) {
1739    action.search = "";
1740  }
1741  return action;
1742}
1743function getMethod(formElement, submitter2) {
1744  const method = submitter2?.getAttribute("formmethod") || formElement.getAttribute("method") || "";
1745  return fetchMethodFromString(method.toLowerCase()) || FetchMethod.get;
1746}
1747function getEnctype(formElement, submitter2) {
1748  return fetchEnctypeFromString(submitter2?.getAttribute("formenctype") || formElement.enctype);
1749}
1750var Snapshot = class {
1751  constructor(element) {
1752    this.element = element;
1753  }
1754  get activeElement() {
1755    return this.element.ownerDocument.activeElement;
1756  }
1757  get children() {
1758    return [...this.element.children];
1759  }
1760  hasAnchor(anchor) {
1761    return this.getElementForAnchor(anchor) != null;
1762  }
1763  getElementForAnchor(anchor) {
1764    return anchor ? this.element.querySelector(`[id='${anchor}'], a[name='${anchor}']`) : null;
1765  }
1766  get isConnected() {
1767    return this.element.isConnected;
1768  }
1769  get firstAutofocusableElement() {
1770    return queryAutofocusableElement(this.element);
1771  }
1772  get permanentElements() {
1773    return queryPermanentElementsAll(this.element);
1774  }
1775  getPermanentElementById(id) {
1776    return getPermanentElementById(this.element, id);
1777  }
1778  getPermanentElementMapForSnapshot(snapshot) {
1779    const permanentElementMap = {};
1780    for (const currentPermanentElement of this.permanentElements) {
1781      const { id } = currentPermanentElement;
1782      const newPermanentElement = snapshot.getPermanentElementById(id);
1783      if (newPermanentElement) {
1784        permanentElementMap[id] = [currentPermanentElement, newPermanentElement];
1785      }
1786    }
1787    return permanentElementMap;
1788  }
1789};
1790function getPermanentElementById(node, id) {
1791  return node.querySelector(`#${id}[data-turbo-permanent]`);
1792}
1793function queryPermanentElementsAll(node) {
1794  return node.querySelectorAll("[id][data-turbo-permanent]");
1795}
1796var FormSubmitObserver = class {
1797  started = false;
1798  constructor(delegate, eventTarget) {
1799    this.delegate = delegate;
1800    this.eventTarget = eventTarget;
1801  }
1802  start() {
1803    if (!this.started) {
1804      this.eventTarget.addEventListener("submit", this.submitCaptured, true);
1805      this.started = true;
1806    }
1807  }
1808  stop() {
1809    if (this.started) {
1810      this.eventTarget.removeEventListener("submit", this.submitCaptured, true);
1811      this.started = false;
1812    }
1813  }
1814  submitCaptured = () => {
1815    this.eventTarget.removeEventListener("submit", this.submitBubbled, false);
1816    this.eventTarget.addEventListener("submit", this.submitBubbled, false);
1817  };
1818  submitBubbled = (event) => {
1819    if (!event.defaultPrevented) {
1820      const form = event.target instanceof HTMLFormElement ? event.target : void 0;
1821      const submitter2 = event.submitter || void 0;
1822      if (form && submissionDoesNotDismissDialog(form, submitter2) && submissionDoesNotTargetIFrame(form, submitter2) && this.delegate.willSubmitForm(form, submitter2)) {
1823        event.preventDefault();
1824        event.stopImmediatePropagation();
1825        this.delegate.formSubmitted(form, submitter2);
1826      }
1827    }
1828  };
1829};
1830function submissionDoesNotDismissDialog(form, submitter2) {
1831  const method = submitter2?.getAttribute("formmethod") || form.getAttribute("method");
1832  return method != "dialog";
1833}
1834function submissionDoesNotTargetIFrame(form, submitter2) {
1835  const target = submitter2?.getAttribute("formtarget") || form.getAttribute("target");
1836  return doesNotTargetIFrame(target);
1837}
1838var View = class {
1839  #resolveRenderPromise = (_value) => {
1840  };
1841  #resolveInterceptionPromise = (_value) => {
1842  };
1843  constructor(delegate, element) {
1844    this.delegate = delegate;
1845    this.element = element;
1846  }
1847  // Scrolling
1848  scrollToAnchor(anchor) {
1849    const element = this.snapshot.getElementForAnchor(anchor);
1850    if (element) {
1851      this.scrollToElement(element);
1852      this.focusElement(element);
1853    } else {
1854      this.scrollToPosition({ x: 0, y: 0 });
1855    }
1856  }
1857  scrollToAnchorFromLocation(location2) {
1858    this.scrollToAnchor(getAnchor(location2));
1859  }
1860  scrollToElement(element) {
1861    element.scrollIntoView();
1862  }
1863  focusElement(element) {
1864    if (element instanceof HTMLElement) {
1865      if (element.hasAttribute("tabindex")) {
1866        element.focus();
1867      } else {
1868        element.setAttribute("tabindex", "-1");
1869        element.focus();
1870        element.removeAttribute("tabindex");
1871      }
1872    }
1873  }
1874  scrollToPosition({ x, y }) {
1875    this.scrollRoot.scrollTo(x, y);
1876  }
1877  scrollToTop() {
1878    this.scrollToPosition({ x: 0, y: 0 });
1879  }
1880  get scrollRoot() {
1881    return window;
1882  }
1883  // Rendering
1884  async render(renderer) {
1885    const { isPreview, shouldRender, willRender, newSnapshot: snapshot } = renderer;
1886    const shouldInvalidate = willRender;
1887    if (shouldRender) {
1888      try {
1889        this.renderPromise = new Promise((resolve) => this.#resolveRenderPromise = resolve);
1890        this.renderer = renderer;
1891        await this.prepareToRenderSnapshot(renderer);
1892        const renderInterception = new Promise((resolve) => this.#resolveInterceptionPromise = resolve);
1893        const options = { resume: this.#resolveInterceptionPromise, render: this.renderer.renderElement, renderMethod: this.renderer.renderMethod };
1894        const immediateRender = this.delegate.allowsImmediateRender(snapshot, options);
1895        if (!immediateRender) await renderInterception;
1896        await this.renderSnapshot(renderer);
1897        this.delegate.viewRenderedSnapshot(snapshot, isPreview, this.renderer.renderMethod);
1898        this.delegate.preloadOnLoadLinksForView(this.element);
1899        this.finishRenderingSnapshot(renderer);
1900      } finally {
1901        delete this.renderer;
1902        this.#resolveRenderPromise(void 0);
1903        delete this.renderPromise;
1904      }
1905    } else if (shouldInvalidate) {
1906      this.invalidate(renderer.reloadReason);
1907    }
1908  }
1909  invalidate(reason) {
1910    this.delegate.viewInvalidated(reason);
1911  }
1912  async prepareToRenderSnapshot(renderer) {
1913    this.markAsPreview(renderer.isPreview);
1914    await renderer.prepareToRender();
1915  }
1916  markAsPreview(isPreview) {
1917    if (isPreview) {
1918      this.element.setAttribute("data-turbo-preview", "");
1919    } else {
1920      this.element.removeAttribute("data-turbo-preview");
1921    }
1922  }
1923  markVisitDirection(direction) {
1924    this.element.setAttribute("data-turbo-visit-direction", direction);
1925  }
1926  unmarkVisitDirection() {
1927    this.element.removeAttribute("data-turbo-visit-direction");
1928  }
1929  async renderSnapshot(renderer) {
1930    await renderer.render();
1931  }
1932  finishRenderingSnapshot(renderer) {
1933    renderer.finishRendering();
1934  }
1935};
1936var FrameView = class extends View {
1937  missing() {
1938    this.element.innerHTML = `<strong class="turbo-frame-error">Content missing</strong>`;
1939  }
1940  get snapshot() {
1941    return new Snapshot(this.element);
1942  }
1943};
1944var LinkInterceptor = class {
1945  constructor(delegate, element) {
1946    this.delegate = delegate;
1947    this.element = element;
1948  }
1949  start() {
1950    this.element.addEventListener("click", this.clickBubbled);
1951    document.addEventListener("turbo:click", this.linkClicked);
1952    document.addEventListener("turbo:before-visit", this.willVisit);
1953  }
1954  stop() {
1955    this.element.removeEventListener("click", this.clickBubbled);
1956    document.removeEventListener("turbo:click", this.linkClicked);
1957    document.removeEventListener("turbo:before-visit", this.willVisit);
1958  }
1959  clickBubbled = (event) => {
1960    if (this.clickEventIsSignificant(event)) {
1961      this.clickEvent = event;
1962    } else {
1963      delete this.clickEvent;
1964    }
1965  };
1966  linkClicked = (event) => {
1967    if (this.clickEvent && this.clickEventIsSignificant(event)) {
1968      if (this.delegate.shouldInterceptLinkClick(event.target, event.detail.url, event.detail.originalEvent)) {
1969        this.clickEvent.preventDefault();
1970        event.preventDefault();
1971        this.delegate.linkClickIntercepted(event.target, event.detail.url, event.detail.originalEvent);
1972      }
1973    }
1974    delete this.clickEvent;
1975  };
1976  willVisit = (_event) => {
1977    delete this.clickEvent;
1978  };
1979  clickEventIsSignificant(event) {
1980    const target = event.composed ? event.target?.parentElement : event.target;
1981    const element = findLinkFromClickTarget(target) || target;
1982    return element instanceof Element && element.closest("turbo-frame, html") == this.element;
1983  }
1984};
1985var LinkClickObserver = class {
1986  started = false;
1987  constructor(delegate, eventTarget) {
1988    this.delegate = delegate;
1989    this.eventTarget = eventTarget;
1990  }
1991  start() {
1992    if (!this.started) {
1993      this.eventTarget.addEventListener("click", this.clickCaptured, true);
1994      this.started = true;
1995    }
1996  }
1997  stop() {
1998    if (this.started) {
1999      this.eventTarget.removeEventListener("click", this.clickCaptured, true);
2000      this.started = false;
2001    }
2002  }
2003  clickCaptured = () => {
2004    this.eventTarget.removeEventListener("click", this.clickBubbled, false);
2005    this.eventTarget.addEventListener("click", this.clickBubbled, false);
2006  };
2007  clickBubbled = (event) => {
2008    if (event instanceof MouseEvent && this.clickEventIsSignificant(event)) {
2009      const target = event.composedPath && event.composedPath()[0] || event.target;
2010      const link = findLinkFromClickTarget(target);
2011      if (link && doesNotTargetIFrame(link.target)) {
2012        const location2 = getLocationForLink(link);
2013        if (this.delegate.willFollowLinkToLocation(link, location2, event)) {
2014          event.preventDefault();
2015          this.delegate.followedLinkToLocation(link, location2);
2016        }
2017      }
2018    }
2019  };
2020  clickEventIsSignificant(event) {
2021    return !(event.target && event.target.isContentEditable || event.defaultPrevented || event.which > 1 || event.altKey || event.ctrlKey || event.metaKey || event.shiftKey);
2022  }
2023};
2024var FormLinkClickObserver = class {
2025  constructor(delegate, element) {
2026    this.delegate = delegate;
2027    this.linkInterceptor = new LinkClickObserver(this, element);
2028  }
2029  start() {
2030    this.linkInterceptor.start();
2031  }
2032  stop() {
2033    this.linkInterceptor.stop();
2034  }
2035  // Link hover observer delegate
2036  canPrefetchRequestToLocation(link, location2) {
2037    return false;
2038  }
2039  prefetchAndCacheRequestToLocation(link, location2) {
2040    return;
2041  }
2042  // Link click observer delegate
2043  willFollowLinkToLocation(link, location2, originalEvent) {
2044    return this.delegate.willSubmitFormLinkToLocation(link, location2, originalEvent) && (link.hasAttribute("data-turbo-method") || link.hasAttribute("data-turbo-stream"));
2045  }
2046  followedLinkToLocation(link, location2) {
2047    const form = document.createElement("form");
2048    const type = "hidden";
2049    for (const [name, value] of location2.searchParams) {
2050      form.append(Object.assign(document.createElement("input"), { type, name, value }));
2051    }
2052    const action = Object.assign(location2, { search: "" });
2053    form.setAttribute("data-turbo", "true");
2054    form.setAttribute("action", action.href);
2055    form.setAttribute("hidden", "");
2056    const method = link.getAttribute("data-turbo-method");
2057    if (method) form.setAttribute("method", method);
2058    const turboFrame = link.getAttribute("data-turbo-frame");
2059    if (turboFrame) form.setAttribute("data-turbo-frame", turboFrame);
2060    const turboAction = getVisitAction(link);
2061    if (turboAction) form.setAttribute("data-turbo-action", turboAction);
2062    const turboConfirm = link.getAttribute("data-turbo-confirm");
2063    if (turboConfirm) form.setAttribute("data-turbo-confirm", turboConfirm);
2064    const turboStream = link.hasAttribute("data-turbo-stream");
2065    if (turboStream) form.setAttribute("data-turbo-stream", "");
2066    this.delegate.submittedFormLinkToLocation(link, location2, form);
2067    document.body.appendChild(form);
2068    form.addEventListener("turbo:submit-end", () => form.remove(), { once: true });
2069    requestAnimationFrame(() => form.requestSubmit());
2070  }
2071};
2072var Bardo = class {
2073  static async preservingPermanentElements(delegate, permanentElementMap, callback) {
2074    const bardo = new this(delegate, permanentElementMap);
2075    bardo.enter();
2076    await callback();
2077    bardo.leave();
2078  }
2079  constructor(delegate, permanentElementMap) {
2080    this.delegate = delegate;
2081    this.permanentElementMap = permanentElementMap;
2082  }
2083  enter() {
2084    for (const id in this.permanentElementMap) {
2085      const [currentPermanentElement, newPermanentElement] = this.permanentElementMap[id];
2086      this.delegate.enteringBardo(currentPermanentElement, newPermanentElement);
2087      this.replaceNewPermanentElementWithPlaceholder(newPermanentElement);
2088    }
2089  }
2090  leave() {
2091    for (const id in this.permanentElementMap) {
2092      const [currentPermanentElement] = this.permanentElementMap[id];
2093      this.replaceCurrentPermanentElementWithClone(currentPermanentElement);
2094      this.replacePlaceholderWithPermanentElement(currentPermanentElement);
2095      this.delegate.leavingBardo(currentPermanentElement);
2096    }
2097  }
2098  replaceNewPermanentElementWithPlaceholder(permanentElement) {
2099    const placeholder = createPlaceholderForPermanentElement(permanentElement);
2100    permanentElement.replaceWith(placeholder);
2101  }
2102  replaceCurrentPermanentElementWithClone(permanentElement) {
2103    const clone = permanentElement.cloneNode(true);
2104    permanentElement.replaceWith(clone);
2105  }
2106  replacePlaceholderWithPermanentElement(permanentElement) {
2107    const placeholder = this.getPlaceholderById(permanentElement.id);
2108    placeholder?.replaceWith(permanentElement);
2109  }
2110  getPlaceholderById(id) {
2111    return this.placeholders.find((element) => element.content == id);
2112  }
2113  get placeholders() {
2114    return [...document.querySelectorAll("meta[name=turbo-permanent-placeholder][content]")];
2115  }
2116};
2117function createPlaceholderForPermanentElement(permanentElement) {
2118  const element = document.createElement("meta");
2119  element.setAttribute("name", "turbo-permanent-placeholder");
2120  element.setAttribute("content", permanentElement.id);
2121  return element;
2122}
2123var Renderer = class {
2124  #activeElement = null;
2125  static renderElement(currentElement, newElement) {
2126  }
2127  constructor(currentSnapshot, newSnapshot, isPreview, willRender = true) {
2128    this.currentSnapshot = currentSnapshot;
2129    this.newSnapshot = newSnapshot;
2130    this.isPreview = isPreview;
2131    this.willRender = willRender;
2132    this.renderElement = this.constructor.renderElement;
2133    this.promise = new Promise((resolve, reject) => this.resolvingFunctions = { resolve, reject });
2134  }
2135  get shouldRender() {
2136    return true;
2137  }
2138  get shouldAutofocus() {
2139    return true;
2140  }
2141  get reloadReason() {
2142    return;
2143  }
2144  prepareToRender() {
2145    return;
2146  }
2147  render() {
2148  }
2149  finishRendering() {
2150    if (this.resolvingFunctions) {
2151      this.resolvingFunctions.resolve();
2152      delete this.resolvingFunctions;
2153    }
2154  }
2155  async preservingPermanentElements(callback) {
2156    await Bardo.preservingPermanentElements(this, this.permanentElementMap, callback);
2157  }
2158  focusFirstAutofocusableElement() {
2159    if (this.shouldAutofocus) {
2160      const element = this.connectedSnapshot.firstAutofocusableElement;
2161      if (element) {
2162        element.focus();
2163      }
2164    }
2165  }
2166  // Bardo delegate
2167  enteringBardo(currentPermanentElement) {
2168    if (this.#activeElement) return;
2169    if (currentPermanentElement.contains(this.currentSnapshot.activeElement)) {
2170      this.#activeElement = this.currentSnapshot.activeElement;
2171    }
2172  }
2173  leavingBardo(currentPermanentElement) {
2174    if (currentPermanentElement.contains(this.#activeElement) && this.#activeElement instanceof HTMLElement) {
2175      this.#activeElement.focus();
2176      this.#activeElement = null;
2177    }
2178  }
2179  get connectedSnapshot() {
2180    return this.newSnapshot.isConnected ? this.newSnapshot : this.currentSnapshot;
2181  }
2182  get currentElement() {
2183    return this.currentSnapshot.element;
2184  }
2185  get newElement() {
2186    return this.newSnapshot.element;
2187  }
2188  get permanentElementMap() {
2189    return this.currentSnapshot.getPermanentElementMapForSnapshot(this.newSnapshot);
2190  }
2191  get renderMethod() {
2192    return "replace";
2193  }
2194};
2195var FrameRenderer = class extends Renderer {
2196  static renderElement(currentElement, newElement) {
2197    const destinationRange = document.createRange();
2198    destinationRange.selectNodeContents(currentElement);
2199    destinationRange.deleteContents();
2200    const frameElement = newElement;
2201    const sourceRange = frameElement.ownerDocument?.createRange();
2202    if (sourceRange) {
2203      sourceRange.selectNodeContents(frameElement);
2204      currentElement.appendChild(sourceRange.extractContents());
2205    }
2206  }
2207  constructor(delegate, currentSnapshot, newSnapshot, renderElement, isPreview, willRender = true) {
2208    super(currentSnapshot, newSnapshot, renderElement, isPreview, willRender);
2209    this.delegate = delegate;
2210  }
2211  get shouldRender() {
2212    return true;
2213  }
2214  async render() {
2215    await nextRepaint();
2216    this.preservingPermanentElements(() => {
2217      this.loadFrameElement();
2218    });
2219    this.scrollFrameIntoView();
2220    await nextRepaint();
2221    this.focusFirstAutofocusableElement();
2222    await nextRepaint();
2223    this.activateScriptElements();
2224  }
2225  loadFrameElement() {
2226    this.delegate.willRenderFrame(this.currentElement, this.newElement);
2227    this.renderElement(this.currentElement, this.newElement);
2228  }
2229  scrollFrameIntoView() {
2230    if (this.currentElement.autoscroll || this.newElement.autoscroll) {
2231      const element = this.currentElement.firstElementChild;
2232      const block = readScrollLogicalPosition(this.currentElement.getAttribute("data-autoscroll-block"), "end");
2233      const behavior = readScrollBehavior(this.currentElement.getAttribute("data-autoscroll-behavior"), "auto");
2234      if (element) {
2235        element.scrollIntoView({ block, behavior });
2236        return true;
2237      }
2238    }
2239    return false;
2240  }
2241  activateScriptElements() {
2242    for (const inertScriptElement of this.newScriptElements) {
2243      const activatedScriptElement = activateScriptElement(inertScriptElement);
2244      inertScriptElement.replaceWith(activatedScriptElement);
2245    }
2246  }
2247  get newScriptElements() {
2248    return this.currentElement.querySelectorAll("script");
2249  }
2250};
2251function readScrollLogicalPosition(value, defaultValue) {
2252  if (value == "end" || value == "start" || value == "center" || value == "nearest") {
2253    return value;
2254  } else {
2255    return defaultValue;
2256  }
2257}
2258function readScrollBehavior(value, defaultValue) {
2259  if (value == "auto" || value == "smooth") {
2260    return value;
2261  } else {
2262    return defaultValue;
2263  }
2264}
2265var Idiomorph = (function() {
2266  const noOp = () => {
2267  };
2268  const defaults = {
2269    morphStyle: "outerHTML",
2270    callbacks: {
2271      beforeNodeAdded: noOp,
2272      afterNodeAdded: noOp,
2273      beforeNodeMorphed: noOp,
2274      afterNodeMorphed: noOp,
2275      beforeNodeRemoved: noOp,
2276      afterNodeRemoved: noOp,
2277      beforeAttributeUpdated: noOp
2278    },
2279    head: {
2280      style: "merge",
2281      shouldPreserve: (elt) => elt.getAttribute("im-preserve") === "true",
2282      shouldReAppend: (elt) => elt.getAttribute("im-re-append") === "true",
2283      shouldRemove: noOp,
2284      afterHeadMorphed: noOp
2285    },
2286    restoreFocus: true
2287  };
2288  function morph(oldNode, newContent, config2 = {}) {
2289    oldNode = normalizeElement(oldNode);
2290    const newNode = normalizeParent(newContent);
2291    const ctx = createMorphContext(oldNode, newNode, config2);
2292    const morphedNodes = saveAndRestoreFocus(ctx, () => {
2293      return withHeadBlocking(
2294        ctx,
2295        oldNode,
2296        newNode,
2297        /** @param {MorphContext} ctx */
2298        (ctx2) => {
2299          if (ctx2.morphStyle === "innerHTML") {
2300            morphChildren2(ctx2, oldNode, newNode);
2301            return Array.from(oldNode.childNodes);
2302          } else {
2303            return morphOuterHTML(ctx2, oldNode, newNode);
2304          }
2305        }
2306      );
2307    });
2308    ctx.pantry.remove();
2309    return morphedNodes;
2310  }
2311  function morphOuterHTML(ctx, oldNode, newNode) {
2312    const oldParent = normalizeParent(oldNode);
2313    let childNodes = Array.from(oldParent.childNodes);
2314    const index = childNodes.indexOf(oldNode);
2315    const rightMargin = childNodes.length - (index + 1);
2316    morphChildren2(
2317      ctx,
2318      oldParent,
2319      newNode,
2320      // these two optional params are the secret sauce
2321      oldNode,
2322      // start point for iteration
2323      oldNode.nextSibling
2324      // end point for iteration
2325    );
2326    childNodes = Array.from(oldParent.childNodes);
2327    return childNodes.slice(index, childNodes.length - rightMargin);
2328  }
2329  function saveAndRestoreFocus(ctx, fn) {
2330    if (!ctx.config.restoreFocus) return fn();
2331    let activeElement = (
2332      /** @type {HTMLInputElement|HTMLTextAreaElement|null} */
2333      document.activeElement
2334    );
2335    if (!(activeElement instanceof HTMLInputElement || activeElement instanceof HTMLTextAreaElement)) {
2336      return fn();
2337    }
2338    const { id: activeElementId, selectionStart, selectionEnd } = activeElement;
2339    const results = fn();
2340    if (activeElementId && activeElementId !== document.activeElement?.id) {
2341      activeElement = ctx.target.querySelector(`#${activeElementId}`);
2342      activeElement?.focus();
2343    }
2344    if (activeElement && !activeElement.selectionEnd && selectionEnd) {
2345      activeElement.setSelectionRange(selectionStart, selectionEnd);
2346    }
2347    return results;
2348  }
2349  const morphChildren2 = /* @__PURE__ */ (function() {
2350    function morphChildren3(ctx, oldParent, newParent, insertionPoint = null, endPoint = null) {
2351      if (oldParent instanceof HTMLTemplateElement && newParent instanceof HTMLTemplateElement) {
2352        oldParent = oldParent.content;
2353        newParent = newParent.content;
2354      }
2355      insertionPoint ||= oldParent.firstChild;
2356      for (const newChild of newParent.childNodes) {
2357        if (insertionPoint && insertionPoint != endPoint) {
2358          const bestMatch = findBestMatch(
2359            ctx,
2360            newChild,
2361            insertionPoint,
2362            endPoint
2363          );
2364          if (bestMatch) {
2365            if (bestMatch !== insertionPoint) {
2366              removeNodesBetween(ctx, insertionPoint, bestMatch);
2367            }
2368            morphNode(bestMatch, newChild, ctx);
2369            insertionPoint = bestMatch.nextSibling;
2370            continue;
2371          }
2372        }
2373        if (newChild instanceof Element && ctx.persistentIds.has(newChild.id)) {
2374          const movedChild = moveBeforeById(
2375            oldParent,
2376            newChild.id,
2377            insertionPoint,
2378            ctx
2379          );
2380          morphNode(movedChild, newChild, ctx);
2381          insertionPoint = movedChild.nextSibling;
2382          continue;
2383        }
2384        const insertedNode = createNode(
2385          oldParent,
2386          newChild,
2387          insertionPoint,
2388          ctx
2389        );
2390        if (insertedNode) {
2391          insertionPoint = insertedNode.nextSibling;
2392        }
2393      }
2394      while (insertionPoint && insertionPoint != endPoint) {
2395        const tempNode = insertionPoint;
2396        insertionPoint = insertionPoint.nextSibling;
2397        removeNode(ctx, tempNode);
2398      }
2399    }
2400    function createNode(oldParent, newChild, insertionPoint, ctx) {
2401      if (ctx.callbacks.beforeNodeAdded(newChild) === false) return null;
2402      if (ctx.idMap.has(newChild)) {
2403        const newEmptyChild = document.createElement(
2404          /** @type {Element} */
2405          newChild.tagName
2406        );
2407        oldParent.insertBefore(newEmptyChild, insertionPoint);
2408        morphNode(newEmptyChild, newChild, ctx);
2409        ctx.callbacks.afterNodeAdded(newEmptyChild);
2410        return newEmptyChild;
2411      } else {
2412        const newClonedChild = document.importNode(newChild, true);
2413        oldParent.insertBefore(newClonedChild, insertionPoint);
2414        ctx.callbacks.afterNodeAdded(newClonedChild);
2415        return newClonedChild;
2416      }
2417    }
2418    const findBestMatch = /* @__PURE__ */ (function() {
2419      function findBestMatch2(ctx, node, startPoint, endPoint) {
2420        let softMatch = null;
2421        let nextSibling = node.nextSibling;
2422        let siblingSoftMatchCount = 0;
2423        let cursor = startPoint;
2424        while (cursor && cursor != endPoint) {
2425          if (isSoftMatch(cursor, node)) {
2426            if (isIdSetMatch(ctx, cursor, node)) {
2427              return cursor;
2428            }
2429            if (softMatch === null) {
2430              if (!ctx.idMap.has(cursor)) {
2431                softMatch = cursor;
2432              }
2433            }
2434          }
2435          if (softMatch === null && nextSibling && isSoftMatch(cursor, nextSibling)) {
2436            siblingSoftMatchCount++;
2437            nextSibling = nextSibling.nextSibling;
2438            if (siblingSoftMatchCount >= 2) {
2439              softMatch = void 0;
2440            }
2441          }
2442          if (cursor.contains(document.activeElement)) break;
2443          cursor = cursor.nextSibling;
2444        }
2445        return softMatch || null;
2446      }
2447      function isIdSetMatch(ctx, oldNode, newNode) {
2448        let oldSet = ctx.idMap.get(oldNode);
2449        let newSet = ctx.idMap.get(newNode);
2450        if (!newSet || !oldSet) return false;
2451        for (const id of oldSet) {
2452          if (newSet.has(id)) {
2453            return true;
2454          }
2455        }
2456        return false;
2457      }
2458      function isSoftMatch(oldNode, newNode) {
2459        const oldElt = (
2460          /** @type {Element} */
2461          oldNode
2462        );
2463        const newElt = (
2464          /** @type {Element} */
2465          newNode
2466        );
2467        return oldElt.nodeType === newElt.nodeType && oldElt.tagName === newElt.tagName && // If oldElt has an `id` with possible state and it doesn't match newElt.id then avoid morphing.
2468        // We'll still match an anonymous node with an IDed newElt, though, because if it got this far,
2469        // its not persistent, and new nodes can't have any hidden state.
2470        (!oldElt.id || oldElt.id === newElt.id);
2471      }
2472      return findBestMatch2;
2473    })();
2474    function removeNode(ctx, node) {
2475      if (ctx.idMap.has(node)) {
2476        moveBefore(ctx.pantry, node, null);
2477      } else {
2478        if (ctx.callbacks.beforeNodeRemoved(node) === false) return;
2479        node.parentNode?.removeChild(node);
2480        ctx.callbacks.afterNodeRemoved(node);
2481      }
2482    }
2483    function removeNodesBetween(ctx, startInclusive, endExclusive) {
2484      let cursor = startInclusive;
2485      while (cursor && cursor !== endExclusive) {
2486        let tempNode = (
2487          /** @type {Node} */
2488          cursor
2489        );
2490        cursor = cursor.nextSibling;
2491        removeNode(ctx, tempNode);
2492      }
2493      return cursor;
2494    }
2495    function moveBeforeById(parentNode, id, after, ctx) {
2496      const target = (
2497        /** @type {Element} - will always be found */
2498        ctx.target.querySelector(`#${id}`) || ctx.pantry.querySelector(`#${id}`)
2499      );
2500      removeElementFromAncestorsIdMaps(target, ctx);
2501      moveBefore(parentNode, target, after);
2502      return target;
2503    }
2504    function removeElementFromAncestorsIdMaps(element, ctx) {
2505      const id = element.id;
2506      while (element = element.parentNode) {
2507        let idSet = ctx.idMap.get(element);
2508        if (idSet) {
2509          idSet.delete(id);
2510          if (!idSet.size) {
2511            ctx.idMap.delete(element);
2512          }
2513        }
2514      }
2515    }
2516    function moveBefore(parentNode, element, after) {
2517      if (parentNode.moveBefore) {
2518        try {
2519          parentNode.moveBefore(element, after);
2520        } catch (e) {
2521          parentNode.insertBefore(element, after);
2522        }
2523      } else {
2524        parentNode.insertBefore(element, after);
2525      }
2526    }
2527    return morphChildren3;
2528  })();
2529  const morphNode = /* @__PURE__ */ (function() {
2530    function morphNode2(oldNode, newContent, ctx) {
2531      if (ctx.ignoreActive && oldNode === document.activeElement) {
2532        return null;
2533      }
2534      if (ctx.callbacks.beforeNodeMorphed(oldNode, newContent) === false) {
2535        return oldNode;
2536      }
2537      if (oldNode instanceof HTMLHeadElement && ctx.head.ignore) ;
2538      else if (oldNode instanceof HTMLHeadElement && ctx.head.style !== "morph") {
2539        handleHeadElement(
2540          oldNode,
2541          /** @type {HTMLHeadElement} */
2542          newContent,
2543          ctx
2544        );
2545      } else {
2546        morphAttributes(oldNode, newContent, ctx);
2547        if (!ignoreValueOfActiveElement(oldNode, ctx)) {
2548          morphChildren2(ctx, oldNode, newContent);
2549        }
2550      }
2551      ctx.callbacks.afterNodeMorphed(oldNode, newContent);
2552      return oldNode;
2553    }
2554    function morphAttributes(oldNode, newNode, ctx) {
2555      let type = newNode.nodeType;
2556      if (type === 1) {
2557        const oldElt = (
2558          /** @type {Element} */
2559          oldNode
2560        );
2561        const newElt = (
2562          /** @type {Element} */
2563          newNode
2564        );
2565        const oldAttributes = oldElt.attributes;
2566        const newAttributes = newElt.attributes;
2567        for (const newAttribute of newAttributes) {
2568          if (ignoreAttribute(newAttribute.name, oldElt, "update", ctx)) {
2569            continue;
2570          }
2571          if (oldElt.getAttribute(newAttribute.name) !== newAttribute.value) {
2572            oldElt.setAttribute(newAttribute.name, newAttribute.value);
2573          }
2574        }
2575        for (let i = oldAttributes.length - 1; 0 <= i; i--) {
2576          const oldAttribute = oldAttributes[i];
2577          if (!oldAttribute) continue;
2578          if (!newElt.hasAttribute(oldAttribute.name)) {
2579            if (ignoreAttribute(oldAttribute.name, oldElt, "remove", ctx)) {
2580              continue;
2581            }
2582            oldElt.removeAttribute(oldAttribute.name);
2583          }
2584        }
2585        if (!ignoreValueOfActiveElement(oldElt, ctx)) {
2586          syncInputValue(oldElt, newElt, ctx);
2587        }
2588      }
2589      if (type === 8 || type === 3) {
2590        if (oldNode.nodeValue !== newNode.nodeValue) {
2591          oldNode.nodeValue = newNode.nodeValue;
2592        }
2593      }
2594    }
2595    function syncInputValue(oldElement, newElement, ctx) {
2596      if (oldElement instanceof HTMLInputElement && newElement instanceof HTMLInputElement && newElement.type !== "file") {
2597        let newValue = newElement.value;
2598        let oldValue = oldElement.value;
2599        syncBooleanAttribute(oldElement, newElement, "checked", ctx);
2600        syncBooleanAttribute(oldElement, newElement, "disabled", ctx);
2601        if (!newElement.hasAttribute("value")) {
2602          if (!ignoreAttribute("value", oldElement, "remove", ctx)) {
2603            oldElement.value = "";
2604            oldElement.removeAttribute("value");
2605          }
2606        } else if (oldValue !== newValue) {
2607          if (!ignoreAttribute("value", oldElement, "update", ctx)) {
2608            oldElement.setAttribute("value", newValue);
2609            oldElement.value = newValue;
2610          }
2611        }
2612      } else if (oldElement instanceof HTMLOptionElement && newElement instanceof HTMLOptionElement) {
2613        syncBooleanAttribute(oldElement, newElement, "selected", ctx);
2614      } else if (oldElement instanceof HTMLTextAreaElement && newElement instanceof HTMLTextAreaElement) {
2615        let newValue = newElement.value;
2616        let oldValue = oldElement.value;
2617        if (ignoreAttribute("value", oldElement, "update", ctx)) {
2618          return;
2619        }
2620        if (newValue !== oldValue) {
2621          oldElement.value = newValue;
2622        }
2623        if (oldElement.firstChild && oldElement.firstChild.nodeValue !== newValue) {
2624          oldElement.firstChild.nodeValue = newValue;
2625        }
2626      }
2627    }
2628    function syncBooleanAttribute(oldElement, newElement, attributeName, ctx) {
2629      const newLiveValue = newElement[attributeName], oldLiveValue = oldElement[attributeName];
2630      if (newLiveValue !== oldLiveValue) {
2631        const ignoreUpdate = ignoreAttribute(
2632          attributeName,
2633          oldElement,
2634          "update",
2635          ctx
2636        );
2637        if (!ignoreUpdate) {
2638          oldElement[attributeName] = newElement[attributeName];
2639        }
2640        if (newLiveValue) {
2641          if (!ignoreUpdate) {
2642            oldElement.setAttribute(attributeName, "");
2643          }
2644        } else {
2645          if (!ignoreAttribute(attributeName, oldElement, "remove", ctx)) {
2646            oldElement.removeAttribute(attributeName);
2647          }
2648        }
2649      }
2650    }
2651    function ignoreAttribute(attr, element, updateType, ctx) {
2652      if (attr === "value" && ctx.ignoreActiveValue && element === document.activeElement) {
2653        return true;
2654      }
2655      return ctx.callbacks.beforeAttributeUpdated(attr, element, updateType) === false;
2656    }
2657    function ignoreValueOfActiveElement(possibleActiveElement, ctx) {
2658      return !!ctx.ignoreActiveValue && possibleActiveElement === document.activeElement && possibleActiveElement !== document.body;
2659    }
2660    return morphNode2;
2661  })();
2662  function withHeadBlocking(ctx, oldNode, newNode, callback) {
2663    if (ctx.head.block) {
2664      const oldHead = oldNode.querySelector("head");
2665      const newHead = newNode.querySelector("head");
2666      if (oldHead && newHead) {
2667        const promises = handleHeadElement(oldHead, newHead, ctx);
2668        return Promise.all(promises).then(() => {
2669          const newCtx = Object.assign(ctx, {
2670            head: {
2671              block: false,
2672              ignore: true
2673            }
2674          });
2675          return callback(newCtx);
2676        });
2677      }
2678    }
2679    return callback(ctx);
2680  }
2681  function handleHeadElement(oldHead, newHead, ctx) {
2682    let added = [];
2683    let removed = [];
2684    let preserved = [];
2685    let nodesToAppend = [];
2686    let srcToNewHeadNodes = /* @__PURE__ */ new Map();
2687    for (const newHeadChild of newHead.children) {
2688      srcToNewHeadNodes.set(newHeadChild.outerHTML, newHeadChild);
2689    }
2690    for (const currentHeadElt of oldHead.children) {
2691      let inNewContent = srcToNewHeadNodes.has(currentHeadElt.outerHTML);
2692      let isReAppended = ctx.head.shouldReAppend(currentHeadElt);
2693      let isPreserved = ctx.head.shouldPreserve(currentHeadElt);
2694      if (inNewContent || isPreserved) {
2695        if (isReAppended) {
2696          removed.push(currentHeadElt);
2697        } else {
2698          srcToNewHeadNodes.delete(currentHeadElt.outerHTML);
2699          preserved.push(currentHeadElt);
2700        }
2701      } else {
2702        if (ctx.head.style === "append") {
2703          if (isReAppended) {
2704            removed.push(currentHeadElt);
2705            nodesToAppend.push(currentHeadElt);
2706          }
2707        } else {
2708          if (ctx.head.shouldRemove(currentHeadElt) !== false) {
2709            removed.push(currentHeadElt);
2710          }
2711        }
2712      }
2713    }
2714    nodesToAppend.push(...srcToNewHeadNodes.values());
2715    let promises = [];
2716    for (const newNode of nodesToAppend) {
2717      let newElt = (
2718        /** @type {ChildNode} */
2719        document.createRange().createContextualFragment(newNode.outerHTML).firstChild
2720      );
2721      if (ctx.callbacks.beforeNodeAdded(newElt) !== false) {
2722        if ("href" in newElt && newElt.href || "src" in newElt && newElt.src) {
2723          let resolve;
2724          let promise = new Promise(function(_resolve) {
2725            resolve = _resolve;
2726          });
2727          newElt.addEventListener("load", function() {
2728            resolve();
2729          });
2730          promises.push(promise);
2731        }
2732        oldHead.appendChild(newElt);
2733        ctx.callbacks.afterNodeAdded(newElt);
2734        added.push(newElt);
2735      }
2736    }
2737    for (const removedElement of removed) {
2738      if (ctx.callbacks.beforeNodeRemoved(removedElement) !== false) {
2739        oldHead.removeChild(removedElement);
2740        ctx.callbacks.afterNodeRemoved(removedElement);
2741      }
2742    }
2743    ctx.head.afterHeadMorphed(oldHead, {
2744      added,
2745      kept: preserved,
2746      removed
2747    });
2748    return promises;
2749  }
2750  const createMorphContext = /* @__PURE__ */ (function() {
2751    function createMorphContext2(oldNode, newContent, config2) {
2752      const { persistentIds, idMap } = createIdMaps(oldNode, newContent);
2753      const mergedConfig = mergeDefaults(config2);
2754      const morphStyle = mergedConfig.morphStyle || "outerHTML";
2755      if (!["innerHTML", "outerHTML"].includes(morphStyle)) {
2756        throw `Do not understand how to morph style ${morphStyle}`;
2757      }
2758      return {
2759        target: oldNode,
2760        newContent,
2761        config: mergedConfig,
2762        morphStyle,
2763        ignoreActive: mergedConfig.ignoreActive,
2764        ignoreActiveValue: mergedConfig.ignoreActiveValue,
2765        restoreFocus: mergedConfig.restoreFocus,
2766        idMap,
2767        persistentIds,
2768        pantry: createPantry(),
2769        callbacks: mergedConfig.callbacks,
2770        head: mergedConfig.head
2771      };
2772    }
2773    function mergeDefaults(config2) {
2774      let finalConfig = Object.assign({}, defaults);
2775      Object.assign(finalConfig, config2);
2776      finalConfig.callbacks = Object.assign(
2777        {},
2778        defaults.callbacks,
2779        config2.callbacks
2780      );
2781      finalConfig.head = Object.assign({}, defaults.head, config2.head);
2782      return finalConfig;
2783    }
2784    function createPantry() {
2785      const pantry = document.createElement("div");
2786      pantry.hidden = true;
2787      document.body.insertAdjacentElement("afterend", pantry);
2788      return pantry;
2789    }
2790    function findIdElements(root) {
2791      let elements = Array.from(root.querySelectorAll("[id]"));
2792      if (root.id) {
2793        elements.push(root);
2794      }
2795      return elements;
2796    }
2797    function populateIdMapWithTree(idMap, persistentIds, root, elements) {
2798      for (const elt of elements) {
2799        if (persistentIds.has(elt.id)) {
2800          let current = elt;
2801          while (current) {
2802            let idSet = idMap.get(current);
2803            if (idSet == null) {
2804              idSet = /* @__PURE__ */ new Set();
2805              idMap.set(current, idSet);
2806            }
2807            idSet.add(elt.id);
2808            if (current === root) break;
2809            current = current.parentElement;
2810          }
2811        }
2812      }
2813    }
2814    function createIdMaps(oldContent, newContent) {
2815      const oldIdElements = findIdElements(oldContent);
2816      const newIdElements = findIdElements(newContent);
2817      const persistentIds = createPersistentIds(oldIdElements, newIdElements);
2818      let idMap = /* @__PURE__ */ new Map();
2819      populateIdMapWithTree(idMap, persistentIds, oldContent, oldIdElements);
2820      const newRoot = newContent.__idiomorphRoot || newContent;
2821      populateIdMapWithTree(idMap, persistentIds, newRoot, newIdElements);
2822      return { persistentIds, idMap };
2823    }
2824    function createPersistentIds(oldIdElements, newIdElements) {
2825      let duplicateIds = /* @__PURE__ */ new Set();
2826      let oldIdTagNameMap = /* @__PURE__ */ new Map();
2827      for (const { id, tagName } of oldIdElements) {
2828        if (oldIdTagNameMap.has(id)) {
2829          duplicateIds.add(id);
2830        } else {
2831          oldIdTagNameMap.set(id, tagName);
2832        }
2833      }
2834      let persistentIds = /* @__PURE__ */ new Set();
2835      for (const { id, tagName } of newIdElements) {
2836        if (persistentIds.has(id)) {
2837          duplicateIds.add(id);
2838        } else if (oldIdTagNameMap.get(id) === tagName) {
2839          persistentIds.add(id);
2840        }
2841      }
2842      for (const id of duplicateIds) {
2843        persistentIds.delete(id);
2844      }
2845      return persistentIds;
2846    }
2847    return createMorphContext2;
2848  })();
2849  const { normalizeElement, normalizeParent } = /* @__PURE__ */ (function() {
2850    const generatedByIdiomorph = /* @__PURE__ */ new WeakSet();
2851    function normalizeElement2(content) {
2852      if (content instanceof Document) {
2853        return content.documentElement;
2854      } else {
2855        return content;
2856      }
2857    }
2858    function normalizeParent2(newContent) {
2859      if (newContent == null) {
2860        return document.createElement("div");
2861      } else if (typeof newContent === "string") {
2862        return normalizeParent2(parseContent(newContent));
2863      } else if (generatedByIdiomorph.has(
2864        /** @type {Element} */
2865        newContent
2866      )) {
2867        return (
2868          /** @type {Element} */
2869          newContent
2870        );
2871      } else if (newContent instanceof Node) {
2872        if (newContent.parentNode) {
2873          return createDuckTypedParent(newContent);
2874        } else {
2875          const dummyParent = document.createElement("div");
2876          dummyParent.append(newContent);
2877          return dummyParent;
2878        }
2879      } else {
2880        const dummyParent = document.createElement("div");
2881        for (const elt of [...newContent]) {
2882          dummyParent.append(elt);
2883        }
2884        return dummyParent;
2885      }
2886    }
2887    function createDuckTypedParent(newContent) {
2888      return (
2889        /** @type {Element} */
2890        /** @type {unknown} */
2891        {
2892          childNodes: [newContent],
2893          /** @ts-ignore - cover your eyes for a minute, tsc */
2894          querySelectorAll: (s) => {
2895            const elements = newContent.querySelectorAll(s);
2896            return newContent.matches(s) ? [newContent, ...elements] : elements;
2897          },
2898          /** @ts-ignore */
2899          insertBefore: (n, r) => newContent.parentNode.insertBefore(n, r),
2900          /** @ts-ignore */
2901          moveBefore: (n, r) => newContent.parentNode.moveBefore(n, r),
2902          // for later use with populateIdMapWithTree to halt upwards iteration
2903          get __idiomorphRoot() {
2904            return newContent;
2905          }
2906        }
2907      );
2908    }
2909    function parseContent(newContent) {
2910      let parser = new DOMParser();
2911      let contentWithSvgsRemoved = newContent.replace(
2912        /<svg(\s[^>]*>|>)([\s\S]*?)<\/svg>/gim,
2913        ""
2914      );
2915      if (contentWithSvgsRemoved.match(/<\/html>/) || contentWithSvgsRemoved.match(/<\/head>/) || contentWithSvgsRemoved.match(/<\/body>/)) {
2916        let content = parser.parseFromString(newContent, "text/html");
2917        if (contentWithSvgsRemoved.match(/<\/html>/)) {
2918          generatedByIdiomorph.add(content);
2919          return content;
2920        } else {
2921          let htmlElement = content.firstChild;
2922          if (htmlElement) {
2923            generatedByIdiomorph.add(htmlElement);
2924          }
2925          return htmlElement;
2926        }
2927      } else {
2928        let responseDoc = parser.parseFromString(
2929          "<body><template>" + newContent + "</template></body>",
2930          "text/html"
2931        );
2932        let content = (
2933          /** @type {HTMLTemplateElement} */
2934          responseDoc.body.querySelector("template").content
2935        );
2936        generatedByIdiomorph.add(content);
2937        return content;
2938      }
2939    }
2940    return { normalizeElement: normalizeElement2, normalizeParent: normalizeParent2 };
2941  })();
2942  return {
2943    morph,
2944    defaults
2945  };
2946})();
2947function morphElements(currentElement, newElement, { callbacks, ...options } = {}) {
2948  Idiomorph.morph(currentElement, newElement, {
2949    ...options,
2950    callbacks: new DefaultIdiomorphCallbacks(callbacks)
2951  });
2952}
2953function morphChildren(currentElement, newElement) {
2954  morphElements(currentElement, newElement.childNodes, {
2955    morphStyle: "innerHTML"
2956  });
2957}
2958var DefaultIdiomorphCallbacks = class {
2959  #beforeNodeMorphed;
2960  constructor({ beforeNodeMorphed } = {}) {
2961    this.#beforeNodeMorphed = beforeNodeMorphed || (() => true);
2962  }
2963  beforeNodeAdded = (node) => {
2964    return !(node.id && node.hasAttribute("data-turbo-permanent") && document.getElementById(node.id));
2965  };
2966  beforeNodeMorphed = (currentElement, newElement) => {
2967    if (currentElement instanceof Element) {
2968      if (!currentElement.hasAttribute("data-turbo-permanent") && this.#beforeNodeMorphed(currentElement, newElement)) {
2969        const event = dispatch("turbo:before-morph-element", {
2970          cancelable: true,
2971          target: currentElement,
2972          detail: { currentElement, newElement }
2973        });
2974        return !event.defaultPrevented;
2975      } else {
2976        return false;
2977      }
2978    }
2979  };
2980  beforeAttributeUpdated = (attributeName, target, mutationType) => {
2981    const event = dispatch("turbo:before-morph-attribute", {
2982      cancelable: true,
2983      target,
2984      detail: { attributeName, mutationType }
2985    });
2986    return !event.defaultPrevented;
2987  };
2988  beforeNodeRemoved = (node) => {
2989    return this.beforeNodeMorphed(node);
2990  };
2991  afterNodeMorphed = (currentElement, newElement) => {
2992    if (currentElement instanceof Element) {
2993      dispatch("turbo:morph-element", {
2994        target: currentElement,
2995        detail: { currentElement, newElement }
2996      });
2997    }
2998  };
2999};
3000var MorphingFrameRenderer = class extends FrameRenderer {
3001  static renderElement(currentElement, newElement) {
3002    dispatch("turbo:before-frame-morph", {
3003      target: currentElement,
3004      detail: { currentElement, newElement }
3005    });
3006    morphChildren(currentElement, newElement);
3007  }
3008  async preservingPermanentElements(callback) {
3009    return await callback();
3010  }
3011};
3012var ProgressBar = class _ProgressBar {
3013  static animationDuration = 300;
3014  /*ms*/
3015  static get defaultCSS() {
3016    return unindent`
3017      .turbo-progress-bar {
3018        position: fixed;
3019        display: block;
3020        top: 0;
3021        left: 0;
3022        height: 3px;
3023        background: #0076ff;
3024        z-index: 2147483647;
3025        transition:
3026          width ${_ProgressBar.animationDuration}ms ease-out,
3027          opacity ${_ProgressBar.animationDuration / 2}ms ${_ProgressBar.animationDuration / 2}ms ease-in;
3028        transform: translate3d(0, 0, 0);
3029      }
3030    `;
3031  }
3032  hiding = false;
3033  value = 0;
3034  visible = false;
3035  constructor() {
3036    this.stylesheetElement = this.createStylesheetElement();
3037    this.progressElement = this.createProgressElement();
3038    this.installStylesheetElement();
3039    this.setValue(0);
3040  }
3041  show() {
3042    if (!this.visible) {
3043      this.visible = true;
3044      this.installProgressElement();
3045      this.startTrickling();
3046    }
3047  }
3048  hide() {
3049    if (this.visible && !this.hiding) {
3050      this.hiding = true;
3051      this.fadeProgressElement(() => {
3052        this.uninstallProgressElement();
3053        this.stopTrickling();
3054        this.visible = false;
3055        this.hiding = false;
3056      });
3057    }
3058  }
3059  setValue(value) {
3060    this.value = value;
3061    this.refresh();
3062  }
3063  // Private
3064  installStylesheetElement() {
3065    document.head.insertBefore(this.stylesheetElement, document.head.firstChild);
3066  }
3067  installProgressElement() {
3068    this.progressElement.style.width = "0";
3069    this.progressElement.style.opacity = "1";
3070    document.documentElement.insertBefore(this.progressElement, document.body);
3071    this.refresh();
3072  }
3073  fadeProgressElement(callback) {
3074    this.progressElement.style.opacity = "0";
3075    setTimeout(callback, _ProgressBar.animationDuration * 1.5);
3076  }
3077  uninstallProgressElement() {
3078    if (this.progressElement.parentNode) {
3079      document.documentElement.removeChild(this.progressElement);
3080    }
3081  }
3082  startTrickling() {
3083    if (!this.trickleInterval) {
3084      this.trickleInterval = window.setInterval(this.trickle, _ProgressBar.animationDuration);
3085    }
3086  }
3087  stopTrickling() {
3088    window.clearInterval(this.trickleInterval);
3089    delete this.trickleInterval;
3090  }
3091  trickle = () => {
3092    this.setValue(this.value + Math.random() / 100);
3093  };
3094  refresh() {
3095    requestAnimationFrame(() => {
3096      this.progressElement.style.width = `${10 + this.value * 90}%`;
3097    });
3098  }
3099  createStylesheetElement() {
3100    const element = document.createElement("style");
3101    element.type = "text/css";
3102    element.textContent = _ProgressBar.defaultCSS;
3103    const cspNonce = getCspNonce();
3104    if (cspNonce) {
3105      element.nonce = cspNonce;
3106    }
3107    return element;
3108  }
3109  createProgressElement() {
3110    const element = document.createElement("div");
3111    element.className = "turbo-progress-bar";
3112    return element;
3113  }
3114};
3115var HeadSnapshot = class extends Snapshot {
3116  detailsByOuterHTML = this.children.filter((element) => !elementIsNoscript(element)).map((element) => elementWithoutNonce(element)).reduce((result, element) => {
3117    const { outerHTML } = element;
3118    const details = outerHTML in result ? result[outerHTML] : {
3119      type: elementType(element),
3120      tracked: elementIsTracked(element),
3121      elements: []
3122    };
3123    return {
3124      ...result,
3125      [outerHTML]: {
3126        ...details,
3127        elements: [...details.elements, element]
3128      }
3129    };
3130  }, {});
3131  get trackedElementSignature() {
3132    return Object.keys(this.detailsByOuterHTML).filter((outerHTML) => this.detailsByOuterHTML[outerHTML].tracked).join("");
3133  }
3134  getScriptElementsNotInSnapshot(snapshot) {
3135    return this.getElementsMatchingTypeNotInSnapshot("script", snapshot);
3136  }
3137  getStylesheetElementsNotInSnapshot(snapshot) {
3138    return this.getElementsMatchingTypeNotInSnapshot("stylesheet", snapshot);
3139  }
3140  getElementsMatchingTypeNotInSnapshot(matchedType, snapshot) {
3141    return Object.keys(this.detailsByOuterHTML).filter((outerHTML) => !(outerHTML in snapshot.detailsByOuterHTML)).map((outerHTML) => this.detailsByOuterHTML[outerHTML]).filter(({ type }) => type == matchedType).map(({ elements: [element] }) => element);
3142  }
3143  get provisionalElements() {
3144    return Object.keys(this.detailsByOuterHTML).reduce((result, outerHTML) => {
3145      const { type, tracked, elements } = this.detailsByOuterHTML[outerHTML];
3146      if (type == null && !tracked) {
3147        return [...result, ...elements];
3148      } else if (elements.length > 1) {
3149        return [...result, ...elements.slice(1)];
3150      } else {
3151        return result;
3152      }
3153    }, []);
3154  }
3155  getMetaValue(name) {
3156    const element = this.findMetaElementByName(name);
3157    return element ? element.getAttribute("content") : null;
3158  }
3159  findMetaElementByName(name) {
3160    return Object.keys(this.detailsByOuterHTML).reduce((result, outerHTML) => {
3161      const {
3162        elements: [element]
3163      } = this.detailsByOuterHTML[outerHTML];
3164      return elementIsMetaElementWithName(element, name) ? element : result;
3165    }, void 0 | void 0);
3166  }
3167};
3168function elementType(element) {
3169  if (elementIsScript(element)) {
3170    return "script";
3171  } else if (elementIsStylesheet(element)) {
3172    return "stylesheet";
3173  }
3174}
3175function elementIsTracked(element) {
3176  return element.getAttribute("data-turbo-track") == "reload";
3177}
3178function elementIsScript(element) {
3179  const tagName = element.localName;
3180  return tagName == "script";
3181}
3182function elementIsNoscript(element) {
3183  const tagName = element.localName;
3184  return tagName == "noscript";
3185}
3186function elementIsStylesheet(element) {
3187  const tagName = element.localName;
3188  return tagName == "style" || tagName == "link" && element.getAttribute("rel") == "stylesheet";
3189}
3190function elementIsMetaElementWithName(element, name) {
3191  const tagName = element.localName;
3192  return tagName == "meta" && element.getAttribute("name") == name;
3193}
3194function elementWithoutNonce(element) {
3195  if (element.hasAttribute("nonce")) {
3196    element.setAttribute("nonce", "");
3197  }
3198  return element;
3199}
3200var PageSnapshot = class _PageSnapshot extends Snapshot {
3201  static fromHTMLString(html = "") {
3202    return this.fromDocument(parseHTMLDocument(html));
3203  }
3204  static fromElement(element) {
3205    return this.fromDocument(element.ownerDocument);
3206  }
3207  static fromDocument({ documentElement, body, head }) {
3208    return new this(documentElement, body, new HeadSnapshot(head));
3209  }
3210  constructor(documentElement, body, headSnapshot) {
3211    super(body);
3212    this.documentElement = documentElement;
3213    this.headSnapshot = headSnapshot;
3214  }
3215  clone() {
3216    const clonedElement = this.element.cloneNode(true);
3217    const selectElements = this.element.querySelectorAll("select");
3218    const clonedSelectElements = clonedElement.querySelectorAll("select");
3219    for (const [index, source] of selectElements.entries()) {
3220      const clone = clonedSelectElements[index];
3221      for (const option of clone.selectedOptions) option.selected = false;
3222      for (const option of source.selectedOptions) clone.options[option.index].selected = true;
3223    }
3224    for (const clonedPasswordInput of clonedElement.querySelectorAll('input[type="password"]')) {
3225      clonedPasswordInput.value = "";
3226    }
3227    return new _PageSnapshot(this.documentElement, clonedElement, this.headSnapshot);
3228  }
3229  get lang() {
3230    return this.documentElement.getAttribute("lang");
3231  }
3232  get headElement() {
3233    return this.headSnapshot.element;
3234  }
3235  get rootLocation() {
3236    const root = this.getSetting("root") ?? "/";
3237    return expandURL(root);
3238  }
3239  get cacheControlValue() {
3240    return this.getSetting("cache-control");
3241  }
3242  get isPreviewable() {
3243    return this.cacheControlValue != "no-preview";
3244  }
3245  get isCacheable() {
3246    return this.cacheControlValue != "no-cache";
3247  }
3248  get isVisitable() {
3249    return this.getSetting("visit-control") != "reload";
3250  }
3251  get prefersViewTransitions() {
3252    return this.headSnapshot.getMetaValue("view-transition") === "same-origin";
3253  }
3254  get shouldMorphPage() {
3255    return this.getSetting("refresh-method") === "morph";
3256  }
3257  get shouldPreserveScrollPosition() {
3258    return this.getSetting("refresh-scroll") === "preserve";
3259  }
3260  // Private
3261  getSetting(name) {
3262    return this.headSnapshot.getMetaValue(`turbo-${name}`);
3263  }
3264};
3265var ViewTransitioner = class {
3266  #viewTransitionStarted = false;
3267  #lastOperation = Promise.resolve();
3268  renderChange(useViewTransition, render) {
3269    if (useViewTransition && this.viewTransitionsAvailable && !this.#viewTransitionStarted) {
3270      this.#viewTransitionStarted = true;
3271      this.#lastOperation = this.#lastOperation.then(async () => {
3272        await document.startViewTransition(render).finished;
3273      });
3274    } else {
3275      this.#lastOperation = this.#lastOperation.then(render);
3276    }
3277    return this.#lastOperation;
3278  }
3279  get viewTransitionsAvailable() {
3280    return document.startViewTransition;
3281  }
3282};
3283var defaultOptions = {
3284  action: "advance",
3285  historyChanged: false,
3286  visitCachedSnapshot: () => {
3287  },
3288  willRender: true,
3289  updateHistory: true,
3290  shouldCacheSnapshot: true,
3291  acceptsStreamResponse: false
3292};
3293var TimingMetric = {
3294  visitStart: "visitStart",
3295  requestStart: "requestStart",
3296  requestEnd: "requestEnd",
3297  visitEnd: "visitEnd"
3298};
3299var VisitState = {
3300  initialized: "initialized",
3301  started: "started",
3302  canceled: "canceled",
3303  failed: "failed",
3304  completed: "completed"
3305};
3306var SystemStatusCode = {
3307  networkFailure: 0,
3308  timeoutFailure: -1,
3309  contentTypeMismatch: -2
3310};
3311var Direction = {
3312  advance: "forward",
3313  restore: "back",
3314  replace: "none"
3315};
3316var Visit = class {
3317  identifier = uuid();
3318  // Required by turbo-ios
3319  timingMetrics = {};
3320  followedRedirect = false;
3321  historyChanged = false;
3322  scrolled = false;
3323  shouldCacheSnapshot = true;
3324  acceptsStreamResponse = false;
3325  snapshotCached = false;
3326  state = VisitState.initialized;
3327  viewTransitioner = new ViewTransitioner();
3328  constructor(delegate, location2, restorationIdentifier, options = {}) {
3329    this.delegate = delegate;
3330    this.location = location2;
3331    this.restorationIdentifier = restorationIdentifier || uuid();
3332    const {
3333      action,
3334      historyChanged,
3335      referrer,
3336      snapshot,
3337      snapshotHTML,
3338      response,
3339      visitCachedSnapshot,
3340      willRender,
3341      updateHistory,
3342      shouldCacheSnapshot,
3343      acceptsStreamResponse,
3344      direction
3345    } = {
3346      ...defaultOptions,
3347      ...options
3348    };
3349    this.action = action;
3350    this.historyChanged = historyChanged;
3351    this.referrer = referrer;
3352    this.snapshot = snapshot;
3353    this.snapshotHTML = snapshotHTML;
3354    this.response = response;
3355    this.isSamePage = this.delegate.locationWithActionIsSamePage(this.location, this.action);
3356    this.isPageRefresh = this.view.isPageRefresh(this);
3357    this.visitCachedSnapshot = visitCachedSnapshot;
3358    this.willRender = willRender;
3359    this.updateHistory = updateHistory;
3360    this.scrolled = !willRender;
3361    this.shouldCacheSnapshot = shouldCacheSnapshot;
3362    this.acceptsStreamResponse = acceptsStreamResponse;
3363    this.direction = direction || Direction[action];
3364  }
3365  get adapter() {
3366    return this.delegate.adapter;
3367  }
3368  get view() {
3369    return this.delegate.view;
3370  }
3371  get history() {
3372    return this.delegate.history;
3373  }
3374  get restorationData() {
3375    return this.history.getRestorationDataForIdentifier(this.restorationIdentifier);
3376  }
3377  get silent() {
3378    return this.isSamePage;
3379  }
3380  start() {
3381    if (this.state == VisitState.initialized) {
3382      this.recordTimingMetric(TimingMetric.visitStart);
3383      this.state = VisitState.started;
3384      this.adapter.visitStarted(this);
3385      this.delegate.visitStarted(this);
3386    }
3387  }
3388  cancel() {
3389    if (this.state == VisitState.started) {
3390      if (this.request) {
3391        this.request.cancel();
3392      }
3393      this.cancelRender();
3394      this.state = VisitState.canceled;
3395    }
3396  }
3397  complete() {
3398    if (this.state == VisitState.started) {
3399      this.recordTimingMetric(TimingMetric.visitEnd);
3400      this.adapter.visitCompleted(this);
3401      this.state = VisitState.completed;
3402      this.followRedirect();
3403      if (!this.followedRedirect) {
3404        this.delegate.visitCompleted(this);
3405      }
3406    }
3407  }
3408  fail() {
3409    if (this.state == VisitState.started) {
3410      this.state = VisitState.failed;
3411      this.adapter.visitFailed(this);
3412      this.delegate.visitCompleted(this);
3413    }
3414  }
3415  changeHistory() {
3416    if (!this.historyChanged && this.updateHistory) {
3417      const actionForHistory = this.location.href === this.referrer?.href ? "replace" : this.action;
3418      const method = getHistoryMethodForAction(actionForHistory);
3419      this.history.update(method, this.location, this.restorationIdentifier);
3420      this.historyChanged = true;
3421    }
3422  }
3423  issueRequest() {
3424    if (this.hasPreloadedResponse()) {
3425      this.simulateRequest();
3426    } else if (this.shouldIssueRequest() && !this.request) {
3427      this.request = new FetchRequest(this, FetchMethod.get, this.location);
3428      this.request.perform();
3429    }
3430  }
3431  simulateRequest() {
3432    if (this.response) {
3433      this.startRequest();
3434      this.recordResponse();
3435      this.finishRequest();
3436    }
3437  }
3438  startRequest() {
3439    this.recordTimingMetric(TimingMetric.requestStart);
3440    this.adapter.visitRequestStarted(this);
3441  }
3442  recordResponse(response = this.response) {
3443    this.response = response;
3444    if (response) {
3445      const { statusCode } = response;
3446      if (isSuccessful(statusCode)) {
3447        this.adapter.visitRequestCompleted(this);
3448      } else {
3449        this.adapter.visitRequestFailedWithStatusCode(this, statusCode);
3450      }
3451    }
3452  }
3453  finishRequest() {
3454    this.recordTimingMetric(TimingMetric.requestEnd);
3455    this.adapter.visitRequestFinished(this);
3456  }
3457  loadResponse() {
3458    if (this.response) {
3459      const { statusCode, responseHTML } = this.response;
3460      this.render(async () => {
3461        if (this.shouldCacheSnapshot) this.cacheSnapshot();
3462        if (this.view.renderPromise) await this.view.renderPromise;
3463        if (isSuccessful(statusCode) && responseHTML != null) {
3464          const snapshot = PageSnapshot.fromHTMLString(responseHTML);
3465          await this.renderPageSnapshot(snapshot, false);
3466          this.adapter.visitRendered(this);
3467          this.complete();
3468        } else {
3469          await this.view.renderError(PageSnapshot.fromHTMLString(responseHTML), this);
3470          this.adapter.visitRendered(this);
3471          this.fail();
3472        }
3473      });
3474    }
3475  }
3476  getCachedSnapshot() {
3477    const snapshot = this.view.getCachedSnapshotForLocation(this.location) || this.getPreloadedSnapshot();
3478    if (snapshot && (!getAnchor(this.location) || snapshot.hasAnchor(getAnchor(this.location)))) {
3479      if (this.action == "restore" || snapshot.isPreviewable) {
3480        return snapshot;
3481      }
3482    }
3483  }
3484  getPreloadedSnapshot() {
3485    if (this.snapshotHTML) {
3486      return PageSnapshot.fromHTMLString(this.snapshotHTML);
3487    }
3488  }
3489  hasCachedSnapshot() {
3490    return this.getCachedSnapshot() != null;
3491  }
3492  loadCachedSnapshot() {
3493    const snapshot = this.getCachedSnapshot();
3494    if (snapshot) {
3495      const isPreview = this.shouldIssueRequest();
3496      this.render(async () => {
3497        this.cacheSnapshot();
3498        if (this.isSamePage || this.isPageRefresh) {
3499          this.adapter.visitRendered(this);
3500        } else {
3501          if (this.view.renderPromise) await this.view.renderPromise;
3502          await this.renderPageSnapshot(snapshot, isPreview);
3503          this.adapter.visitRendered(this);
3504          if (!isPreview) {
3505            this.complete();
3506          }
3507        }
3508      });
3509    }
3510  }
3511  followRedirect() {
3512    if (this.redirectedToLocation && !this.followedRedirect && this.response?.redirected) {
3513      this.adapter.visitProposedToLocation(this.redirectedToLocation, {
3514        action: "replace",
3515        response: this.response,
3516        shouldCacheSnapshot: false,
3517        willRender: false
3518      });
3519      this.followedRedirect = true;
3520    }
3521  }
3522  goToSamePageAnchor() {
3523    if (this.isSamePage) {
3524      this.render(async () => {
3525        this.cacheSnapshot();
3526        this.performScroll();
3527        this.changeHistory();
3528        this.adapter.visitRendered(this);
3529      });
3530    }
3531  }
3532  // Fetch request delegate
3533  prepareRequest(request) {
3534    if (this.acceptsStreamResponse) {
3535      request.acceptResponseType(StreamMessage.contentType);
3536    }
3537  }
3538  requestStarted() {
3539    this.startRequest();
3540  }
3541  requestPreventedHandlingResponse(_request, _response) {
3542  }
3543  async requestSucceededWithResponse(request, response) {
3544    const responseHTML = await response.responseHTML;
3545    const { redirected, statusCode } = response;
3546    if (responseHTML == void 0) {
3547      this.recordResponse({
3548        statusCode: SystemStatusCode.contentTypeMismatch,
3549        redirected
3550      });
3551    } else {
3552      this.redirectedToLocation = response.redirected ? response.location : void 0;
3553      this.recordResponse({ statusCode, responseHTML, redirected });
3554    }
3555  }
3556  async requestFailedWithResponse(request, response) {
3557    const responseHTML = await response.responseHTML;
3558    const { redirected, statusCode } = response;
3559    if (responseHTML == void 0) {
3560      this.recordResponse({
3561        statusCode: SystemStatusCode.contentTypeMismatch,
3562        redirected
3563      });
3564    } else {
3565      this.recordResponse({ statusCode, responseHTML, redirected });
3566    }
3567  }
3568  requestErrored(_request, _error) {
3569    this.recordResponse({
3570      statusCode: SystemStatusCode.networkFailure,
3571      redirected: false
3572    });
3573  }
3574  requestFinished() {
3575    this.finishRequest();
3576  }
3577  // Scrolling
3578  performScroll() {
3579    if (!this.scrolled && !this.view.forceReloaded && !this.view.shouldPreserveScrollPosition(this)) {
3580      if (this.action == "restore") {
3581        this.scrollToRestoredPosition() || this.scrollToAnchor() || this.view.scrollToTop();
3582      } else {
3583        this.scrollToAnchor() || this.view.scrollToTop();
3584      }
3585      if (this.isSamePage) {
3586        this.delegate.visitScrolledToSamePageLocation(this.view.lastRenderedLocation, this.location);
3587      }
3588      this.scrolled = true;
3589    }
3590  }
3591  scrollToRestoredPosition() {
3592    const { scrollPosition } = this.restorationData;
3593    if (scrollPosition) {
3594      this.view.scrollToPosition(scrollPosition);
3595      return true;
3596    }
3597  }
3598  scrollToAnchor() {
3599    const anchor = getAnchor(this.location);
3600    if (anchor != null) {
3601      this.view.scrollToAnchor(anchor);
3602      return true;
3603    }
3604  }
3605  // Instrumentation
3606  recordTimingMetric(metric) {
3607    this.timingMetrics[metric] = (/* @__PURE__ */ new Date()).getTime();
3608  }
3609  getTimingMetrics() {
3610    return { ...this.timingMetrics };
3611  }
3612  // Private
3613  hasPreloadedResponse() {
3614    return typeof this.response == "object";
3615  }
3616  shouldIssueRequest() {
3617    if (this.isSamePage) {
3618      return false;
3619    } else if (this.action == "restore") {
3620      return !this.hasCachedSnapshot();
3621    } else {
3622      return this.willRender;
3623    }
3624  }
3625  cacheSnapshot() {
3626    if (!this.snapshotCached) {
3627      this.view.cacheSnapshot(this.snapshot).then((snapshot) => snapshot && this.visitCachedSnapshot(snapshot));
3628      this.snapshotCached = true;
3629    }
3630  }
3631  async render(callback) {
3632    this.cancelRender();
3633    await new Promise((resolve) => {
3634      this.frame = document.visibilityState === "hidden" ? setTimeout(() => resolve(), 0) : requestAnimationFrame(() => resolve());
3635    });
3636    await callback();
3637    delete this.frame;
3638  }
3639  async renderPageSnapshot(snapshot, isPreview) {
3640    await this.viewTransitioner.renderChange(this.view.shouldTransitionTo(snapshot), async () => {
3641      await this.view.renderPage(snapshot, isPreview, this.willRender, this);
3642      this.performScroll();
3643    });
3644  }
3645  cancelRender() {
3646    if (this.frame) {
3647      cancelAnimationFrame(this.frame);
3648      delete this.frame;
3649    }
3650  }
3651};
3652function isSuccessful(statusCode) {
3653  return statusCode >= 200 && statusCode < 300;
3654}
3655var BrowserAdapter = class {
3656  progressBar = new ProgressBar();
3657  constructor(session2) {
3658    this.session = session2;
3659  }
3660  visitProposedToLocation(location2, options) {
3661    if (locationIsVisitable(location2, this.navigator.rootLocation)) {
3662      this.navigator.startVisit(location2, options?.restorationIdentifier || uuid(), options);
3663    } else {
3664      window.location.href = location2.toString();
3665    }
3666  }
3667  visitStarted(visit2) {
3668    this.location = visit2.location;
3669    visit2.loadCachedSnapshot();
3670    visit2.issueRequest();
3671    visit2.goToSamePageAnchor();
3672  }
3673  visitRequestStarted(visit2) {
3674    this.progressBar.setValue(0);
3675    if (visit2.hasCachedSnapshot() || visit2.action != "restore") {
3676      this.showVisitProgressBarAfterDelay();
3677    } else {
3678      this.showProgressBar();
3679    }
3680  }
3681  visitRequestCompleted(visit2) {
3682    visit2.loadResponse();
3683  }
3684  visitRequestFailedWithStatusCode(visit2, statusCode) {
3685    switch (statusCode) {
3686      case SystemStatusCode.networkFailure:
3687      case SystemStatusCode.timeoutFailure:
3688      case SystemStatusCode.contentTypeMismatch:
3689        return this.reload({
3690          reason: "request_failed",
3691          context: {
3692            statusCode
3693          }
3694        });
3695      default:
3696        return visit2.loadResponse();
3697    }
3698  }
3699  visitRequestFinished(_visit) {
3700  }
3701  visitCompleted(_visit) {
3702    this.progressBar.setValue(1);
3703    this.hideVisitProgressBar();
3704  }
3705  pageInvalidated(reason) {
3706    this.reload(reason);
3707  }
3708  visitFailed(_visit) {
3709    this.progressBar.setValue(1);
3710    this.hideVisitProgressBar();
3711  }
3712  visitRendered(_visit) {
3713  }
3714  // Link prefetching
3715  linkPrefetchingIsEnabledForLocation(location2) {
3716    return true;
3717  }
3718  // Form Submission Delegate
3719  formSubmissionStarted(_formSubmission) {
3720    this.progressBar.setValue(0);
3721    this.showFormProgressBarAfterDelay();
3722  }
3723  formSubmissionFinished(_formSubmission) {
3724    this.progressBar.setValue(1);
3725    this.hideFormProgressBar();
3726  }
3727  // Private
3728  showVisitProgressBarAfterDelay() {
3729    this.visitProgressBarTimeout = window.setTimeout(this.showProgressBar, this.session.progressBarDelay);
3730  }
3731  hideVisitProgressBar() {
3732    this.progressBar.hide();
3733    if (this.visitProgressBarTimeout != null) {
3734      window.clearTimeout(this.visitProgressBarTimeout);
3735      delete this.visitProgressBarTimeout;
3736    }
3737  }
3738  showFormProgressBarAfterDelay() {
3739    if (this.formProgressBarTimeout == null) {
3740      this.formProgressBarTimeout = window.setTimeout(this.showProgressBar, this.session.progressBarDelay);
3741    }
3742  }
3743  hideFormProgressBar() {
3744    this.progressBar.hide();
3745    if (this.formProgressBarTimeout != null) {
3746      window.clearTimeout(this.formProgressBarTimeout);
3747      delete this.formProgressBarTimeout;
3748    }
3749  }
3750  showProgressBar = () => {
3751    this.progressBar.show();
3752  };
3753  reload(reason) {
3754    dispatch("turbo:reload", { detail: reason });
3755    window.location.href = this.location?.toString() || window.location.href;
3756  }
3757  get navigator() {
3758    return this.session.navigator;
3759  }
3760};
3761var CacheObserver = class {
3762  selector = "[data-turbo-temporary]";
3763  deprecatedSelector = "[data-turbo-cache=false]";
3764  started = false;
3765  start() {
3766    if (!this.started) {
3767      this.started = true;
3768      addEventListener("turbo:before-cache", this.removeTemporaryElements, false);
3769    }
3770  }
3771  stop() {
3772    if (this.started) {
3773      this.started = false;
3774      removeEventListener("turbo:before-cache", this.removeTemporaryElements, false);
3775    }
3776  }
3777  removeTemporaryElements = (_event) => {
3778    for (const element of this.temporaryElements) {
3779      element.remove();
3780    }
3781  };
3782  get temporaryElements() {
3783    return [...document.querySelectorAll(this.selector), ...this.temporaryElementsWithDeprecation];
3784  }
3785  get temporaryElementsWithDeprecation() {
3786    const elements = document.querySelectorAll(this.deprecatedSelector);
3787    if (elements.length) {
3788      console.warn(
3789        `The ${this.deprecatedSelector} selector is deprecated and will be removed in a future version. Use ${this.selector} instead.`
3790      );
3791    }
3792    return [...elements];
3793  }
3794};
3795var FrameRedirector = class {
3796  constructor(session2, element) {
3797    this.session = session2;
3798    this.element = element;
3799    this.linkInterceptor = new LinkInterceptor(this, element);
3800    this.formSubmitObserver = new FormSubmitObserver(this, element);
3801  }
3802  start() {
3803    this.linkInterceptor.start();
3804    this.formSubmitObserver.start();
3805  }
3806  stop() {
3807    this.linkInterceptor.stop();
3808    this.formSubmitObserver.stop();
3809  }
3810  // Link interceptor delegate
3811  shouldInterceptLinkClick(element, _location, _event) {
3812    return this.#shouldRedirect(element);
3813  }
3814  linkClickIntercepted(element, url, event) {
3815    const frame = this.#findFrameElement(element);
3816    if (frame) {
3817      frame.delegate.linkClickIntercepted(element, url, event);
3818    }
3819  }
3820  // Form submit observer delegate
3821  willSubmitForm(element, submitter2) {
3822    return element.closest("turbo-frame") == null && this.#shouldSubmit(element, submitter2) && this.#shouldRedirect(element, submitter2);
3823  }
3824  formSubmitted(element, submitter2) {
3825    const frame = this.#findFrameElement(element, submitter2);
3826    if (frame) {
3827      frame.delegate.formSubmitted(element, submitter2);
3828    }
3829  }
3830  #shouldSubmit(form, submitter2) {
3831    const action = getAction$1(form, submitter2);
3832    const meta = this.element.ownerDocument.querySelector(`meta[name="turbo-root"]`);
3833    const rootLocation = expandURL(meta?.content ?? "/");
3834    return this.#shouldRedirect(form, submitter2) && locationIsVisitable(action, rootLocation);
3835  }
3836  #shouldRedirect(element, submitter2) {
3837    const isNavigatable = element instanceof HTMLFormElement ? this.session.submissionIsNavigatable(element, submitter2) : this.session.elementIsNavigatable(element);
3838    if (isNavigatable) {
3839      const frame = this.#findFrameElement(element, submitter2);
3840      return frame ? frame != element.closest("turbo-frame") : false;
3841    } else {
3842      return false;
3843    }
3844  }
3845  #findFrameElement(element, submitter2) {
3846    const id = submitter2?.getAttribute("data-turbo-frame") || element.getAttribute("data-turbo-frame");
3847    if (id && id != "_top") {
3848      const frame = this.element.querySelector(`#${id}:not([disabled])`);
3849      if (frame instanceof FrameElement) {
3850        return frame;
3851      }
3852    }
3853  }
3854};
3855var History = class {
3856  location;
3857  restorationIdentifier = uuid();
3858  restorationData = {};
3859  started = false;
3860  pageLoaded = false;
3861  currentIndex = 0;
3862  constructor(delegate) {
3863    this.delegate = delegate;
3864  }
3865  start() {
3866    if (!this.started) {
3867      addEventListener("popstate", this.onPopState, false);
3868      addEventListener("load", this.onPageLoad, false);
3869      this.currentIndex = history.state?.turbo?.restorationIndex || 0;
3870      this.started = true;
3871      this.replace(new URL(window.location.href));
3872    }
3873  }
3874  stop() {
3875    if (this.started) {
3876      removeEventListener("popstate", this.onPopState, false);
3877      removeEventListener("load", this.onPageLoad, false);
3878      this.started = false;
3879    }
3880  }
3881  push(location2, restorationIdentifier) {
3882    this.update(history.pushState, location2, restorationIdentifier);
3883  }
3884  replace(location2, restorationIdentifier) {
3885    this.update(history.replaceState, location2, restorationIdentifier);
3886  }
3887  update(method, location2, restorationIdentifier = uuid()) {
3888    if (method === history.pushState) ++this.currentIndex;
3889    const state = { turbo: { restorationIdentifier, restorationIndex: this.currentIndex } };
3890    method.call(history, state, "", location2.href);
3891    this.location = location2;
3892    this.restorationIdentifier = restorationIdentifier;
3893  }
3894  // Restoration data
3895  getRestorationDataForIdentifier(restorationIdentifier) {
3896    return this.restorationData[restorationIdentifier] || {};
3897  }
3898  updateRestorationData(additionalData) {
3899    const { restorationIdentifier } = this;
3900    const restorationData = this.restorationData[restorationIdentifier];
3901    this.restorationData[restorationIdentifier] = {
3902      ...restorationData,
3903      ...additionalData
3904    };
3905  }
3906  // Scroll restoration
3907  assumeControlOfScrollRestoration() {
3908    if (!this.previousScrollRestoration) {
3909      this.previousScrollRestoration = history.scrollRestoration ?? "auto";
3910      history.scrollRestoration = "manual";
3911    }
3912  }
3913  relinquishControlOfScrollRestoration() {
3914    if (this.previousScrollRestoration) {
3915      history.scrollRestoration = this.previousScrollRestoration;
3916      delete this.previousScrollRestoration;
3917    }
3918  }
3919  // Event handlers
3920  onPopState = (event) => {
3921    if (this.shouldHandlePopState()) {
3922      const { turbo } = event.state || {};
3923      if (turbo) {
3924        this.location = new URL(window.location.href);
3925        const { restorationIdentifier, restorationIndex } = turbo;
3926        this.restorationIdentifier = restorationIdentifier;
3927        const direction = restorationIndex > this.currentIndex ? "forward" : "back";
3928        this.delegate.historyPoppedToLocationWithRestorationIdentifierAndDirection(this.location, restorationIdentifier, direction);
3929        this.currentIndex = restorationIndex;
3930      }
3931    }
3932  };
3933  onPageLoad = async (_event) => {
3934    await nextMicrotask();
3935    this.pageLoaded = true;
3936  };
3937  // Private
3938  shouldHandlePopState() {
3939    return this.pageIsLoaded();
3940  }
3941  pageIsLoaded() {
3942    return this.pageLoaded || document.readyState == "complete";
3943  }
3944};
3945var LinkPrefetchObserver = class {
3946  started = false;
3947  #prefetchedLink = null;
3948  constructor(delegate, eventTarget) {
3949    this.delegate = delegate;
3950    this.eventTarget = eventTarget;
3951  }
3952  start() {
3953    if (this.started) return;
3954    if (this.eventTarget.readyState === "loading") {
3955      this.eventTarget.addEventListener("DOMContentLoaded", this.#enable, { once: true });
3956    } else {
3957      this.#enable();
3958    }
3959  }
3960  stop() {
3961    if (!this.started) return;
3962    this.eventTarget.removeEventListener("mouseenter", this.#tryToPrefetchRequest, {
3963      capture: true,
3964      passive: true
3965    });
3966    this.eventTarget.removeEventListener("mouseleave", this.#cancelRequestIfObsolete, {
3967      capture: true,
3968      passive: true
3969    });
3970    this.eventTarget.removeEventListener("turbo:before-fetch-request", this.#tryToUsePrefetchedRequest, true);
3971    this.started = false;
3972  }
3973  #enable = () => {
3974    this.eventTarget.addEventListener("mouseenter", this.#tryToPrefetchRequest, {
3975      capture: true,
3976      passive: true
3977    });
3978    this.eventTarget.addEventListener("mouseleave", this.#cancelRequestIfObsolete, {
3979      capture: true,
3980      passive: true
3981    });
3982    this.eventTarget.addEventListener("turbo:before-fetch-request", this.#tryToUsePrefetchedRequest, true);
3983    this.started = true;
3984  };
3985  #tryToPrefetchRequest = (event) => {
3986    if (getMetaContent("turbo-prefetch") === "false") return;
3987    const target = event.target;
3988    const isLink = target.matches && target.matches("a[href]:not([target^=_]):not([download])");
3989    if (isLink && this.#isPrefetchable(target)) {
3990      const link = target;
3991      const location2 = getLocationForLink(link);
3992      if (this.delegate.canPrefetchRequestToLocation(link, location2)) {
3993        this.#prefetchedLink = link;
3994        const fetchRequest = new FetchRequest(
3995          this,
3996          FetchMethod.get,
3997          location2,
3998          new URLSearchParams(),
3999          target
4000        );
4001        prefetchCache.setLater(location2.toString(), fetchRequest, this.#cacheTtl);
4002      }
4003    }
4004  };
4005  #cancelRequestIfObsolete = (event) => {
4006    if (event.target === this.#prefetchedLink) this.#cancelPrefetchRequest();
4007  };
4008  #cancelPrefetchRequest = () => {
4009    prefetchCache.clear();
4010    this.#prefetchedLink = null;
4011  };
4012  #tryToUsePrefetchedRequest = (event) => {
4013    if (event.target.tagName !== "FORM" && event.detail.fetchOptions.method === "GET") {
4014      const cached = prefetchCache.get(event.detail.url.toString());
4015      if (cached) {
4016        event.detail.fetchRequest = cached;
4017      }
4018      prefetchCache.clear();
4019    }
4020  };
4021  prepareRequest(request) {
4022    const link = request.target;
4023    request.headers["X-Sec-Purpose"] = "prefetch";
4024    const turboFrame = link.closest("turbo-frame");
4025    const turboFrameTarget = link.getAttribute("data-turbo-frame") || turboFrame?.getAttribute("target") || turboFrame?.id;
4026    if (turboFrameTarget && turboFrameTarget !== "_top") {
4027      request.headers["Turbo-Frame"] = turboFrameTarget;
4028    }
4029  }
4030  // Fetch request interface
4031  requestSucceededWithResponse() {
4032  }
4033  requestStarted(fetchRequest) {
4034  }
4035  requestErrored(fetchRequest) {
4036  }
4037  requestFinished(fetchRequest) {
4038  }
4039  requestPreventedHandlingResponse(fetchRequest, fetchResponse) {
4040  }
4041  requestFailedWithResponse(fetchRequest, fetchResponse) {
4042  }
4043  get #cacheTtl() {
4044    return Number(getMetaContent("turbo-prefetch-cache-time")) || cacheTtl;
4045  }
4046  #isPrefetchable(link) {
4047    const href = link.getAttribute("href");
4048    if (!href) return false;
4049    if (unfetchableLink(link)) return false;
4050    if (linkToTheSamePage(link)) return false;
4051    if (linkOptsOut(link)) return false;
4052    if (nonSafeLink(link)) return false;
4053    if (eventPrevented(link)) return false;
4054    return true;
4055  }
4056};
4057var unfetchableLink = (link) => {
4058  return link.origin !== document.location.origin || !["http:", "https:"].includes(link.protocol) || link.hasAttribute("target");
4059};
4060var linkToTheSamePage = (link) => {
4061  return link.pathname + link.search === document.location.pathname + document.location.search || link.href.startsWith("#");
4062};
4063var linkOptsOut = (link) => {
4064  if (link.getAttribute("data-turbo-prefetch") === "false") return true;
4065  if (link.getAttribute("data-turbo") === "false") return true;
4066  const turboPrefetchParent = findClosestRecursively(link, "[data-turbo-prefetch]");
4067  if (turboPrefetchParent && turboPrefetchParent.getAttribute("data-turbo-prefetch") === "false") return true;
4068  return false;
4069};
4070var nonSafeLink = (link) => {
4071  const turboMethod = link.getAttribute("data-turbo-method");
4072  if (turboMethod && turboMethod.toLowerCase() !== "get") return true;
4073  if (isUJS(link)) return true;
4074  if (link.hasAttribute("data-turbo-confirm")) return true;
4075  if (link.hasAttribute("data-turbo-stream")) return true;
4076  return false;
4077};
4078var isUJS = (link) => {
4079  return link.hasAttribute("data-remote") || link.hasAttribute("data-behavior") || link.hasAttribute("data-confirm") || link.hasAttribute("data-method");
4080};
4081var eventPrevented = (link) => {
4082  const event = dispatch("turbo:before-prefetch", { target: link, cancelable: true });
4083  return event.defaultPrevented;
4084};
4085var Navigator = class {
4086  constructor(delegate) {
4087    this.delegate = delegate;
4088  }
4089  proposeVisit(location2, options = {}) {
4090    if (this.delegate.allowsVisitingLocationWithAction(location2, options.action)) {
4091      this.delegate.visitProposedToLocation(location2, options);
4092    }
4093  }
4094  startVisit(locatable, restorationIdentifier, options = {}) {
4095    this.stop();
4096    this.currentVisit = new Visit(this, expandURL(locatable), restorationIdentifier, {
4097      referrer: this.location,
4098      ...options
4099    });
4100    this.currentVisit.start();
4101  }
4102  submitForm(form, submitter2) {
4103    this.stop();
4104    this.formSubmission = new FormSubmission(this, form, submitter2, true);
4105    this.formSubmission.start();
4106  }
4107  stop() {
4108    if (this.formSubmission) {
4109      this.formSubmission.stop();
4110      delete this.formSubmission;
4111    }
4112    if (this.currentVisit) {
4113      this.currentVisit.cancel();
4114      delete this.currentVisit;
4115    }
4116  }
4117  get adapter() {
4118    return this.delegate.adapter;
4119  }
4120  get view() {
4121    return this.delegate.view;
4122  }
4123  get rootLocation() {
4124    return this.view.snapshot.rootLocation;
4125  }
4126  get history() {
4127    return this.delegate.history;
4128  }
4129  // Form submission delegate
4130  formSubmissionStarted(formSubmission) {
4131    if (typeof this.adapter.formSubmissionStarted === "function") {
4132      this.adapter.formSubmissionStarted(formSubmission);
4133    }
4134  }
4135  async formSubmissionSucceededWithResponse(formSubmission, fetchResponse) {
4136    if (formSubmission == this.formSubmission) {
4137      const responseHTML = await fetchResponse.responseHTML;
4138      if (responseHTML) {
4139        const shouldCacheSnapshot = formSubmission.isSafe;
4140        if (!shouldCacheSnapshot) {
4141          this.view.clearSnapshotCache();
4142        }
4143        const { statusCode, redirected } = fetchResponse;
4144        const action = this.#getActionForFormSubmission(formSubmission, fetchResponse);
4145        const visitOptions = {
4146          action,
4147          shouldCacheSnapshot,
4148          response: { statusCode, responseHTML, redirected }
4149        };
4150        this.proposeVisit(fetchResponse.location, visitOptions);
4151      }
4152    }
4153  }
4154  async formSubmissionFailedWithResponse(formSubmission, fetchResponse) {
4155    const responseHTML = await fetchResponse.responseHTML;
4156    if (responseHTML) {
4157      const snapshot = PageSnapshot.fromHTMLString(responseHTML);
4158      if (fetchResponse.serverError) {
4159        await this.view.renderError(snapshot, this.currentVisit);
4160      } else {
4161        await this.view.renderPage(snapshot, false, true, this.currentVisit);
4162      }
4163      if (!snapshot.shouldPreserveScrollPosition) {
4164        this.view.scrollToTop();
4165      }
4166      this.view.clearSnapshotCache();
4167    }
4168  }
4169  formSubmissionErrored(formSubmission, error) {
4170    console.error(error);
4171  }
4172  formSubmissionFinished(formSubmission) {
4173    if (typeof this.adapter.formSubmissionFinished === "function") {
4174      this.adapter.formSubmissionFinished(formSubmission);
4175    }
4176  }
4177  // Link prefetching
4178  linkPrefetchingIsEnabledForLocation(location2) {
4179    if (typeof this.adapter.linkPrefetchingIsEnabledForLocation === "function") {
4180      return this.adapter.linkPrefetchingIsEnabledForLocation(location2);
4181    }
4182    return true;
4183  }
4184  // Visit delegate
4185  visitStarted(visit2) {
4186    this.delegate.visitStarted(visit2);
4187  }
4188  visitCompleted(visit2) {
4189    this.delegate.visitCompleted(visit2);
4190    delete this.currentVisit;
4191  }
4192  locationWithActionIsSamePage(location2, action) {
4193    const anchor = getAnchor(location2);
4194    const currentAnchor = getAnchor(this.view.lastRenderedLocation);
4195    const isRestorationToTop = action === "restore" && typeof anchor === "undefined";
4196    return action !== "replace" && getRequestURL(location2) === getRequestURL(this.view.lastRenderedLocation) && (isRestorationToTop || anchor != null && anchor !== currentAnchor);
4197  }
4198  visitScrolledToSamePageLocation(oldURL, newURL) {
4199    this.delegate.visitScrolledToSamePageLocation(oldURL, newURL);
4200  }
4201  // Visits
4202  get location() {
4203    return this.history.location;
4204  }
4205  get restorationIdentifier() {
4206    return this.history.restorationIdentifier;
4207  }
4208  #getActionForFormSubmission(formSubmission, fetchResponse) {
4209    const { submitter: submitter2, formElement } = formSubmission;
4210    return getVisitAction(submitter2, formElement) || this.#getDefaultAction(fetchResponse);
4211  }
4212  #getDefaultAction(fetchResponse) {
4213    const sameLocationRedirect = fetchResponse.redirected && fetchResponse.location.href === this.location?.href;
4214    return sameLocationRedirect ? "replace" : "advance";
4215  }
4216};
4217var PageStage = {
4218  initial: 0,
4219  loading: 1,
4220  interactive: 2,
4221  complete: 3
4222};
4223var PageObserver = class {
4224  stage = PageStage.initial;
4225  started = false;
4226  constructor(delegate) {
4227    this.delegate = delegate;
4228  }
4229  start() {
4230    if (!this.started) {
4231      if (this.stage == PageStage.initial) {
4232        this.stage = PageStage.loading;
4233      }
4234      document.addEventListener("readystatechange", this.interpretReadyState, false);
4235      addEventListener("pagehide", this.pageWillUnload, false);
4236      this.started = true;
4237    }
4238  }
4239  stop() {
4240    if (this.started) {
4241      document.removeEventListener("readystatechange", this.interpretReadyState, false);
4242      removeEventListener("pagehide", this.pageWillUnload, false);
4243      this.started = false;
4244    }
4245  }
4246  interpretReadyState = () => {
4247    const { readyState } = this;
4248    if (readyState == "interactive") {
4249      this.pageIsInteractive();
4250    } else if (readyState == "complete") {
4251      this.pageIsComplete();
4252    }
4253  };
4254  pageIsInteractive() {
4255    if (this.stage == PageStage.loading) {
4256      this.stage = PageStage.interactive;
4257      this.delegate.pageBecameInteractive();
4258    }
4259  }
4260  pageIsComplete() {
4261    this.pageIsInteractive();
4262    if (this.stage == PageStage.interactive) {
4263      this.stage = PageStage.complete;
4264      this.delegate.pageLoaded();
4265    }
4266  }
4267  pageWillUnload = () => {
4268    this.delegate.pageWillUnload();
4269  };
4270  get readyState() {
4271    return document.readyState;
4272  }
4273};
4274var ScrollObserver = class {
4275  started = false;
4276  constructor(delegate) {
4277    this.delegate = delegate;
4278  }
4279  start() {
4280    if (!this.started) {
4281      addEventListener("scroll", this.onScroll, false);
4282      this.onScroll();
4283      this.started = true;
4284    }
4285  }
4286  stop() {
4287    if (this.started) {
4288      removeEventListener("scroll", this.onScroll, false);
4289      this.started = false;
4290    }
4291  }
4292  onScroll = () => {
4293    this.updatePosition({ x: window.pageXOffset, y: window.pageYOffset });
4294  };
4295  // Private
4296  updatePosition(position) {
4297    this.delegate.scrollPositionChanged(position);
4298  }
4299};
4300var StreamMessageRenderer = class {
4301  render({ fragment }) {
4302    Bardo.preservingPermanentElements(this, getPermanentElementMapForFragment(fragment), () => {
4303      withAutofocusFromFragment(fragment, () => {
4304        withPreservedFocus(() => {
4305          document.documentElement.appendChild(fragment);
4306        });
4307      });
4308    });
4309  }
4310  // Bardo delegate
4311  enteringBardo(currentPermanentElement, newPermanentElement) {
4312    newPermanentElement.replaceWith(currentPermanentElement.cloneNode(true));
4313  }
4314  leavingBardo() {
4315  }
4316};
4317function getPermanentElementMapForFragment(fragment) {
4318  const permanentElementsInDocument = queryPermanentElementsAll(document.documentElement);
4319  const permanentElementMap = {};
4320  for (const permanentElementInDocument of permanentElementsInDocument) {
4321    const { id } = permanentElementInDocument;
4322    for (const streamElement of fragment.querySelectorAll("turbo-stream")) {
4323      const elementInStream = getPermanentElementById(streamElement.templateElement.content, id);
4324      if (elementInStream) {
4325        permanentElementMap[id] = [permanentElementInDocument, elementInStream];
4326      }
4327    }
4328  }
4329  return permanentElementMap;
4330}
4331async function withAutofocusFromFragment(fragment, callback) {
4332  const generatedID = `turbo-stream-autofocus-${uuid()}`;
4333  const turboStreams = fragment.querySelectorAll("turbo-stream");
4334  const elementWithAutofocus = firstAutofocusableElementInStreams(turboStreams);
4335  let willAutofocusId = null;
4336  if (elementWithAutofocus) {
4337    if (elementWithAutofocus.id) {
4338      willAutofocusId = elementWithAutofocus.id;
4339    } else {
4340      willAutofocusId = generatedID;
4341    }
4342    elementWithAutofocus.id = willAutofocusId;
4343  }
4344  callback();
4345  await nextRepaint();
4346  const hasNoActiveElement = document.activeElement == null || document.activeElement == document.body;
4347  if (hasNoActiveElement && willAutofocusId) {
4348    const elementToAutofocus = document.getElementById(willAutofocusId);
4349    if (elementIsFocusable(elementToAutofocus)) {
4350      elementToAutofocus.focus();
4351    }
4352    if (elementToAutofocus && elementToAutofocus.id == generatedID) {
4353      elementToAutofocus.removeAttribute("id");
4354    }
4355  }
4356}
4357async function withPreservedFocus(callback) {
4358  const [activeElementBeforeRender, activeElementAfterRender] = await around(callback, () => document.activeElement);
4359  const restoreFocusTo = activeElementBeforeRender && activeElementBeforeRender.id;
4360  if (restoreFocusTo) {
4361    const elementToFocus = document.getElementById(restoreFocusTo);
4362    if (elementIsFocusable(elementToFocus) && elementToFocus != activeElementAfterRender) {
4363      elementToFocus.focus();
4364    }
4365  }
4366}
4367function firstAutofocusableElementInStreams(nodeListOfStreamElements) {
4368  for (const streamElement of nodeListOfStreamElements) {
4369    const elementWithAutofocus = queryAutofocusableElement(streamElement.templateElement.content);
4370    if (elementWithAutofocus) return elementWithAutofocus;
4371  }
4372  return null;
4373}
4374var StreamObserver = class {
4375  sources = /* @__PURE__ */ new Set();
4376  #started = false;
4377  constructor(delegate) {
4378    this.delegate = delegate;
4379  }
4380  start() {
4381    if (!this.#started) {
4382      this.#started = true;
4383      addEventListener("turbo:before-fetch-response", this.inspectFetchResponse, false);
4384    }
4385  }
4386  stop() {
4387    if (this.#started) {
4388      this.#started = false;
4389      removeEventListener("turbo:before-fetch-response", this.inspectFetchResponse, false);
4390    }
4391  }
4392  connectStreamSource(source) {
4393    if (!this.streamSourceIsConnected(source)) {
4394      this.sources.add(source);
4395      source.addEventListener("message", this.receiveMessageEvent, false);
4396    }
4397  }
4398  disconnectStreamSource(source) {
4399    if (this.streamSourceIsConnected(source)) {
4400      this.sources.delete(source);
4401      source.removeEventListener("message", this.receiveMessageEvent, false);
4402    }
4403  }
4404  streamSourceIsConnected(source) {
4405    return this.sources.has(source);
4406  }
4407  inspectFetchResponse = (event) => {
4408    const response = fetchResponseFromEvent(event);
4409    if (response && fetchResponseIsStream(response)) {
4410      event.preventDefault();
4411      this.receiveMessageResponse(response);
4412    }
4413  };
4414  receiveMessageEvent = (event) => {
4415    if (this.#started && typeof event.data == "string") {
4416      this.receiveMessageHTML(event.data);
4417    }
4418  };
4419  async receiveMessageResponse(response) {
4420    const html = await response.responseHTML;
4421    if (html) {
4422      this.receiveMessageHTML(html);
4423    }
4424  }
4425  receiveMessageHTML(html) {
4426    this.delegate.receivedMessageFromStream(StreamMessage.wrap(html));
4427  }
4428};
4429function fetchResponseFromEvent(event) {
4430  const fetchResponse = event.detail?.fetchResponse;
4431  if (fetchResponse instanceof FetchResponse) {
4432    return fetchResponse;
4433  }
4434}
4435function fetchResponseIsStream(response) {
4436  const contentType = response.contentType ?? "";
4437  return contentType.startsWith(StreamMessage.contentType);
4438}
4439var ErrorRenderer = class extends Renderer {
4440  static renderElement(currentElement, newElement) {
4441    const { documentElement, body } = document;
4442    documentElement.replaceChild(newElement, body);
4443  }
4444  async render() {
4445    this.replaceHeadAndBody();
4446    this.activateScriptElements();
4447  }
4448  replaceHeadAndBody() {
4449    const { documentElement, head } = document;
4450    documentElement.replaceChild(this.newHead, head);
4451    this.renderElement(this.currentElement, this.newElement);
4452  }
4453  activateScriptElements() {
4454    for (const replaceableElement of this.scriptElements) {
4455      const parentNode = replaceableElement.parentNode;
4456      if (parentNode) {
4457        const element = activateScriptElement(replaceableElement);
4458        parentNode.replaceChild(element, replaceableElement);
4459      }
4460    }
4461  }
4462  get newHead() {
4463    return this.newSnapshot.headSnapshot.element;
4464  }
4465  get scriptElements() {
4466    return document.documentElement.querySelectorAll("script");
4467  }
4468};
4469var PageRenderer = class extends Renderer {
4470  static renderElement(currentElement, newElement) {
4471    if (document.body && newElement instanceof HTMLBodyElement) {
4472      document.body.replaceWith(newElement);
4473    } else {
4474      document.documentElement.appendChild(newElement);
4475    }
4476  }
4477  get shouldRender() {
4478    return this.newSnapshot.isVisitable && this.trackedElementsAreIdentical;
4479  }
4480  get reloadReason() {
4481    if (!this.newSnapshot.isVisitable) {
4482      return {
4483        reason: "turbo_visit_control_is_reload"
4484      };
4485    }
4486    if (!this.trackedElementsAreIdentical) {
4487      return {
4488        reason: "tracked_element_mismatch"
4489      };
4490    }
4491  }
4492  async prepareToRender() {
4493    this.#setLanguage();
4494    await this.mergeHead();
4495  }
4496  async render() {
4497    if (this.willRender) {
4498      await this.replaceBody();
4499    }
4500  }
4501  finishRendering() {
4502    super.finishRendering();
4503    if (!this.isPreview) {
4504      this.focusFirstAutofocusableElement();
4505    }
4506  }
4507  get currentHeadSnapshot() {
4508    return this.currentSnapshot.headSnapshot;
4509  }
4510  get newHeadSnapshot() {
4511    return this.newSnapshot.headSnapshot;
4512  }
4513  get newElement() {
4514    return this.newSnapshot.element;
4515  }
4516  #setLanguage() {
4517    const { documentElement } = this.currentSnapshot;
4518    const { lang } = this.newSnapshot;
4519    if (lang) {
4520      documentElement.setAttribute("lang", lang);
4521    } else {
4522      documentElement.removeAttribute("lang");
4523    }
4524  }
4525  async mergeHead() {
4526    const mergedHeadElements = this.mergeProvisionalElements();
4527    const newStylesheetElements = this.copyNewHeadStylesheetElements();
4528    this.copyNewHeadScriptElements();
4529    await mergedHeadElements;
4530    await newStylesheetElements;
4531    if (this.willRender) {
4532      this.removeUnusedDynamicStylesheetElements();
4533    }
4534  }
4535  async replaceBody() {
4536    await this.preservingPermanentElements(async () => {
4537      this.activateNewBody();
4538      await this.assignNewBody();
4539    });
4540  }
4541  get trackedElementsAreIdentical() {
4542    return this.currentHeadSnapshot.trackedElementSignature == this.newHeadSnapshot.trackedElementSignature;
4543  }
4544  async copyNewHeadStylesheetElements() {
4545    const loadingElements = [];
4546    for (const element of this.newHeadStylesheetElements) {
4547      loadingElements.push(waitForLoad(element));
4548      document.head.appendChild(element);
4549    }
4550    await Promise.all(loadingElements);
4551  }
4552  copyNewHeadScriptElements() {
4553    for (const element of this.newHeadScriptElements) {
4554      document.head.appendChild(activateScriptElement(element));
4555    }
4556  }
4557  removeUnusedDynamicStylesheetElements() {
4558    for (const element of this.unusedDynamicStylesheetElements) {
4559      document.head.removeChild(element);
4560    }
4561  }
4562  async mergeProvisionalElements() {
4563    const newHeadElements = [...this.newHeadProvisionalElements];
4564    for (const element of this.currentHeadProvisionalElements) {
4565      if (!this.isCurrentElementInElementList(element, newHeadElements)) {
4566        document.head.removeChild(element);
4567      }
4568    }
4569    for (const element of newHeadElements) {
4570      document.head.appendChild(element);
4571    }
4572  }
4573  isCurrentElementInElementList(element, elementList) {
4574    for (const [index, newElement] of elementList.entries()) {
4575      if (element.tagName == "TITLE") {
4576        if (newElement.tagName != "TITLE") {
4577          continue;
4578        }
4579        if (element.innerHTML == newElement.innerHTML) {
4580          elementList.splice(index, 1);
4581          return true;
4582        }
4583      }
4584      if (newElement.isEqualNode(element)) {
4585        elementList.splice(index, 1);
4586        return true;
4587      }
4588    }
4589    return false;
4590  }
4591  removeCurrentHeadProvisionalElements() {
4592    for (const element of this.currentHeadProvisionalElements) {
4593      document.head.removeChild(element);
4594    }
4595  }
4596  copyNewHeadProvisionalElements() {
4597    for (const element of this.newHeadProvisionalElements) {
4598      document.head.appendChild(element);
4599    }
4600  }
4601  activateNewBody() {
4602    document.adoptNode(this.newElement);
4603    this.activateNewBodyScriptElements();
4604  }
4605  activateNewBodyScriptElements() {
4606    for (const inertScriptElement of this.newBodyScriptElements) {
4607      const activatedScriptElement = activateScriptElement(inertScriptElement);
4608      inertScriptElement.replaceWith(activatedScriptElement);
4609    }
4610  }
4611  async assignNewBody() {
4612    await this.renderElement(this.currentElement, this.newElement);
4613  }
4614  get unusedDynamicStylesheetElements() {
4615    return this.oldHeadStylesheetElements.filter((element) => {
4616      return element.getAttribute("data-turbo-track") === "dynamic";
4617    });
4618  }
4619  get oldHeadStylesheetElements() {
4620    return this.currentHeadSnapshot.getStylesheetElementsNotInSnapshot(this.newHeadSnapshot);
4621  }
4622  get newHeadStylesheetElements() {
4623    return this.newHeadSnapshot.getStylesheetElementsNotInSnapshot(this.currentHeadSnapshot);
4624  }
4625  get newHeadScriptElements() {
4626    return this.newHeadSnapshot.getScriptElementsNotInSnapshot(this.currentHeadSnapshot);
4627  }
4628  get currentHeadProvisionalElements() {
4629    return this.currentHeadSnapshot.provisionalElements;
4630  }
4631  get newHeadProvisionalElements() {
4632    return this.newHeadSnapshot.provisionalElements;
4633  }
4634  get newBodyScriptElements() {
4635    return this.newElement.querySelectorAll("script");
4636  }
4637};
4638var MorphingPageRenderer = class extends PageRenderer {
4639  static renderElement(currentElement, newElement) {
4640    morphElements(currentElement, newElement, {
4641      callbacks: {
4642        beforeNodeMorphed: (element) => !canRefreshFrame(element)
4643      }
4644    });
4645    for (const frame of currentElement.querySelectorAll("turbo-frame")) {
4646      if (canRefreshFrame(frame)) frame.reload();
4647    }
4648    dispatch("turbo:morph", { detail: { currentElement, newElement } });
4649  }
4650  async preservingPermanentElements(callback) {
4651    return await callback();
4652  }
4653  get renderMethod() {
4654    return "morph";
4655  }
4656  get shouldAutofocus() {
4657    return false;
4658  }
4659};
4660function canRefreshFrame(frame) {
4661  return frame instanceof FrameElement && frame.src && frame.refresh === "morph" && !frame.closest("[data-turbo-permanent]");
4662}
4663var SnapshotCache = class {
4664  keys = [];
4665  snapshots = {};
4666  constructor(size) {
4667    this.size = size;
4668  }
4669  has(location2) {
4670    return toCacheKey(location2) in this.snapshots;
4671  }
4672  get(location2) {
4673    if (this.has(location2)) {
4674      const snapshot = this.read(location2);
4675      this.touch(location2);
4676      return snapshot;
4677    }
4678  }
4679  put(location2, snapshot) {
4680    this.write(location2, snapshot);
4681    this.touch(location2);
4682    return snapshot;
4683  }
4684  clear() {
4685    this.snapshots = {};
4686  }
4687  // Private
4688  read(location2) {
4689    return this.snapshots[toCacheKey(location2)];
4690  }
4691  write(location2, snapshot) {
4692    this.snapshots[toCacheKey(location2)] = snapshot;
4693  }
4694  touch(location2) {
4695    const key = toCacheKey(location2);
4696    const index = this.keys.indexOf(key);
4697    if (index > -1) this.keys.splice(index, 1);
4698    this.keys.unshift(key);
4699    this.trim();
4700  }
4701  trim() {
4702    for (const key of this.keys.splice(this.size)) {
4703      delete this.snapshots[key];
4704    }
4705  }
4706};
4707var PageView = class extends View {
4708  snapshotCache = new SnapshotCache(10);
4709  lastRenderedLocation = new URL(location.href);
4710  forceReloaded = false;
4711  shouldTransitionTo(newSnapshot) {
4712    return this.snapshot.prefersViewTransitions && newSnapshot.prefersViewTransitions;
4713  }
4714  renderPage(snapshot, isPreview = false, willRender = true, visit2) {
4715    const shouldMorphPage = this.isPageRefresh(visit2) && this.snapshot.shouldMorphPage;
4716    const rendererClass = shouldMorphPage ? MorphingPageRenderer : PageRenderer;
4717    const renderer = new rendererClass(this.snapshot, snapshot, isPreview, willRender);
4718    if (!renderer.shouldRender) {
4719      this.forceReloaded = true;
4720    } else {
4721      visit2?.changeHistory();
4722    }
4723    return this.render(renderer);
4724  }
4725  renderError(snapshot, visit2) {
4726    visit2?.changeHistory();
4727    const renderer = new ErrorRenderer(this.snapshot, snapshot, false);
4728    return this.render(renderer);
4729  }
4730  clearSnapshotCache() {
4731    this.snapshotCache.clear();
4732  }
4733  async cacheSnapshot(snapshot = this.snapshot) {
4734    if (snapshot.isCacheable) {
4735      this.delegate.viewWillCacheSnapshot();
4736      const { lastRenderedLocation: location2 } = this;
4737      await nextEventLoopTick();
4738      const cachedSnapshot = snapshot.clone();
4739      this.snapshotCache.put(location2, cachedSnapshot);
4740      return cachedSnapshot;
4741    }
4742  }
4743  getCachedSnapshotForLocation(location2) {
4744    return this.snapshotCache.get(location2);
4745  }
4746  isPageRefresh(visit2) {
4747    return !visit2 || this.lastRenderedLocation.pathname === visit2.location.pathname && visit2.action === "replace";
4748  }
4749  shouldPreserveScrollPosition(visit2) {
4750    return this.isPageRefresh(visit2) && this.snapshot.shouldPreserveScrollPosition;
4751  }
4752  get snapshot() {
4753    return PageSnapshot.fromElement(this.element);
4754  }
4755};
4756var Preloader = class {
4757  selector = "a[data-turbo-preload]";
4758  constructor(delegate, snapshotCache) {
4759    this.delegate = delegate;
4760    this.snapshotCache = snapshotCache;
4761  }
4762  start() {
4763    if (document.readyState === "loading") {
4764      document.addEventListener("DOMContentLoaded", this.#preloadAll);
4765    } else {
4766      this.preloadOnLoadLinksForView(document.body);
4767    }
4768  }
4769  stop() {
4770    document.removeEventListener("DOMContentLoaded", this.#preloadAll);
4771  }
4772  preloadOnLoadLinksForView(element) {
4773    for (const link of element.querySelectorAll(this.selector)) {
4774      if (this.delegate.shouldPreloadLink(link)) {
4775        this.preloadURL(link);
4776      }
4777    }
4778  }
4779  async preloadURL(link) {
4780    const location2 = new URL(link.href);
4781    if (this.snapshotCache.has(location2)) {
4782      return;
4783    }
4784    const fetchRequest = new FetchRequest(this, FetchMethod.get, location2, new URLSearchParams(), link);
4785    await fetchRequest.perform();
4786  }
4787  // Fetch request delegate
4788  prepareRequest(fetchRequest) {
4789    fetchRequest.headers["X-Sec-Purpose"] = "prefetch";
4790  }
4791  async requestSucceededWithResponse(fetchRequest, fetchResponse) {
4792    try {
4793      const responseHTML = await fetchResponse.responseHTML;
4794      const snapshot = PageSnapshot.fromHTMLString(responseHTML);
4795      this.snapshotCache.put(fetchRequest.url, snapshot);
4796    } catch (_) {
4797    }
4798  }
4799  requestStarted(fetchRequest) {
4800  }
4801  requestErrored(fetchRequest) {
4802  }
4803  requestFinished(fetchRequest) {
4804  }
4805  requestPreventedHandlingResponse(fetchRequest, fetchResponse) {
4806  }
4807  requestFailedWithResponse(fetchRequest, fetchResponse) {
4808  }
4809  #preloadAll = () => {
4810    this.preloadOnLoadLinksForView(document.body);
4811  };
4812};
4813var Cache = class {
4814  constructor(session2) {
4815    this.session = session2;
4816  }
4817  clear() {
4818    this.session.clearCache();
4819  }
4820  resetCacheControl() {
4821    this.#setCacheControl("");
4822  }
4823  exemptPageFromCache() {
4824    this.#setCacheControl("no-cache");
4825  }
4826  exemptPageFromPreview() {
4827    this.#setCacheControl("no-preview");
4828  }
4829  #setCacheControl(value) {
4830    setMetaContent("turbo-cache-control", value);
4831  }
4832};
4833var Session = class {
4834  navigator = new Navigator(this);
4835  history = new History(this);
4836  view = new PageView(this, document.documentElement);
4837  adapter = new BrowserAdapter(this);
4838  pageObserver = new PageObserver(this);
4839  cacheObserver = new CacheObserver();
4840  linkPrefetchObserver = new LinkPrefetchObserver(this, document);
4841  linkClickObserver = new LinkClickObserver(this, window);
4842  formSubmitObserver = new FormSubmitObserver(this, document);
4843  scrollObserver = new ScrollObserver(this);
4844  streamObserver = new StreamObserver(this);
4845  formLinkClickObserver = new FormLinkClickObserver(this, document.documentElement);
4846  frameRedirector = new FrameRedirector(this, document.documentElement);
4847  streamMessageRenderer = new StreamMessageRenderer();
4848  cache = new Cache(this);
4849  enabled = true;
4850  started = false;
4851  #pageRefreshDebouncePeriod = 150;
4852  constructor(recentRequests2) {
4853    this.recentRequests = recentRequests2;
4854    this.preloader = new Preloader(this, this.view.snapshotCache);
4855    this.debouncedRefresh = this.refresh;
4856    this.pageRefreshDebouncePeriod = this.pageRefreshDebouncePeriod;
4857  }
4858  start() {
4859    if (!this.started) {
4860      this.pageObserver.start();
4861      this.cacheObserver.start();
4862      this.linkPrefetchObserver.start();
4863      this.formLinkClickObserver.start();
4864      this.linkClickObserver.start();
4865      this.formSubmitObserver.start();
4866      this.scrollObserver.start();
4867      this.streamObserver.start();
4868      this.frameRedirector.start();
4869      this.history.start();
4870      this.preloader.start();
4871      this.started = true;
4872      this.enabled = true;
4873    }
4874  }
4875  disable() {
4876    this.enabled = false;
4877  }
4878  stop() {
4879    if (this.started) {
4880      this.pageObserver.stop();
4881      this.cacheObserver.stop();
4882      this.linkPrefetchObserver.stop();
4883      this.formLinkClickObserver.stop();
4884      this.linkClickObserver.stop();
4885      this.formSubmitObserver.stop();
4886      this.scrollObserver.stop();
4887      this.streamObserver.stop();
4888      this.frameRedirector.stop();
4889      this.history.stop();
4890      this.preloader.stop();
4891      this.started = false;
4892    }
4893  }
4894  registerAdapter(adapter) {
4895    this.adapter = adapter;
4896  }
4897  visit(location2, options = {}) {
4898    const frameElement = options.frame ? document.getElementById(options.frame) : null;
4899    if (frameElement instanceof FrameElement) {
4900      const action = options.action || getVisitAction(frameElement);
4901      frameElement.delegate.proposeVisitIfNavigatedWithAction(frameElement, action);
4902      frameElement.src = location2.toString();
4903    } else {
4904      this.navigator.proposeVisit(expandURL(location2), options);
4905    }
4906  }
4907  refresh(url, requestId) {
4908    const isRecentRequest = requestId && this.recentRequests.has(requestId);
4909    const isCurrentUrl = url === document.baseURI;
4910    if (!isRecentRequest && !this.navigator.currentVisit && isCurrentUrl) {
4911      this.visit(url, { action: "replace", shouldCacheSnapshot: false });
4912    }
4913  }
4914  connectStreamSource(source) {
4915    this.streamObserver.connectStreamSource(source);
4916  }
4917  disconnectStreamSource(source) {
4918    this.streamObserver.disconnectStreamSource(source);
4919  }
4920  renderStreamMessage(message) {
4921    this.streamMessageRenderer.render(StreamMessage.wrap(message));
4922  }
4923  clearCache() {
4924    this.view.clearSnapshotCache();
4925  }
4926  setProgressBarDelay(delay) {
4927    console.warn(
4928      "Please replace `session.setProgressBarDelay(delay)` with `session.progressBarDelay = delay`. The function is deprecated and will be removed in a future version of Turbo.`"
4929    );
4930    this.progressBarDelay = delay;
4931  }
4932  set progressBarDelay(delay) {
4933    config.drive.progressBarDelay = delay;
4934  }
4935  get progressBarDelay() {
4936    return config.drive.progressBarDelay;
4937  }
4938  set drive(value) {
4939    config.drive.enabled = value;
4940  }
4941  get drive() {
4942    return config.drive.enabled;
4943  }
4944  set formMode(value) {
4945    config.forms.mode = value;
4946  }
4947  get formMode() {
4948    return config.forms.mode;
4949  }
4950  get location() {
4951    return this.history.location;
4952  }
4953  get restorationIdentifier() {
4954    return this.history.restorationIdentifier;
4955  }
4956  get pageRefreshDebouncePeriod() {
4957    return this.#pageRefreshDebouncePeriod;
4958  }
4959  set pageRefreshDebouncePeriod(value) {
4960    this.refresh = debounce(this.debouncedRefresh.bind(this), value);
4961    this.#pageRefreshDebouncePeriod = value;
4962  }
4963  // Preloader delegate
4964  shouldPreloadLink(element) {
4965    const isUnsafe = element.hasAttribute("data-turbo-method");
4966    const isStream = element.hasAttribute("data-turbo-stream");
4967    const frameTarget = element.getAttribute("data-turbo-frame");
4968    const frame = frameTarget == "_top" ? null : document.getElementById(frameTarget) || findClosestRecursively(element, "turbo-frame:not([disabled])");
4969    if (isUnsafe || isStream || frame instanceof FrameElement) {
4970      return false;
4971    } else {
4972      const location2 = new URL(element.href);
4973      return this.elementIsNavigatable(element) && locationIsVisitable(location2, this.snapshot.rootLocation);
4974    }
4975  }
4976  // History delegate
4977  historyPoppedToLocationWithRestorationIdentifierAndDirection(location2, restorationIdentifier, direction) {
4978    if (this.enabled) {
4979      this.navigator.startVisit(location2, restorationIdentifier, {
4980        action: "restore",
4981        historyChanged: true,
4982        direction
4983      });
4984    } else {
4985      this.adapter.pageInvalidated({
4986        reason: "turbo_disabled"
4987      });
4988    }
4989  }
4990  // Scroll observer delegate
4991  scrollPositionChanged(position) {
4992    this.history.updateRestorationData({ scrollPosition: position });
4993  }
4994  // Form click observer delegate
4995  willSubmitFormLinkToLocation(link, location2) {
4996    return this.elementIsNavigatable(link) && locationIsVisitable(location2, this.snapshot.rootLocation);
4997  }
4998  submittedFormLinkToLocation() {
4999  }
5000  // Link hover observer delegate
5001  canPrefetchRequestToLocation(link, location2) {
5002    return this.elementIsNavigatable(link) && locationIsVisitable(location2, this.snapshot.rootLocation) && this.navigator.linkPrefetchingIsEnabledForLocation(location2);
5003  }
5004  // Link click observer delegate
5005  willFollowLinkToLocation(link, location2, event) {
5006    return this.elementIsNavigatable(link) && locationIsVisitable(location2, this.snapshot.rootLocation) && this.applicationAllowsFollowingLinkToLocation(link, location2, event);
5007  }
5008  followedLinkToLocation(link, location2) {
5009    const action = this.getActionForLink(link);
5010    const acceptsStreamResponse = link.hasAttribute("data-turbo-stream");
5011    this.visit(location2.href, { action, acceptsStreamResponse });
5012  }
5013  // Navigator delegate
5014  allowsVisitingLocationWithAction(location2, action) {
5015    return this.locationWithActionIsSamePage(location2, action) || this.applicationAllowsVisitingLocation(location2);
5016  }
5017  visitProposedToLocation(location2, options) {
5018    extendURLWithDeprecatedProperties(location2);
5019    this.adapter.visitProposedToLocation(location2, options);
5020  }
5021  // Visit delegate
5022  visitStarted(visit2) {
5023    if (!visit2.acceptsStreamResponse) {
5024      markAsBusy(document.documentElement);
5025      this.view.markVisitDirection(visit2.direction);
5026    }
5027    extendURLWithDeprecatedProperties(visit2.location);
5028    if (!visit2.silent) {
5029      this.notifyApplicationAfterVisitingLocation(visit2.location, visit2.action);
5030    }
5031  }
5032  visitCompleted(visit2) {
5033    this.view.unmarkVisitDirection();
5034    clearBusyState(document.documentElement);
5035    this.notifyApplicationAfterPageLoad(visit2.getTimingMetrics());
5036  }
5037  locationWithActionIsSamePage(location2, action) {
5038    return this.navigator.locationWithActionIsSamePage(location2, action);
5039  }
5040  visitScrolledToSamePageLocation(oldURL, newURL) {
5041    this.notifyApplicationAfterVisitingSamePageLocation(oldURL, newURL);
5042  }
5043  // Form submit observer delegate
5044  willSubmitForm(form, submitter2) {
5045    const action = getAction$1(form, submitter2);
5046    return this.submissionIsNavigatable(form, submitter2) && locationIsVisitable(expandURL(action), this.snapshot.rootLocation);
5047  }
5048  formSubmitted(form, submitter2) {
5049    this.navigator.submitForm(form, submitter2);
5050  }
5051  // Page observer delegate
5052  pageBecameInteractive() {
5053    this.view.lastRenderedLocation = this.location;
5054    this.notifyApplicationAfterPageLoad();
5055  }
5056  pageLoaded() {
5057    this.history.assumeControlOfScrollRestoration();
5058  }
5059  pageWillUnload() {
5060    this.history.relinquishControlOfScrollRestoration();
5061  }
5062  // Stream observer delegate
5063  receivedMessageFromStream(message) {
5064    this.renderStreamMessage(message);
5065  }
5066  // Page view delegate
5067  viewWillCacheSnapshot() {
5068    if (!this.navigator.currentVisit?.silent) {
5069      this.notifyApplicationBeforeCachingSnapshot();
5070    }
5071  }
5072  allowsImmediateRender({ element }, options) {
5073    const event = this.notifyApplicationBeforeRender(element, options);
5074    const {
5075      defaultPrevented,
5076      detail: { render }
5077    } = event;
5078    if (this.view.renderer && render) {
5079      this.view.renderer.renderElement = render;
5080    }
5081    return !defaultPrevented;
5082  }
5083  viewRenderedSnapshot(_snapshot, _isPreview, renderMethod) {
5084    this.view.lastRenderedLocation = this.history.location;
5085    this.notifyApplicationAfterRender(renderMethod);
5086  }
5087  preloadOnLoadLinksForView(element) {
5088    this.preloader.preloadOnLoadLinksForView(element);
5089  }
5090  viewInvalidated(reason) {
5091    this.adapter.pageInvalidated(reason);
5092  }
5093  // Frame element
5094  frameLoaded(frame) {
5095    this.notifyApplicationAfterFrameLoad(frame);
5096  }
5097  frameRendered(fetchResponse, frame) {
5098    this.notifyApplicationAfterFrameRender(fetchResponse, frame);
5099  }
5100  // Application events
5101  applicationAllowsFollowingLinkToLocation(link, location2, ev) {
5102    const event = this.notifyApplicationAfterClickingLinkToLocation(link, location2, ev);
5103    return !event.defaultPrevented;
5104  }
5105  applicationAllowsVisitingLocation(location2) {
5106    const event = this.notifyApplicationBeforeVisitingLocation(location2);
5107    return !event.defaultPrevented;
5108  }
5109  notifyApplicationAfterClickingLinkToLocation(link, location2, event) {
5110    return dispatch("turbo:click", {
5111      target: link,
5112      detail: { url: location2.href, originalEvent: event },
5113      cancelable: true
5114    });
5115  }
5116  notifyApplicationBeforeVisitingLocation(location2) {
5117    return dispatch("turbo:before-visit", {
5118      detail: { url: location2.href },
5119      cancelable: true
5120    });
5121  }
5122  notifyApplicationAfterVisitingLocation(location2, action) {
5123    return dispatch("turbo:visit", { detail: { url: location2.href, action } });
5124  }
5125  notifyApplicationBeforeCachingSnapshot() {
5126    return dispatch("turbo:before-cache");
5127  }
5128  notifyApplicationBeforeRender(newBody, options) {
5129    return dispatch("turbo:before-render", {
5130      detail: { newBody, ...options },
5131      cancelable: true
5132    });
5133  }
5134  notifyApplicationAfterRender(renderMethod) {
5135    return dispatch("turbo:render", { detail: { renderMethod } });
5136  }
5137  notifyApplicationAfterPageLoad(timing = {}) {
5138    return dispatch("turbo:load", {
5139      detail: { url: this.location.href, timing }
5140    });
5141  }
5142  notifyApplicationAfterVisitingSamePageLocation(oldURL, newURL) {
5143    dispatchEvent(
5144      new HashChangeEvent("hashchange", {
5145        oldURL: oldURL.toString(),
5146        newURL: newURL.toString()
5147      })
5148    );
5149  }
5150  notifyApplicationAfterFrameLoad(frame) {
5151    return dispatch("turbo:frame-load", { target: frame });
5152  }
5153  notifyApplicationAfterFrameRender(fetchResponse, frame) {
5154    return dispatch("turbo:frame-render", {
5155      detail: { fetchResponse },
5156      target: frame,
5157      cancelable: true
5158    });
5159  }
5160  // Helpers
5161  submissionIsNavigatable(form, submitter2) {
5162    if (config.forms.mode == "off") {
5163      return false;
5164    } else {
5165      const submitterIsNavigatable = submitter2 ? this.elementIsNavigatable(submitter2) : true;
5166      if (config.forms.mode == "optin") {
5167        return submitterIsNavigatable && form.closest('[data-turbo="true"]') != null;
5168      } else {
5169        return submitterIsNavigatable && this.elementIsNavigatable(form);
5170      }
5171    }
5172  }
5173  elementIsNavigatable(element) {
5174    const container = findClosestRecursively(element, "[data-turbo]");
5175    const withinFrame = findClosestRecursively(element, "turbo-frame");
5176    if (config.drive.enabled || withinFrame) {
5177      if (container) {
5178        return container.getAttribute("data-turbo") != "false";
5179      } else {
5180        return true;
5181      }
5182    } else {
5183      if (container) {
5184        return container.getAttribute("data-turbo") == "true";
5185      } else {
5186        return false;
5187      }
5188    }
5189  }
5190  // Private
5191  getActionForLink(link) {
5192    return getVisitAction(link) || "advance";
5193  }
5194  get snapshot() {
5195    return this.view.snapshot;
5196  }
5197};
5198function extendURLWithDeprecatedProperties(url) {
5199  Object.defineProperties(url, deprecatedLocationPropertyDescriptors);
5200}
5201var deprecatedLocationPropertyDescriptors = {
5202  absoluteURL: {
5203    get() {
5204      return this.toString();
5205    }
5206  }
5207};
5208var session = new Session(recentRequests);
5209var { cache, navigator: navigator$1 } = session;
5210function start() {
5211  session.start();
5212}
5213function registerAdapter(adapter) {
5214  session.registerAdapter(adapter);
5215}
5216function visit(location2, options) {
5217  session.visit(location2, options);
5218}
5219function connectStreamSource(source) {
5220  session.connectStreamSource(source);
5221}
5222function disconnectStreamSource(source) {
5223  session.disconnectStreamSource(source);
5224}
5225function renderStreamMessage(message) {
5226  session.renderStreamMessage(message);
5227}
5228function clearCache() {
5229  console.warn(
5230    "Please replace `Turbo.clearCache()` with `Turbo.cache.clear()`. The top-level function is deprecated and will be removed in a future version of Turbo.`"
5231  );
5232  session.clearCache();
5233}
5234function setProgressBarDelay(delay) {
5235  console.warn(
5236    "Please replace `Turbo.setProgressBarDelay(delay)` with `Turbo.config.drive.progressBarDelay = delay`. The top-level function is deprecated and will be removed in a future version of Turbo.`"
5237  );
5238  config.drive.progressBarDelay = delay;
5239}
5240function setConfirmMethod(confirmMethod) {
5241  console.warn(
5242    "Please replace `Turbo.setConfirmMethod(confirmMethod)` with `Turbo.config.forms.confirm = confirmMethod`. The top-level function is deprecated and will be removed in a future version of Turbo.`"
5243  );
5244  config.forms.confirm = confirmMethod;
5245}
5246function setFormMode(mode) {
5247  console.warn(
5248    "Please replace `Turbo.setFormMode(mode)` with `Turbo.config.forms.mode = mode`. The top-level function is deprecated and will be removed in a future version of Turbo.`"
5249  );
5250  config.forms.mode = mode;
5251}
5252var Turbo2 = /* @__PURE__ */ Object.freeze({
5253  __proto__: null,
5254  navigator: navigator$1,
5255  session,
5256  cache,
5257  PageRenderer,
5258  PageSnapshot,
5259  FrameRenderer,
5260  fetch: fetchWithTurboHeaders,
5261  config,
5262  start,
5263  registerAdapter,
5264  visit,
5265  connectStreamSource,
5266  disconnectStreamSource,
5267  renderStreamMessage,
5268  clearCache,
5269  setProgressBarDelay,
5270  setConfirmMethod,
5271  setFormMode
5272});
5273var TurboFrameMissingError = class extends Error {
5274};
5275var FrameController = class {
5276  fetchResponseLoaded = (_fetchResponse) => Promise.resolve();
5277  #currentFetchRequest = null;
5278  #resolveVisitPromise = () => {
5279  };
5280  #connected = false;
5281  #hasBeenLoaded = false;
5282  #ignoredAttributes = /* @__PURE__ */ new Set();
5283  #shouldMorphFrame = false;
5284  action = null;
5285  constructor(element) {
5286    this.element = element;
5287    this.view = new FrameView(this, this.element);
5288    this.appearanceObserver = new AppearanceObserver(this, this.element);
5289    this.formLinkClickObserver = new FormLinkClickObserver(this, this.element);
5290    this.linkInterceptor = new LinkInterceptor(this, this.element);
5291    this.restorationIdentifier = uuid();
5292    this.formSubmitObserver = new FormSubmitObserver(this, this.element);
5293  }
5294  // Frame delegate
5295  connect() {
5296    if (!this.#connected) {
5297      this.#connected = true;
5298      if (this.loadingStyle == FrameLoadingStyle.lazy) {
5299        this.appearanceObserver.start();
5300      } else {
5301        this.#loadSourceURL();
5302      }
5303      this.formLinkClickObserver.start();
5304      this.linkInterceptor.start();
5305      this.formSubmitObserver.start();
5306    }
5307  }
5308  disconnect() {
5309    if (this.#connected) {
5310      this.#connected = false;
5311      this.appearanceObserver.stop();
5312      this.formLinkClickObserver.stop();
5313      this.linkInterceptor.stop();
5314      this.formSubmitObserver.stop();
5315    }
5316  }
5317  disabledChanged() {
5318    if (this.loadingStyle == FrameLoadingStyle.eager) {
5319      this.#loadSourceURL();
5320    }
5321  }
5322  sourceURLChanged() {
5323    if (this.#isIgnoringChangesTo("src")) return;
5324    if (this.element.isConnected) {
5325      this.complete = false;
5326    }
5327    if (this.loadingStyle == FrameLoadingStyle.eager || this.#hasBeenLoaded) {
5328      this.#loadSourceURL();
5329    }
5330  }
5331  sourceURLReloaded() {
5332    const { refresh, src } = this.element;
5333    this.#shouldMorphFrame = src && refresh === "morph";
5334    this.element.removeAttribute("complete");
5335    this.element.src = null;
5336    this.element.src = src;
5337    return this.element.loaded;
5338  }
5339  loadingStyleChanged() {
5340    if (this.loadingStyle == FrameLoadingStyle.lazy) {
5341      this.appearanceObserver.start();
5342    } else {
5343      this.appearanceObserver.stop();
5344      this.#loadSourceURL();
5345    }
5346  }
5347  async #loadSourceURL() {
5348    if (this.enabled && this.isActive && !this.complete && this.sourceURL) {
5349      this.element.loaded = this.#visit(expandURL(this.sourceURL));
5350      this.appearanceObserver.stop();
5351      await this.element.loaded;
5352      this.#hasBeenLoaded = true;
5353    }
5354  }
5355  async loadResponse(fetchResponse) {
5356    if (fetchResponse.redirected || fetchResponse.succeeded && fetchResponse.isHTML) {
5357      this.sourceURL = fetchResponse.response.url;
5358    }
5359    try {
5360      const html = await fetchResponse.responseHTML;
5361      if (html) {
5362        const document2 = parseHTMLDocument(html);
5363        const pageSnapshot = PageSnapshot.fromDocument(document2);
5364        if (pageSnapshot.isVisitable) {
5365          await this.#loadFrameResponse(fetchResponse, document2);
5366        } else {
5367          await this.#handleUnvisitableFrameResponse(fetchResponse);
5368        }
5369      }
5370    } finally {
5371      this.#shouldMorphFrame = false;
5372      this.fetchResponseLoaded = () => Promise.resolve();
5373    }
5374  }
5375  // Appearance observer delegate
5376  elementAppearedInViewport(element) {
5377    this.proposeVisitIfNavigatedWithAction(element, getVisitAction(element));
5378    this.#loadSourceURL();
5379  }
5380  // Form link click observer delegate
5381  willSubmitFormLinkToLocation(link) {
5382    return this.#shouldInterceptNavigation(link);
5383  }
5384  submittedFormLinkToLocation(link, _location, form) {
5385    const frame = this.#findFrameElement(link);
5386    if (frame) form.setAttribute("data-turbo-frame", frame.id);
5387  }
5388  // Link interceptor delegate
5389  shouldInterceptLinkClick(element, _location, _event) {
5390    return this.#shouldInterceptNavigation(element);
5391  }
5392  linkClickIntercepted(element, location2) {
5393    this.#navigateFrame(element, location2);
5394  }
5395  // Form submit observer delegate
5396  willSubmitForm(element, submitter2) {
5397    return element.closest("turbo-frame") == this.element && this.#shouldInterceptNavigation(element, submitter2);
5398  }
5399  formSubmitted(element, submitter2) {
5400    if (this.formSubmission) {
5401      this.formSubmission.stop();
5402    }
5403    this.formSubmission = new FormSubmission(this, element, submitter2);
5404    const { fetchRequest } = this.formSubmission;
5405    this.prepareRequest(fetchRequest);
5406    this.formSubmission.start();
5407  }
5408  // Fetch request delegate
5409  prepareRequest(request) {
5410    request.headers["Turbo-Frame"] = this.id;
5411    if (this.currentNavigationElement?.hasAttribute("data-turbo-stream")) {
5412      request.acceptResponseType(StreamMessage.contentType);
5413    }
5414  }
5415  requestStarted(_request) {
5416    markAsBusy(this.element);
5417  }
5418  requestPreventedHandlingResponse(_request, _response) {
5419    this.#resolveVisitPromise();
5420  }
5421  async requestSucceededWithResponse(request, response) {
5422    await this.loadResponse(response);
5423    this.#resolveVisitPromise();
5424  }
5425  async requestFailedWithResponse(request, response) {
5426    await this.loadResponse(response);
5427    this.#resolveVisitPromise();
5428  }
5429  requestErrored(request, error) {
5430    console.error(error);
5431    this.#resolveVisitPromise();
5432  }
5433  requestFinished(_request) {
5434    clearBusyState(this.element);
5435  }
5436  // Form submission delegate
5437  formSubmissionStarted({ formElement }) {
5438    markAsBusy(formElement, this.#findFrameElement(formElement));
5439  }
5440  formSubmissionSucceededWithResponse(formSubmission, response) {
5441    const frame = this.#findFrameElement(formSubmission.formElement, formSubmission.submitter);
5442    frame.delegate.proposeVisitIfNavigatedWithAction(frame, getVisitAction(formSubmission.submitter, formSubmission.formElement, frame));
5443    frame.delegate.loadResponse(response);
5444    if (!formSubmission.isSafe) {
5445      session.clearCache();
5446    }
5447  }
5448  formSubmissionFailedWithResponse(formSubmission, fetchResponse) {
5449    this.element.delegate.loadResponse(fetchResponse);
5450    session.clearCache();
5451  }
5452  formSubmissionErrored(formSubmission, error) {
5453    console.error(error);
5454  }
5455  formSubmissionFinished({ formElement }) {
5456    clearBusyState(formElement, this.#findFrameElement(formElement));
5457  }
5458  // View delegate
5459  allowsImmediateRender({ element: newFrame }, options) {
5460    const event = dispatch("turbo:before-frame-render", {
5461      target: this.element,
5462      detail: { newFrame, ...options },
5463      cancelable: true
5464    });
5465    const {
5466      defaultPrevented,
5467      detail: { render }
5468    } = event;
5469    if (this.view.renderer && render) {
5470      this.view.renderer.renderElement = render;
5471    }
5472    return !defaultPrevented;
5473  }
5474  viewRenderedSnapshot(_snapshot, _isPreview, _renderMethod) {
5475  }
5476  preloadOnLoadLinksForView(element) {
5477    session.preloadOnLoadLinksForView(element);
5478  }
5479  viewInvalidated() {
5480  }
5481  // Frame renderer delegate
5482  willRenderFrame(currentElement, _newElement) {
5483    this.previousFrameElement = currentElement.cloneNode(true);
5484  }
5485  visitCachedSnapshot = ({ element }) => {
5486    const frame = element.querySelector("#" + this.element.id);
5487    if (frame && this.previousFrameElement) {
5488      frame.replaceChildren(...this.previousFrameElement.children);
5489    }
5490    delete this.previousFrameElement;
5491  };
5492  // Private
5493  async #loadFrameResponse(fetchResponse, document2) {
5494    const newFrameElement = await this.extractForeignFrameElement(document2.body);
5495    const rendererClass = this.#shouldMorphFrame ? MorphingFrameRenderer : FrameRenderer;
5496    if (newFrameElement) {
5497      const snapshot = new Snapshot(newFrameElement);
5498      const renderer = new rendererClass(this, this.view.snapshot, snapshot, false, false);
5499      if (this.view.renderPromise) await this.view.renderPromise;
5500      this.changeHistory();
5501      await this.view.render(renderer);
5502      this.complete = true;
5503      session.frameRendered(fetchResponse, this.element);
5504      session.frameLoaded(this.element);
5505      await this.fetchResponseLoaded(fetchResponse);
5506    } else if (this.#willHandleFrameMissingFromResponse(fetchResponse)) {
5507      this.#handleFrameMissingFromResponse(fetchResponse);
5508    }
5509  }
5510  async #visit(url) {
5511    const request = new FetchRequest(this, FetchMethod.get, url, new URLSearchParams(), this.element);
5512    this.#currentFetchRequest?.cancel();
5513    this.#currentFetchRequest = request;
5514    return new Promise((resolve) => {
5515      this.#resolveVisitPromise = () => {
5516        this.#resolveVisitPromise = () => {
5517        };
5518        this.#currentFetchRequest = null;
5519        resolve();
5520      };
5521      request.perform();
5522    });
5523  }
5524  #navigateFrame(element, url, submitter2) {
5525    const frame = this.#findFrameElement(element, submitter2);
5526    frame.delegate.proposeVisitIfNavigatedWithAction(frame, getVisitAction(submitter2, element, frame));
5527    this.#withCurrentNavigationElement(element, () => {
5528      frame.src = url;
5529    });
5530  }
5531  proposeVisitIfNavigatedWithAction(frame, action = null) {
5532    this.action = action;
5533    if (this.action) {
5534      const pageSnapshot = PageSnapshot.fromElement(frame).clone();
5535      const { visitCachedSnapshot } = frame.delegate;
5536      frame.delegate.fetchResponseLoaded = async (fetchResponse) => {
5537        if (frame.src) {
5538          const { statusCode, redirected } = fetchResponse;
5539          const responseHTML = await fetchResponse.responseHTML;
5540          const response = { statusCode, redirected, responseHTML };
5541          const options = {
5542            response,
5543            visitCachedSnapshot,
5544            willRender: false,
5545            updateHistory: false,
5546            restorationIdentifier: this.restorationIdentifier,
5547            snapshot: pageSnapshot
5548          };
5549          if (this.action) options.action = this.action;
5550          session.visit(frame.src, options);
5551        }
5552      };
5553    }
5554  }
5555  changeHistory() {
5556    if (this.action) {
5557      const method = getHistoryMethodForAction(this.action);
5558      session.history.update(method, expandURL(this.element.src || ""), this.restorationIdentifier);
5559    }
5560  }
5561  async #handleUnvisitableFrameResponse(fetchResponse) {
5562    console.warn(
5563      `The response (${fetchResponse.statusCode}) from <turbo-frame id="${this.element.id}"> is performing a full page visit due to turbo-visit-control.`
5564    );
5565    await this.#visitResponse(fetchResponse.response);
5566  }
5567  #willHandleFrameMissingFromResponse(fetchResponse) {
5568    this.element.setAttribute("complete", "");
5569    const response = fetchResponse.response;
5570    const visit2 = async (url, options) => {
5571      if (url instanceof Response) {
5572        this.#visitResponse(url);
5573      } else {
5574        session.visit(url, options);
5575      }
5576    };
5577    const event = dispatch("turbo:frame-missing", {
5578      target: this.element,
5579      detail: { response, visit: visit2 },
5580      cancelable: true
5581    });
5582    return !event.defaultPrevented;
5583  }
5584  #handleFrameMissingFromResponse(fetchResponse) {
5585    this.view.missing();
5586    this.#throwFrameMissingError(fetchResponse);
5587  }
5588  #throwFrameMissingError(fetchResponse) {
5589    const message = `The response (${fetchResponse.statusCode}) did not contain the expected <turbo-frame id="${this.element.id}"> and will be ignored. To perform a full page visit instead, set turbo-visit-control to reload.`;
5590    throw new TurboFrameMissingError(message);
5591  }
5592  async #visitResponse(response) {
5593    const wrapped = new FetchResponse(response);
5594    const responseHTML = await wrapped.responseHTML;
5595    const { location: location2, redirected, statusCode } = wrapped;
5596    return session.visit(location2, { response: { redirected, statusCode, responseHTML } });
5597  }
5598  #findFrameElement(element, submitter2) {
5599    const id = getAttribute("data-turbo-frame", submitter2, element) || this.element.getAttribute("target");
5600    return getFrameElementById(id) ?? this.element;
5601  }
5602  async extractForeignFrameElement(container) {
5603    let element;
5604    const id = CSS.escape(this.id);
5605    try {
5606      element = activateElement(container.querySelector(`turbo-frame#${id}`), this.sourceURL);
5607      if (element) {
5608        return element;
5609      }
5610      element = activateElement(container.querySelector(`turbo-frame[src][recurse~=${id}]`), this.sourceURL);
5611      if (element) {
5612        await element.loaded;
5613        return await this.extractForeignFrameElement(element);
5614      }
5615    } catch (error) {
5616      console.error(error);
5617      return new FrameElement();
5618    }
5619    return null;
5620  }
5621  #formActionIsVisitable(form, submitter2) {
5622    const action = getAction$1(form, submitter2);
5623    return locationIsVisitable(expandURL(action), this.rootLocation);
5624  }
5625  #shouldInterceptNavigation(element, submitter2) {
5626    const id = getAttribute("data-turbo-frame", submitter2, element) || this.element.getAttribute("target");
5627    if (element instanceof HTMLFormElement && !this.#formActionIsVisitable(element, submitter2)) {
5628      return false;
5629    }
5630    if (!this.enabled || id == "_top") {
5631      return false;
5632    }
5633    if (id) {
5634      const frameElement = getFrameElementById(id);
5635      if (frameElement) {
5636        return !frameElement.disabled;
5637      }
5638    }
5639    if (!session.elementIsNavigatable(element)) {
5640      return false;
5641    }
5642    if (submitter2 && !session.elementIsNavigatable(submitter2)) {
5643      return false;
5644    }
5645    return true;
5646  }
5647  // Computed properties
5648  get id() {
5649    return this.element.id;
5650  }
5651  get enabled() {
5652    return !this.element.disabled;
5653  }
5654  get sourceURL() {
5655    if (this.element.src) {
5656      return this.element.src;
5657    }
5658  }
5659  set sourceURL(sourceURL) {
5660    this.#ignoringChangesToAttribute("src", () => {
5661      this.element.src = sourceURL ?? null;
5662    });
5663  }
5664  get loadingStyle() {
5665    return this.element.loading;
5666  }
5667  get isLoading() {
5668    return this.formSubmission !== void 0 || this.#resolveVisitPromise() !== void 0;
5669  }
5670  get complete() {
5671    return this.element.hasAttribute("complete");
5672  }
5673  set complete(value) {
5674    if (value) {
5675      this.element.setAttribute("complete", "");
5676    } else {
5677      this.element.removeAttribute("complete");
5678    }
5679  }
5680  get isActive() {
5681    return this.element.isActive && this.#connected;
5682  }
5683  get rootLocation() {
5684    const meta = this.element.ownerDocument.querySelector(`meta[name="turbo-root"]`);
5685    const root = meta?.content ?? "/";
5686    return expandURL(root);
5687  }
5688  #isIgnoringChangesTo(attributeName) {
5689    return this.#ignoredAttributes.has(attributeName);
5690  }
5691  #ignoringChangesToAttribute(attributeName, callback) {
5692    this.#ignoredAttributes.add(attributeName);
5693    callback();
5694    this.#ignoredAttributes.delete(attributeName);
5695  }
5696  #withCurrentNavigationElement(element, callback) {
5697    this.currentNavigationElement = element;
5698    callback();
5699    delete this.currentNavigationElement;
5700  }
5701};
5702function getFrameElementById(id) {
5703  if (id != null) {
5704    const element = document.getElementById(id);
5705    if (element instanceof FrameElement) {
5706      return element;
5707    }
5708  }
5709}
5710function activateElement(element, currentURL) {
5711  if (element) {
5712    const src = element.getAttribute("src");
5713    if (src != null && currentURL != null && urlsAreEqual(src, currentURL)) {
5714      throw new Error(`Matching <turbo-frame id="${element.id}"> element has a source URL which references itself`);
5715    }
5716    if (element.ownerDocument !== document) {
5717      element = document.importNode(element, true);
5718    }
5719    if (element instanceof FrameElement) {
5720      element.connectedCallback();
5721      element.disconnectedCallback();
5722      return element;
5723    }
5724  }
5725}
5726var StreamActions = {
5727  after() {
5728    this.targetElements.forEach((e) => e.parentElement?.insertBefore(this.templateContent, e.nextSibling));
5729  },
5730  append() {
5731    this.removeDuplicateTargetChildren();
5732    this.targetElements.forEach((e) => e.append(this.templateContent));
5733  },
5734  before() {
5735    this.targetElements.forEach((e) => e.parentElement?.insertBefore(this.templateContent, e));
5736  },
5737  prepend() {
5738    this.removeDuplicateTargetChildren();
5739    this.targetElements.forEach((e) => e.prepend(this.templateContent));
5740  },
5741  remove() {
5742    this.targetElements.forEach((e) => e.remove());
5743  },
5744  replace() {
5745    const method = this.getAttribute("method");
5746    this.targetElements.forEach((targetElement) => {
5747      if (method === "morph") {
5748        morphElements(targetElement, this.templateContent);
5749      } else {
5750        targetElement.replaceWith(this.templateContent);
5751      }
5752    });
5753  },
5754  update() {
5755    const method = this.getAttribute("method");
5756    this.targetElements.forEach((targetElement) => {
5757      if (method === "morph") {
5758        morphChildren(targetElement, this.templateContent);
5759      } else {
5760        targetElement.innerHTML = "";
5761        targetElement.append(this.templateContent);
5762      }
5763    });
5764  },
5765  refresh() {
5766    session.refresh(this.baseURI, this.requestId);
5767  }
5768};
5769var StreamElement = class _StreamElement extends HTMLElement {
5770  static async renderElement(newElement) {
5771    await newElement.performAction();
5772  }
5773  async connectedCallback() {
5774    try {
5775      await this.render();
5776    } catch (error) {
5777      console.error(error);
5778    } finally {
5779      this.disconnect();
5780    }
5781  }
5782  async render() {
5783    return this.renderPromise ??= (async () => {
5784      const event = this.beforeRenderEvent;
5785      if (this.dispatchEvent(event)) {
5786        await nextRepaint();
5787        await event.detail.render(this);
5788      }
5789    })();
5790  }
5791  disconnect() {
5792    try {
5793      this.remove();
5794    } catch {
5795    }
5796  }
5797  /**
5798   * Removes duplicate children (by ID)
5799   */
5800  removeDuplicateTargetChildren() {
5801    this.duplicateChildren.forEach((c) => c.remove());
5802  }
5803  /**
5804   * Gets the list of duplicate children (i.e. those with the same ID)
5805   */
5806  get duplicateChildren() {
5807    const existingChildren = this.targetElements.flatMap((e) => [...e.children]).filter((c) => !!c.getAttribute("id"));
5808    const newChildrenIds = [...this.templateContent?.children || []].filter((c) => !!c.getAttribute("id")).map((c) => c.getAttribute("id"));
5809    return existingChildren.filter((c) => newChildrenIds.includes(c.getAttribute("id")));
5810  }
5811  /**
5812   * Gets the action function to be performed.
5813   */
5814  get performAction() {
5815    if (this.action) {
5816      const actionFunction = StreamActions[this.action];
5817      if (actionFunction) {
5818        return actionFunction;
5819      }
5820      this.#raise("unknown action");
5821    }
5822    this.#raise("action attribute is missing");
5823  }
5824  /**
5825   * Gets the target elements which the template will be rendered to.
5826   */
5827  get targetElements() {
5828    if (this.target) {
5829      return this.targetElementsById;
5830    } else if (this.targets) {
5831      return this.targetElementsByQuery;
5832    } else {
5833      this.#raise("target or targets attribute is missing");
5834    }
5835  }
5836  /**
5837   * Gets the contents of the main `<template>`.
5838   */
5839  get templateContent() {
5840    return this.templateElement.content.cloneNode(true);
5841  }
5842  /**
5843   * Gets the main `<template>` used for rendering
5844   */
5845  get templateElement() {
5846    if (this.firstElementChild === null) {
5847      const template = this.ownerDocument.createElement("template");
5848      this.appendChild(template);
5849      return template;
5850    } else if (this.firstElementChild instanceof HTMLTemplateElement) {
5851      return this.firstElementChild;
5852    }
5853    this.#raise("first child element must be a <template> element");
5854  }
5855  /**
5856   * Gets the current action.
5857   */
5858  get action() {
5859    return this.getAttribute("action");
5860  }
5861  /**
5862   * Gets the current target (an element ID) to which the result will
5863   * be rendered.
5864   */
5865  get target() {
5866    return this.getAttribute("target");
5867  }
5868  /**
5869   * Gets the current "targets" selector (a CSS selector)
5870   */
5871  get targets() {
5872    return this.getAttribute("targets");
5873  }
5874  /**
5875   * Reads the request-id attribute
5876   */
5877  get requestId() {
5878    return this.getAttribute("request-id");
5879  }
5880  #raise(message) {
5881    throw new Error(`${this.description}: ${message}`);
5882  }
5883  get description() {
5884    return (this.outerHTML.match(/<[^>]+>/) ?? [])[0] ?? "<turbo-stream>";
5885  }
5886  get beforeRenderEvent() {
5887    return new CustomEvent("turbo:before-stream-render", {
5888      bubbles: true,
5889      cancelable: true,
5890      detail: { newStream: this, render: _StreamElement.renderElement }
5891    });
5892  }
5893  get targetElementsById() {
5894    const element = this.ownerDocument?.getElementById(this.target);
5895    if (element !== null) {
5896      return [element];
5897    } else {
5898      return [];
5899    }
5900  }
5901  get targetElementsByQuery() {
5902    const elements = this.ownerDocument?.querySelectorAll(this.targets);
5903    if (elements.length !== 0) {
5904      return Array.prototype.slice.call(elements);
5905    } else {
5906      return [];
5907    }
5908  }
5909};
5910var StreamSourceElement = class extends HTMLElement {
5911  streamSource = null;
5912  connectedCallback() {
5913    this.streamSource = this.src.match(/^ws{1,2}:/) ? new WebSocket(this.src) : new EventSource(this.src);
5914    connectStreamSource(this.streamSource);
5915  }
5916  disconnectedCallback() {
5917    if (this.streamSource) {
5918      this.streamSource.close();
5919      disconnectStreamSource(this.streamSource);
5920    }
5921  }
5922  get src() {
5923    return this.getAttribute("src") || "";
5924  }
5925};
5926FrameElement.delegateConstructor = FrameController;
5927if (customElements.get("turbo-frame") === void 0) {
5928  customElements.define("turbo-frame", FrameElement);
5929}
5930if (customElements.get("turbo-stream") === void 0) {
5931  customElements.define("turbo-stream", StreamElement);
5932}
5933if (customElements.get("turbo-stream-source") === void 0) {
5934  customElements.define("turbo-stream-source", StreamSourceElement);
5935}
5936(() => {
5937  let element = document.currentScript;
5938  if (!element) return;
5939  if (element.hasAttribute("data-turbo-suppress-warning")) return;
5940  element = element.parentElement;
5941  while (element) {
5942    if (element == document.body) {
5943      return console.warn(
5944        unindent`
5945        You are loading Turbo from a <script> element inside the <body> element. This is probably not what you meant to do!
5946
5947        Load your application’s JavaScript bundle inside the <head> element instead. <script> elements in <body> are evaluated with each page change.
5948
5949        For more information, see: https://turbo.hotwired.dev/handbook/building#working-with-script-elements
5950
5951        ——
5952        Suppress this warning by adding a "data-turbo-suppress-warning" attribute to: %s
5953      `,
5954        element.outerHTML
5955      );
5956    }
5957    element = element.parentElement;
5958  }
5959})();
5960window.Turbo = { ...Turbo2, StreamActions };
5961start();
5962