https://www.britishtheatreguide.info/assets/frontend-06f6b231.js

39// ../../node_modules/@rails/actioncable/src/adapters.js
40  var adapters_default;
41  var init_adapters = __esm({
42    "../../node_modules/@rails/actioncable/src/adapters.js"() {
43      adapters_default = {
44        logger: typeof console !== "undefined" ? console : void 0,
45        WebSocket: typeof WebSocket !== "undefined" ? WebSocket : void 0
46      };
47    }
48  });
49
50  

50// ../../node_modules/@rails/actioncable/src/logger.js
51  var logger_default;
52  var init_logger = __esm({
53    "../../node_modules/@rails/actioncable/src/logger.js"() {
54      init_adapters();
55      logger_default = {
56        log(...messages) {
57          if (this.enabled) {
58            messages.push(Date.now());
59            adapters_default.logger.log("[ActionCable]", ...messages);
60          }
61        }
62      };
63    }
64  });
65
66  

66// ../../node_modules/@rails/actioncable/src/connection_monitor.js
67  var now, secondsSince, ConnectionMonitor, connection_monitor_default;
68  var init_connection_monitor = __esm({
69    "../../node_modules/@rails/actioncable/src/connection_monitor.js"() {
70      init_logger();
71      now = () => new Date().getTime();
72      secondsSince = (time) => (now() - time) / 1e3;
73      ConnectionMonitor = class {
74        constructor(connection) {
75          this.visibilityDidChange = this.visibilityDidChange.bind(this);
76          this.connection = connection;
77          this.reconnectAttempts = 0;
78        }
79        start() {
80          if (!this.isRunning()) {
81            this.startedAt = now();
82            delete this.stoppedAt;
83            this.startPolling();
84            addEventListener("visibilitychange", this.visibilityDidChange);
85            logger_default.log(`ConnectionMonitor started. stale threshold = ${this.constructor.staleThreshold} s`);
86          }
87        }
88        stop() {
89          if (this.isRunning()) {
90            this.stoppedAt = now();
91            this.stopPolling();
92            removeEventListener("visibilitychange", this.visibilityDidChange);
93            logger_default.log("ConnectionMonitor stopped");
94          }
95        }
96        isRunning() {
97          return this.startedAt && !this.stoppedAt;
98        }
99        recordMessage() {
100          this.pingedAt = now();
101        }
102        recordConnect() {
103          this.reconnectAttempts = 0;
104          delete this.disconnectedAt;
105          logger_default.log("ConnectionMonitor recorded connect");
106        }
107        recordDisconnect() {
108          this.disconnectedAt = now();
109          logger_default.log("ConnectionMonitor recorded disconnect");
110        }
111        startPolling() {
112          this.stopPolling();
113          this.poll();
114        }
115        stopPolling() {
116          clearTimeout(this.pollTimeout);
117        }
118        poll() {
119          this.pollTimeout = setTimeout(
120            () => {
121              this.reconnectIfStale();
122              this.poll();
123            },
124            this.getPollInterval()
125          );
126        }
127        getPollInterval() {
128          const { staleThreshold, reconnectionBackoffRate } = this.constructor;
129          const backoff = Math.pow(1 + reconnectionBackoffRate, Math.min(this.reconnectAttempts, 10));
130          const jitterMax = this.reconnectAttempts === 0 ? 1 : reconnectionBackoffRate;
131          const jitter = jitterMax * Math.random();
132          return staleThreshold * 1e3 * backoff * (1 + jitter);
133        }
134        reconnectIfStale() {
135          if (this.connectionIsStale()) {
136            logger_default.log(`ConnectionMonitor detected stale connection. reconnectAttempts = ${this.reconnectAttempts}, time stale = ${secondsSince(this.refreshedAt)} s, stale threshold = ${this.constructor.staleThreshold} s`);
137            this.reconnectAttempts++;
138            if (this.disconnectedRecently()) {
139              logger_default.log(`ConnectionMonitor skipping reopening recent disconnect. time disconnected = ${secondsSince(this.disconnectedAt)} s`);
140            } else {
141              logger_default.log("ConnectionMonitor reopening");
142              this.connection.reopen();
143            }
144          }
145        }
146        get refreshedAt() {
147          return this.pingedAt ? this.pingedAt : this.startedAt;
148        }
149        connectionIsStale() {
150          return secondsSince(this.refreshedAt) > this.constructor.staleThreshold;
151        }
152        disconnectedRecently() {
153          return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;
154        }
155        visibilityDidChange() {
156          if (document.visibilityState === "visible") {
157            setTimeout(
158              () => {
159                if (this.connectionIsStale() || !this.connection.isOpen()) {
160                  logger_default.log(`ConnectionMonitor reopening stale connection on visibilitychange. visibilityState = ${document.visibilityState}`);
161                  this.connection.reopen();
162                }
163              },
164              200
165            );
166          }
167        }
168      };
169      ConnectionMonitor.staleThreshold = 6;
170      ConnectionMonitor.reconnectionBackoffRate = 0.15;
171      connection_monitor_default = ConnectionMonitor;
172    }
173  });
174
175  

175// ../../node_modules/@rails/actioncable/src/internal.js
176  var internal_default;
177  var init_internal = __esm({
178    "../../node_modules/@rails/actioncable/src/internal.js"() {
179      internal_default = {
180        "message_types": {
181          "welcome": "welcome",
182          "disconnect": "disconnect",
183          "ping": "ping",
184          "confirmation": "confirm_subscription",
185          "rejection": "reject_subscription"
186        },
187        "disconnect_reasons": {
188          "unauthorized": "unauthorized",
189          "invalid_request": "invalid_request",
190          "server_restart": "server_restart",
191          "remote": "remote"
192        },
193        "default_mount_path": "/cable",
194        "protocols": [
195          "actioncable-v1-json",
196          "actioncable-unsupported"
197        ]
198      };
199    }
200  });
201
202  

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

370// ../../node_modules/@rails/actioncable/src/subscription.js
371  var extend, Subscription;
372  var init_subscription = __esm({
373    "../../node_modules/@rails/actioncable/src/subscription.js"() {
374      extend = function(object, properties) {
375        if (properties != null) {
376          for (let key in properties) {
377            const value = properties[key];
378            object[key] = value;
379          }
380        }
381        return object;
382      };
383      Subscription = class {
384        constructor(consumer2, params = {}, mixin) {
385          this.consumer = consumer2;
386          this.identifier = JSON.stringify(params);
387          extend(this, mixin);
388        }
389        perform(action, data = {}) {
390          data.action = action;
391          return this.send(data);
392        }
393        send(data) {
394          return this.consumer.send({ command: "message", identifier: this.identifier, data: JSON.stringify(data) });
395        }
396        unsubscribe() {
397          return this.consumer.subscriptions.remove(this);
398        }
399      };
400    }
401  });
402
403  

403// ../../node_modules/@rails/actioncable/src/subscription_guarantor.js
404  var SubscriptionGuarantor, subscription_guarantor_default;
405  var init_subscription_guarantor = __esm({
406    "../../node_modules/@rails/actioncable/src/subscription_guarantor.js"() {
407      init_logger();
408      SubscriptionGuarantor = class {
409        constructor(subscriptions) {
410          this.subscriptions = subscriptions;
411          this.pendingSubscriptions = [];
412        }
413        guarantee(subscription) {
414          if (this.pendingSubscriptions.indexOf(subscription) == -1) {
415            logger_default.log(`SubscriptionGuarantor guaranteeing ${subscription.identifier}`);
416            this.pendingSubscriptions.push(subscription);
417          } else {
418            logger_default.log(`SubscriptionGuarantor already guaranteeing ${subscription.identifier}`);
419          }
420          this.startGuaranteeing();
421        }
422        forget(subscription) {
423          logger_default.log(`SubscriptionGuarantor forgetting ${subscription.identifier}`);
424          this.pendingSubscriptions = this.pendingSubscriptions.filter((s) => s !== subscription);
425        }
426        startGuaranteeing() {
427          this.stopGuaranteeing();
428          this.retrySubscribing();
429        }
430        stopGuaranteeing() {
431          clearTimeout(this.retryTimeout);
432        }
433        retrySubscribing() {
434          this.retryTimeout = setTimeout(
435            () => {
436              if (this.subscriptions && typeof this.subscriptions.subscribe === "function") {
437                this.pendingSubscriptions.map((subscription) => {
438                  logger_default.log(`SubscriptionGuarantor resubscribing ${subscription.identifier}`);
439                  this.subscriptions.subscribe(subscription);
440                });
441              }
442            },
443            500
444          );
445        }
446      };
447      subscription_guarantor_default = SubscriptionGuarantor;
448    }
449  });
450
451  

451// ../../node_modules/@rails/actioncable/src/subscriptions.js
452  var Subscriptions;
453  var init_subscriptions = __esm({
454    "../../node_modules/@rails/actioncable/src/subscriptions.js"() {
455      init_logger();
456      init_subscription();
457      init_subscription_guarantor();
458      Subscriptions = class {
459        constructor(consumer2) {
460          this.consumer = consumer2;
461          this.guarantor = new subscription_guarantor_default(this);
462          this.subscriptions = [];
463        }
464        create(channelName, mixin) {
465          const channel = channelName;
466          const params = typeof channel === "object" ? channel : { channel };
467          const subscription = new Subscription(this.consumer, params, mixin);
468          return this.add(subscription);
469        }
470        add(subscription) {
471          this.subscriptions.push(subscription);
472          this.consumer.ensureActiveConnection();
473          this.notify(subscription, "initialized");
474          this.subscribe(subscription);
475          return subscription;
476        }
477        remove(subscription) {
478          this.forget(subscription);
479          if (!this.findAll(subscription.identifier).length) {
480            this.sendCommand(subscription, "unsubscribe");
481          }
482          return subscription;
483        }
484        reject(identifier) {
485          return this.findAll(identifier).map((subscription) => {
486            this.forget(subscription);
487            this.notify(subscription, "rejected");
488            return subscription;
489          });
490        }
491        forget(subscription) {
492          this.guarantor.forget(subscription);
493          this.subscriptions = this.subscriptions.filter((s) => s !== subscription);
494          return subscription;
495        }
496        findAll(identifier) {
497          return this.subscriptions.filter((s) => s.identifier === identifier);
498        }
499        reload() {
500          return this.subscriptions.map((subscription) => this.subscribe(subscription));
501        }
502        notifyAll(callbackName, ...args) {
503          return this.subscriptions.map((subscription) => this.notify(subscription, callbackName, ...args));
504        }
505        notify(subscription, callbackName, ...args) {
506          let subscriptions;
507          if (typeof subscription === "string") {
508            subscriptions = this.findAll(subscription);
509          } else {
510            subscriptions = [subscription];
511          }
512          return subscriptions.map((subscription2) => typeof subscription2[callbackName] === "function" ? subscription2[callbackName](...args) : void 0);
513        }
514        subscribe(subscription) {
515          if (this.sendCommand(subscription, "subscribe")) {
516            this.guarantor.guarantee(subscription);
517          }
518        }
519        confirmSubscription(identifier) {
520          logger_default.log(`Subscription confirmed ${identifier}`);
521          this.findAll(identifier).map((subscription) => this.guarantor.forget(subscription));
522        }
523        sendCommand(subscription, command) {
524          const { identifier } = subscription;
525          return this.consumer.send({ command, identifier });
526        }
527      };
528    }
529  });
530
531  

531// ../../node_modules/@rails/actioncable/src/consumer.js
532  function createWebSocketURL(url) {
533    if (typeof url === "function") {
534      url = url();
535    }
536    if (url && !/^wss?:/i.test(url)) {
537      const a = document.createElement("a");
538      a.href = url;
539      a.href = a.href;
540      a.protocol = a.protocol.replace("http", "ws");
541      return a.href;
542    } else {
543      return url;
544    }
545  }
546  var Consumer;
547  var init_consumer = __esm({
548    "../../node_modules/@rails/actioncable/src/consumer.js"() {
549      init_connection();
550      init_subscriptions();
551      Consumer = class {
552        constructor(url) {
553          this._url = url;
554          this.subscriptions = new Subscriptions(this);
555          this.connection = new connection_default(this);
556          this.subprotocols = [];
557        }
558        get url() {
559          return createWebSocketURL(this._url);
560        }
561        send(data) {
562          return this.connection.send(data);
563        }
564        connect() {
565          return this.connection.open();
566        }
567        disconnect() {
568          return this.connection.close({ allowReconnect: false });
569        }
570        ensureActiveConnection() {
571          if (!this.connection.isActive()) {
572            return this.connection.open();
573          }
574        }
575        addSubProtocol(subprotocol) {
576          this.subprotocols = [...this.subprotocols, subprotocol];
577        }
578      };
579    }
580  });
581
582  

582// ../../node_modules/@rails/actioncable/src/index.js
583  var src_exports = {};
584  __export(src_exports, {
585    Connection: () => connection_default,
586    ConnectionMonitor: () => connection_monitor_default,
587    Consumer: () => Consumer,
588    INTERNAL: () => internal_default,
589    Subscription: () => Subscription,
590    SubscriptionGuarantor: () => subscription_guarantor_default,
591    Subscriptions: () => Subscriptions,
592    adapters: () => adapters_default,
593    createConsumer: () => createConsumer,
594    createWebSocketURL: () => createWebSocketURL,
595    getConfig: () => getConfig,
596    logger: () => logger_default
597  });
598  function createConsumer(url = getConfig("url") || internal_default.default_mount_path) {
599    return new Consumer(url);
600  }
601  function getConfig(name) {
602    const element = document.head.querySelector(`meta[name='action-cable-${name}']`);
603    if (element) {
604      return element.getAttribute("content");
605    }
606  }
607  var init_src = __esm({
608    "../../node_modules/@rails/actioncable/src/index.js"() {
609      init_adapters();
610      init_connection();
611      init_connection_monitor();
612      init_consumer();
613      init_internal();
614      init_logger();
615      init_subscription();
616      init_subscription_guarantor();
617      init_subscriptions();
618    }
619  });
620
621  

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