livewire.js?id=07f22875

js europeanforum.museum collected 2026-10-02 10:25:23 UTC 335,813 bytes, 9,905 lines download raw bytes

1(() => {
2  var __create = Object.create;
3  var __defProp = Object.defineProperty;
4  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
5  var __getOwnPropNames = Object.getOwnPropertyNames;
6  var __getProtoOf = Object.getPrototypeOf;
7  var __hasOwnProp = Object.prototype.hasOwnProperty;
8  var __commonJS = (cb, mod) => function __require() {
9    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
10  };
11  var __copyProps = (to, from, except, desc) => {
12    if (from && typeof from === "object" || typeof from === "function") {
13      for (let key of __getOwnPropNames(from))
14        if (!__hasOwnProp.call(to, key) && key !== except)
15          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
16    }
17    return to;
18  };
19  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
20
21

vendor: 10,237 bytes, lines 21-298

21// node_modules/nprogress/nprogress.js
22  var require_nprogress = __commonJS({
23    "node_modules/nprogress/nprogress.js"(exports, module) {
24      (function(root, factory) {
25        if (typeof define === "function" && define.amd) {
26          define(factory);
27        } else if (typeof exports === "object") {
28          module.exports = factory();
29        } else {
30          root.NProgress = factory();
31        }
32      })(exports, function() {
33        var NProgress2 = {};
34        NProgress2.version = "0.2.0";
35        var Settings = NProgress2.settings = {
36          minimum: 0.08,
37          easing: "ease",
38          positionUsing: "",
39          speed: 200,
40          trickle: true,
41          trickleRate: 0.02,
42          trickleSpeed: 800,
43          showSpinner: true,
44          barSelector: '[role="bar"]',
45          spinnerSelector: '[role="spinner"]',
46          parent: "body",
47          template: '<div class="bar" role="bar"><div class="peg"></div></div><div class="spinner" role="spinner"><div class="spinner-icon"></div></div>'
48        };
49        NProgress2.configure = function(options) {
50          var key, value;
51          for (key in options) {
52            value = options[key];
53            if (value !== void 0 && options.hasOwnProperty(key))
54              Settings[key] = value;
55          }
56          return this;
57        };
58        NProgress2.status = null;
59        NProgress2.set = function(n) {
60          var started2 = NProgress2.isStarted();
61          n = clamp2(n, Settings.minimum, 1);
62          NProgress2.status = n === 1 ? null : n;
63          var progress = NProgress2.render(!started2), bar = progress.querySelector(Settings.barSelector), speed = Settings.speed, ease = Settings.easing;
64          progress.offsetWidth;
65          queue2(function(next) {
66            if (Settings.positionUsing === "")
67              Settings.positionUsing = NProgress2.getPositioningCSS();
68            css(bar, barPositionCSS(n, speed, ease));
69            if (n === 1) {
70              css(progress, {
71                transition: "none",
72                opacity: 1
73              });
74              progress.offsetWidth;
75              setTimeout(function() {
76                css(progress, {
77                  transition: "all " + speed + "ms linear",
78                  opacity: 0
79                });
80                setTimeout(function() {
81                  NProgress2.remove();
82                  next();
83                }, speed);
84              }, speed);
85            } else {
86              setTimeout(next, speed);
87            }
88          });
89          return this;
90        };
91        NProgress2.isStarted = function() {
92          return typeof NProgress2.status === "number";
93        };
94        NProgress2.start = function() {
95          if (!NProgress2.status)
96            NProgress2.set(0);
97          var work = function() {
98            setTimeout(function() {
99              if (!NProgress2.status)
100                return;
101              NProgress2.trickle();
102              work();
103            }, Settings.trickleSpeed);
104          };
105          if (Settings.trickle)
106            work();
107          return this;
108        };
109        NProgress2.done = function(force) {
110          if (!force && !NProgress2.status)
111            return this;
112          return NProgress2.inc(0.3 + 0.5 * Math.random()).set(1);
113        };
114        NProgress2.inc = function(amount) {
115          var n = NProgress2.status;
116          if (!n) {
117            return NProgress2.start();
118          } else {
119            if (typeof amount !== "number") {
120              amount = (1 - n) * clamp2(Math.random() * n, 0.1, 0.95);
121            }
122            n = clamp2(n + amount, 0, 0.994);
123            return NProgress2.set(n);
124          }
125        };
126        NProgress2.trickle = function() {
127          return NProgress2.inc(Math.random() * Settings.trickleRate);
128        };
129        (function() {
130          var initial = 0, current = 0;
131          NProgress2.promise = function($promise) {
132            if (!$promise || $promise.state() === "resolved") {
133              return this;
134            }
135            if (current === 0) {
136              NProgress2.start();
137            }
138            initial++;
139            current++;
140            $promise.always(function() {
141              current--;
142              if (current === 0) {
143                initial = 0;
144                NProgress2.done();
145              } else {
146                NProgress2.set((initial - current) / initial);
147              }
148            });
149            return this;
150          };
151        })();
152        NProgress2.render = function(fromStart) {
153          if (NProgress2.isRendered())
154            return document.getElementById("nprogress");
155          addClass(document.documentElement, "nprogress-busy");
156          var progress = document.createElement("div");
157          progress.id = "nprogress";
158          progress.innerHTML = Settings.template;
159          var bar = progress.querySelector(Settings.barSelector), perc = fromStart ? "-100" : toBarPerc(NProgress2.status || 0), parent = document.querySelector(Settings.parent), spinner;
160          css(bar, {
161            transition: "all 0 linear",
162            transform: "translate3d(" + perc + "%,0,0)"
163          });
164          if (!Settings.showSpinner) {
165            spinner = progress.querySelector(Settings.spinnerSelector);
166            spinner && removeElement(spinner);
167          }
168          if (parent != document.body) {
169            addClass(parent, "nprogress-custom-parent");
170          }
171          parent.appendChild(progress);
172          return progress;
173        };
174        NProgress2.remove = function() {
175          removeClass(document.documentElement, "nprogress-busy");
176          removeClass(document.querySelector(Settings.parent), "nprogress-custom-parent");
177          var progress = document.getElementById("nprogress");
178          progress && removeElement(progress);
179        };
180        NProgress2.isRendered = function() {
181          return !!document.getElementById("nprogress");
182        };
183        NProgress2.getPositioningCSS = function() {
184          var bodyStyle = document.body.style;
185          var vendorPrefix = "WebkitTransform" in bodyStyle ? "Webkit" : "MozTransform" in bodyStyle ? "Moz" : "msTransform" in bodyStyle ? "ms" : "OTransform" in bodyStyle ? "O" : "";
186          if (vendorPrefix + "Perspective" in bodyStyle) {
187            return "translate3d";
188          } else if (vendorPrefix + "Transform" in bodyStyle) {
189            return "translate";
190          } else {
191            return "margin";
192          }
193        };
194        function clamp2(n, min2, max2) {
195          if (n < min2)
196            return min2;
197          if (n > max2)
198            return max2;
199          return n;
200        }
201        function toBarPerc(n) {
202          return (-1 + n) * 100;
203        }
204        function barPositionCSS(n, speed, ease) {
205          var barCSS;
206          if (Settings.positionUsing === "translate3d") {
207            barCSS = { transform: "translate3d(" + toBarPerc(n) + "%,0,0)" };
208          } else if (Settings.positionUsing === "translate") {
209            barCSS = { transform: "translate(" + toBarPerc(n) + "%,0)" };
210          } else {
211            barCSS = { "margin-left": toBarPerc(n) + "%" };
212          }
213          barCSS.transition = "all " + speed + "ms " + ease;
214          return barCSS;
215        }
216        var queue2 = function() {
217          var pending = [];
218          function next() {
219            var fn = pending.shift();
220            if (fn) {
221              fn(next);
222            }
223          }
224          return function(fn) {
225            pending.push(fn);
226            if (pending.length == 1)
227              next();
228          };
229        }();
230        var css = function() {
231          var cssPrefixes = ["Webkit", "O", "Moz", "ms"], cssProps = {};
232          function camelCase3(string) {
233            return string.replace(/^-ms-/, "ms-").replace(/-([\da-z])/gi, function(match, letter) {
234              return letter.toUpperCase();
235            });
236          }
237          function getVendorProp(name) {
238            var style = document.body.style;
239            if (name in style)
240              return name;
241            var i = cssPrefixes.length, capName = name.charAt(0).toUpperCase() + name.slice(1), vendorName;
242            while (i--) {
243              vendorName = cssPrefixes[i] + capName;
244              if (vendorName in style)
245                return vendorName;
246            }
247            return name;
248          }
249          function getStyleProp(name) {
250            name = camelCase3(name);
251            return cssProps[name] || (cssProps[name] = getVendorProp(name));
252          }
253          function applyCss(element, prop, value) {
254            prop = getStyleProp(prop);
255            element.style[prop] = value;
256          }
257          return function(element, properties2) {
258            var args = arguments, prop, value;
259            if (args.length == 2) {
260              for (prop in properties2) {
261                value = properties2[prop];
262                if (value !== void 0 && properties2.hasOwnProperty(prop))
263                  applyCss(element, prop, value);
264              }
265            } else {
266              applyCss(element, args[1], args[2]);
267            }
268          };
269        }();
270        function hasClass(element, name) {
271          var list = typeof element == "string" ? element : classList(element);
272          return list.indexOf(" " + name + " ") >= 0;
273        }
274        function addClass(element, name) {
275          var oldList = classList(element), newList = oldList + name;
276          if (hasClass(oldList, name))
277            return;
278          element.className = newList.substring(1);
279        }
280        function removeClass(element, name) {
281          var oldList = classList(element), newList;
282          if (!hasClass(element, name))
283            return;
284          newList = oldList.replace(" " + name + " ", " ");
285          element.className = newList.substring(1, newList.length - 1);
286        }
287        function classList(element) {
288          return (" " + (element.className || "") + " ").replace(/\s+/gi, " ");
289        }
290        function removeElement(element) {
291          element && element.parentNode && element.parentNode.removeChild(element);
292        }
293        return NProgress2;
294      });
295    }
296  });
297
298

298// js/utils.js
299  var Bag = class {
300    constructor() {
301      this.arrays = {};
302    }
303    add(key, value) {
304      if (!this.arrays[key])
305        this.arrays[key] = [];
306      this.arrays[key].push(value);
307    }
308    remove(key) {
309      if (this.arrays[key])
310        delete this.arrays[key];
311    }
312    get(key) {
313      return this.arrays[key] || [];
314    }
315    each(key, callback) {
316      return this.get(key).forEach(callback);
317    }
318  };
319  var WeakBag = class {
320    constructor() {
321      this.arrays = /* @__PURE__ */ new WeakMap();
322    }
323    add(key, value) {
324      if (!this.arrays.has(key))
325        this.arrays.set(key, []);
326      this.arrays.get(key).push(value);
327    }
328    remove(key) {
329      if (this.arrays.has(key))
330        this.arrays.delete(key, []);
331    }
332    get(key) {
333      return this.arrays.has(key) ? this.arrays.get(key) : [];
334    }
335    each(key, callback) {
336      return this.get(key).forEach(callback);
337    }
338  };
339  function dispatch(target, name, detail = {}, bubbles = true) {
340    target.dispatchEvent(new CustomEvent(name, {
341      detail,
342      bubbles,
343      composed: true,
344      cancelable: true
345    }));
346  }
347  function listen(target, name, handler4) {
348    target.addEventListener(name, handler4);
349    return () => target.removeEventListener(name, handler4);
350  }
351  function isObjecty(subject) {
352    return typeof subject === "object" && subject !== null;
353  }
354  function isObject(subject) {
355    return isObjecty(subject) && !isArray(subject);
356  }
357  function isArray(subject) {
358    return Array.isArray(subject);
359  }
360  function isFunction(subject) {
361    return typeof subject === "function";
362  }
363  function isPrimitive(subject) {
364    return typeof subject !== "object" || subject === null;
365  }
366  function deepClone(obj) {
367    return JSON.parse(JSON.stringify(obj));
368  }
369  function dataGet(object, key) {
370    if (key === "")
371      return object;
372    return key.split(".").reduce((carry, i) => {
373      if (carry === void 0)
374        return void 0;
375      return carry[i];
376    }, object);
377  }
378  function dataSet(object, key, value) {
379    let segments = key.split(".");
380    if (segments.length === 1) {
381      return object[key] = value;
382    }
383    let firstSegment = segments.shift();
384    let restOfSegments = segments.join(".");
385    if (object[firstSegment] === void 0) {
386      object[firstSegment] = {};
387    }
388    dataSet(object[firstSegment], restOfSegments, value);
389  }
390  function diff(left, right, diffs = {}, path = "") {
391    if (left === right)
392      return diffs;
393    if (typeof left !== typeof right || isObject(left) && isArray(right) || isArray(left) && isObject(right)) {
394      diffs[path] = right;
395      return diffs;
396    }
397    if (isPrimitive(left) || isPrimitive(right)) {
398      diffs[path] = right;
399      return diffs;
400    }
401    let leftKeys = Object.keys(left);
402    Object.entries(right).forEach(([key, value]) => {
403      diffs = { ...diffs, ...diff(left[key], right[key], diffs, path === "" ? key : `${path}.${key}`) };
404      leftKeys = leftKeys.filter((i) => i !== key);
405    });
406    leftKeys.forEach((key) => {
407      diffs[`${path}.${key}`] = "__rm__";
408    });
409    return diffs;
410  }
411  function extractData(payload) {
412    let value = isSynthetic(payload) ? payload[0] : payload;
413    let meta = isSynthetic(payload) ? payload[1] : void 0;
414    if (isObjecty(value)) {
415      Object.entries(value).forEach(([key, iValue]) => {
416        value[key] = extractData(iValue);
417      });
418    }
419    return value;
420  }
421  function isSynthetic(subject) {
422    return Array.isArray(subject) && subject.length === 2 && typeof subject[1] === "object" && Object.keys(subject[1]).includes("s");
423  }
424  function getCsrfToken() {
425    if (document.querySelector('meta[name="csrf-token"]')) {
426      return document.querySelector('meta[name="csrf-token"]').getAttribute("content");
427    }
428    if (document.querySelector("[data-csrf]")) {
429      return document.querySelector("[data-csrf]").getAttribute("data-csrf");
430    }
431    if (window.livewireScriptConfig["csrf"] ?? false) {
432      return window.livewireScriptConfig["csrf"];
433    }
434    throw "Livewire: No CSRF token detected";
435  }
436  var nonce;
437  function getNonce() {
438    if (nonce)
439      return nonce;
440    if (window.livewireScriptConfig && (window.livewireScriptConfig["nonce"] ?? false)) {
441      nonce = window.livewireScriptConfig["nonce"];
442      return nonce;
443    }
444    const elWithNonce = document.querySelector("style[data-livewire-style][nonce]");
445    if (elWithNonce) {
446      nonce = elWithNonce.nonce;
447      return nonce;
448    }
449    return null;
450  }
451  function getUpdateUri() {
452    return document.querySelector("[data-update-uri]")?.getAttribute("data-update-uri") ?? window.livewireScriptConfig["uri"] ?? null;
453  }
454  function contentIsFromDump(content) {
455    return !!content.match(/<script>Sfdump\(".+"\)<\/script>/);
456  }
457  function splitDumpFromContent(content) {
458    let dump = content.match(/.*<script>Sfdump\(".+"\)<\/script>/s);
459    return [dump, content.replace(dump, "")];
460  }
461
462

462// js/features/supportFileUploads.js
463  var uploadManagers = /* @__PURE__ */ new WeakMap();
464  function getUploadManager(component) {
465    if (!uploadManagers.has(component)) {
466      let manager = new UploadManager(component);
467      uploadManagers.set(component, manager);
468      manager.registerListeners();
469    }
470    return uploadManagers.get(component);
471  }
472  function handleFileUpload(el, property, component, cleanup2) {
473    let manager = getUploadManager(component);
474    let start3 = () => el.dispatchEvent(new CustomEvent("livewire-upload-start", { bubbles: true, detail: { id: component.id, property } }));
475    let finish = () => el.dispatchEvent(new CustomEvent("livewire-upload-finish", { bubbles: true, detail: { id: component.id, property } }));
476    let error2 = () => el.dispatchEvent(new CustomEvent("livewire-upload-error", { bubbles: true, detail: { id: component.id, property } }));
477    let cancel = () => el.dispatchEvent(new CustomEvent("livewire-upload-cancel", { bubbles: true, detail: { id: component.id, property } }));
478    let progress = (progressEvent) => {
479      var percentCompleted = Math.round(progressEvent.loaded * 100 / progressEvent.total);
480      el.dispatchEvent(new CustomEvent("livewire-upload-progress", {
481        bubbles: true,
482        detail: { progress: percentCompleted }
483      }));
484    };
485    let eventHandler = (e) => {
486      if (e.target.files.length === 0)
487        return;
488      start3();
489      if (e.target.multiple) {
490        manager.uploadMultiple(property, e.target.files, finish, error2, progress, cancel);
491      } else {
492        manager.upload(property, e.target.files[0], finish, error2, progress, cancel);
493      }
494    };
495    el.addEventListener("change", eventHandler);
496    component.$wire.$watch(property, (value) => {
497      if (!el.isConnected)
498        return;
499      if (value === null || value === "") {
500        el.value = "";
501      }
502    });
503    let clearFileInputValue = () => {
504      el.value = null;
505    };
506    el.addEventListener("click", clearFileInputValue);
507    el.addEventListener("livewire-upload-cancel", clearFileInputValue);
508    cleanup2(() => {
509      el.removeEventListener("change", eventHandler);
510      el.removeEventListener("click", clearFileInputValue);
511    });
512  }
513  var UploadManager = class {
514    constructor(component) {
515      this.component = component;
516      this.uploadBag = new MessageBag();
517      this.removeBag = new MessageBag();
518    }
519    registerListeners() {
520      this.component.$wire.$on("upload:generatedSignedUrl", ({ name, url }) => {
521        setUploadLoading(this.component, name);
522        this.handleSignedUrl(name, url);
523      });
524      this.component.$wire.$on("upload:generatedSignedUrlForS3", ({ name, payload }) => {
525        setUploadLoading(this.component, name);
526        this.handleS3PreSignedUrl(name, payload);
527      });
528      this.component.$wire.$on("upload:finished", ({ name, tmpFilenames }) => this.markUploadFinished(name, tmpFilenames));
529      this.component.$wire.$on("upload:errored", ({ name }) => this.markUploadErrored(name));
530      this.component.$wire.$on("upload:removed", ({ name, tmpFilename }) => this.removeBag.shift(name).finishCallback(tmpFilename));
531    }
532    upload(name, file, finishCallback, errorCallback, progressCallback, cancelledCallback) {
533      this.setUpload(name, {
534        files: [file],
535        multiple: false,
536        finishCallback,
537        errorCallback,
538        progressCallback,
539        cancelledCallback
540      });
541    }
542    uploadMultiple(name, files, finishCallback, errorCallback, progressCallback, cancelledCallback) {
543      this.setUpload(name, {
544        files: Array.from(files),
545        multiple: true,
546        finishCallback,
547        errorCallback,
548        progressCallback,
549        cancelledCallback
550      });
551    }
552    removeUpload(name, tmpFilename, finishCallback) {
553      this.removeBag.push(name, {
554        tmpFilename,
555        finishCallback
556      });
557      this.component.$wire.call("_removeUpload", name, tmpFilename);
558    }
559    setUpload(name, uploadObject) {
560      this.uploadBag.add(name, uploadObject);
561      if (this.uploadBag.get(name).length === 1) {
562        this.startUpload(name, uploadObject);
563      }
564    }
565    handleSignedUrl(name, url) {
566      let formData = new FormData();

567      Array.from(this.uploadBag.first(name).files).forEach((file) => formData.append("files[]", file, file.name));
568      let headers = {
569        "Accept": "application/json"
570      };
571      let csrfToken = getCsrfToken();
572      if (csrfToken)
573        headers["X-CSRF-TOKEN"] = csrfToken;
574      this.makeRequest(name, formData, "post", url, headers, (response) => {
575        return response.paths;
576      });
577    }
578    handleS3PreSignedUrl(name, payload) {
579      let formData = this.uploadBag.first(name).files[0];
580      let headers = payload.headers;
581      if ("Host" in headers)
582        delete headers.Host;
583      let url = payload.url;
584      this.makeRequest(name, formData, "put", url, headers, (response) => {
585        return [payload.path];
586      });
587    }
588    makeRequest(name, formData, method, url, headers, retrievePaths) {
589      let request = new XMLHttpRequest();
590      request.open(method, url);
591      Object.entries(headers).forEach(([key, value]) => {
592        request.setRequestHeader(key, value);
593      });
594      request.upload.addEventListener("progress", (e) => {
595        e.detail = {};
596        e.detail.progress = Math.floor(e.loaded * 100 / e.total);
597        this.uploadBag.first(name).progressCallback(e);
598      });
599      request.addEventListener("load", () => {
600        if ((request.status + "")[0] === "2") {
601          let paths = retrievePaths(request.response && JSON.parse(request.response));
602          this.component.$wire.call("_finishUpload", name, paths, this.uploadBag.first(name).multiple);
603          return;
604        }
605        let errors = null;
606        if (request.status === 422) {
607          errors = request.response;
608        }
609        this.component.$wire.call("_uploadErrored", name, errors, this.uploadBag.first(name).multiple);
610      });
611      this.uploadBag.first(name).request = request;
612      request.send(formData);
613    }
614    startUpload(name, uploadObject) {
615      let fileInfos = uploadObject.files.map((file) => {
616        return { name: file.name, size: file.size, type: file.type };
617      });
618      this.component.$wire.call("_startUpload", name, fileInfos, uploadObject.multiple);
619      setUploadLoading(this.component, name);
620    }
621    markUploadFinished(name, tmpFilenames) {
622      unsetUploadLoading(this.component);
623      let uploadObject = this.uploadBag.shift(name);
624      uploadObject.finishCallback(uploadObject.multiple ? tmpFilenames : tmpFilenames[0]);
625      if (this.uploadBag.get(name).length > 0)
626        this.startUpload(name, this.uploadBag.last(name));
627    }
628    markUploadErrored(name) {
629      unsetUploadLoading(this.component);
630      this.uploadBag.shift(name).errorCallback();
631      if (this.uploadBag.get(name).length > 0)
632        this.startUpload(name, this.uploadBag.last(name));
633    }
634    cancelUpload(name, cancelledCallback = null) {
635      unsetUploadLoading(this.component);
636      let uploadItem = this.uploadBag.first(name);
637      if (uploadItem) {
638        uploadItem.request.abort();
639        this.uploadBag.shift(name).cancelledCallback();
640        if (cancelledCallback)
641          cancelledCallback();
642      }
643    }
644  };
645  var MessageBag = class {
646    constructor() {
647      this.bag = {};
648    }
649    add(name, thing) {
650      if (!this.bag[name]) {
651        this.bag[name] = [];
652      }
653      this.bag[name].push(thing);
654    }
655    push(name, thing) {
656      this.add(name, thing);
657    }
658    first(name) {
659      if (!this.bag[name])
660        return null;
661      return this.bag[name][0];
662    }
663    last(name) {
664      return this.bag[name].slice(-1)[0];
665    }
666    get(name) {
667      return this.bag[name];
668    }
669    shift(name) {
670      return this.bag[name].shift();
671    }
672    call(name, ...params) {
673      (this.listeners[name] || []).forEach((callback) => {
674        callback(...params);
675      });
676    }
677    has(name) {
678      return Object.keys(this.listeners).includes(name);
679    }
680  };
681  function setUploadLoading() {
682  }
683  function unsetUploadLoading() {
684  }
685  function upload(component, name, file, finishCallback = () => {
686  }, errorCallback = () => {
687  }, progressCallback = () => {
688  }, cancelledCallback = () => {
689  }) {
690    let uploadManager = getUploadManager(component);
691    uploadManager.upload(name, file, finishCallback, errorCallback, progressCallback, cancelledCallback);
692  }
693  function uploadMultiple(component, name, files, finishCallback = () => {
694  }, errorCallback = () => {
695  }, progressCallback = () => {
696  }, cancelledCallback = () => {
697  }) {
698    let uploadManager = getUploadManager(component);
699    uploadManager.uploadMultiple(name, files, finishCallback, errorCallback, progressCallback, cancelledCallback);
700  }
701  function removeUpload(component, name, tmpFilename, finishCallback = () => {
702  }, errorCallback = () => {
703  }) {
704    let uploadManager = getUploadManager(component);
705    uploadManager.removeUpload(name, tmpFilename, finishCallback, errorCallback);
706  }
707  function cancelUpload(component, name, cancelledCallback = () => {
708  }) {
709    let uploadManager = getUploadManager(component);
710    uploadManager.cancelUpload(name, cancelledCallback);
711  }
712
713

713// ../alpine/packages/alpinejs/dist/module.esm.js
714  var flushPending = false;
715  var flushing = false;
716  var queue = [];
717  var lastFlushedIndex = -1;
718  function scheduler(callback) {
719    queueJob(callback);
720  }
721  function queueJob(job) {
722    if (!queue.includes(job))
723      queue.push(job);
724    queueFlush();
725  }
726  function dequeueJob(job) {
727    let index = queue.indexOf(job);
728    if (index !== -1 && index > lastFlushedIndex)
729      queue.splice(index, 1);
730  }
731  function queueFlush() {
732    if (!flushing && !flushPending) {
733      flushPending = true;
734      queueMicrotask(flushJobs);
735    }
736  }
737  function flushJobs() {
738    flushPending = false;
739    flushing = true;
740    for (let i = 0; i < queue.length; i++) {
741      queue[i]();
742      lastFlushedIndex = i;
743    }
744    queue.length = 0;
745    lastFlushedIndex = -1;
746    flushing = false;
747  }
748  var reactive;
749  var effect;
750  var release;
751  var raw;
752  var shouldSchedule = true;
753  function disableEffectScheduling(callback) {
754    shouldSchedule = false;
755    callback();
756    shouldSchedule = true;
757  }
758  function setReactivityEngine(engine) {
759    reactive = engine.reactive;
760    release = engine.release;
761    effect = (callback) => engine.effect(callback, { scheduler: (task) => {
762      if (shouldSchedule) {
763        scheduler(task);
764      } else {
765        task();
766      }
767    } });
768    raw = engine.raw;
769  }
770  function overrideEffect(override) {
771    effect = override;
772  }
773  function elementBoundEffect(el) {
774    let cleanup2 = () => {
775    };
776    let wrappedEffect = (callback) => {
777      let effectReference = effect(callback);
778      if (!el._x_effects) {
779        el._x_effects = /* @__PURE__ */ new Set();
780        el._x_runEffects = () => {
781          el._x_effects.forEach((i) => i());
782        };
783      }
784      el._x_effects.add(effectReference);
785      cleanup2 = () => {
786        if (effectReference === void 0)
787          return;
788        el._x_effects.delete(effectReference);
789        release(effectReference);
790      };
791      return effectReference;
792    };
793    return [wrappedEffect, () => {
794      cleanup2();
795    }];
796  }
797  function watch(getter, callback) {
798    let firstTime = true;
799    let oldValue;
800    let effectReference = effect(() => {
801      let value = getter();
802      JSON.stringify(value);
803      if (!firstTime) {
804        queueMicrotask(() => {
805          callback(value, oldValue);
806          oldValue = value;
807        });
808      } else {
809        oldValue = value;
810      }
811      firstTime = false;
812    });
813    return () => release(effectReference);
814  }
815  var onAttributeAddeds = [];
816  var onElRemoveds = [];
817  var onElAddeds = [];
818  function onElAdded(callback) {
819    onElAddeds.push(callback);
820  }
821  function onElRemoved(el, callback) {
822    if (typeof callback === "function") {
823      if (!el._x_cleanups)
824        el._x_cleanups = [];
825      el._x_cleanups.push(callback);
826    } else {
827      callback = el;
828      onElRemoveds.push(callback);
829    }
830  }
831  function onAttributesAdded(callback) {
832    onAttributeAddeds.push(callback);
833  }
834  function onAttributeRemoved(el, name, callback) {
835    if (!el._x_attributeCleanups)
836      el._x_attributeCleanups = {};
837    if (!el._x_attributeCleanups[name])
838      el._x_attributeCleanups[name] = [];
839    el._x_attributeCleanups[name].push(callback);
840  }
841  function cleanupAttributes(el, names) {
842    if (!el._x_attributeCleanups)
843      return;
844    Object.entries(el._x_attributeCleanups).forEach(([name, value]) => {
845      if (names === void 0 || names.includes(name)) {
846        value.forEach((i) => i());
847        delete el._x_attributeCleanups[name];
848      }
849    });
850  }
851  function cleanupElement(el) {
852    if (el._x_cleanups) {
853      while (el._x_cleanups.length)
854        el._x_cleanups.pop()();
855    }
856  }
857  var observer = new MutationObserver(onMutate);
858  var currentlyObserving = false;
859  function startObservingMutations() {
860    observer.observe(document, { subtree: true, childList: true, attributes: true, attributeOldValue: true });
861    currentlyObserving = true;
862  }
863  function stopObservingMutations() {
864    flushObserver();
865    observer.disconnect();
866    currentlyObserving = false;
867  }
868  var queuedMutations = [];
869  function flushObserver() {
870    let records = observer.takeRecords();
871    queuedMutations.push(() => records.length > 0 && onMutate(records));
872    let queueLengthWhenTriggered = queuedMutations.length;
873    queueMicrotask(() => {
874      if (queuedMutations.length === queueLengthWhenTriggered) {
875        while (queuedMutations.length > 0)
876          queuedMutations.shift()();
877      }
878    });
879  }
880  function mutateDom(callback) {
881    if (!currentlyObserving)
882      return callback();
883    stopObservingMutations();
884    let result = callback();
885    startObservingMutations();
886    return result;
887  }
888  var isCollecting = false;

889  var deferredMutations = [];
890  function deferMutations() {
891    isCollecting = true;
892  }
893  function flushAndStopDeferringMutations() {
894    isCollecting = false;
895    onMutate(deferredMutations);
896    deferredMutations = [];
897  }
898  function onMutate(mutations) {
899    if (isCollecting) {
900      deferredMutations = deferredMutations.concat(mutations);
901      return;
902    }
903    let addedNodes = /* @__PURE__ */ new Set();
904    let removedNodes = /* @__PURE__ */ new Set();
905    let addedAttributes = /* @__PURE__ */ new Map();
906    let removedAttributes = /* @__PURE__ */ new Map();
907    for (let i = 0; i < mutations.length; i++) {
908      if (mutations[i].target._x_ignoreMutationObserver)
909        continue;
910      if (mutations[i].type === "childList") {
911        mutations[i].addedNodes.forEach((node) => node.nodeType === 1 && addedNodes.add(node));
912        mutations[i].removedNodes.forEach((node) => node.nodeType === 1 && removedNodes.add(node));
913      }
914      if (mutations[i].type === "attributes") {
915        let el = mutations[i].target;
916        let name = mutations[i].attributeName;
917        let oldValue = mutations[i].oldValue;
918        let add2 = () => {
919          if (!addedAttributes.has(el))
920            addedAttributes.set(el, []);
921          addedAttributes.get(el).push({ name, value: el.getAttribute(name) });
922        };
923        let remove = () => {
924          if (!removedAttributes.has(el))
925            removedAttributes.set(el, []);
926          removedAttributes.get(el).push(name);
927        };
928        if (el.hasAttribute(name) && oldValue === null) {
929          add2();
930        } else if (el.hasAttribute(name)) {
931          remove();
932          add2();
933        } else {
934          remove();
935        }
936      }
937    }
938    removedAttributes.forEach((attrs, el) => {
939      cleanupAttributes(el, attrs);
940    });
941    addedAttributes.forEach((attrs, el) => {
942      onAttributeAddeds.forEach((i) => i(el, attrs));
943    });
944    for (let node of removedNodes) {
945      if (addedNodes.has(node))
946        continue;
947      onElRemoveds.forEach((i) => i(node));
948    }
949    addedNodes.forEach((node) => {
950      node._x_ignoreSelf = true;
951      node._x_ignore = true;
952    });
953    for (let node of addedNodes) {
954      if (removedNodes.has(node))
955        continue;
956      if (!node.isConnected)
957        continue;
958      delete node._x_ignoreSelf;
959      delete node._x_ignore;
960      onElAddeds.forEach((i) => i(node));
961      node._x_ignore = true;
962      node._x_ignoreSelf = true;
963    }
964    addedNodes.forEach((node) => {
965      delete node._x_ignoreSelf;
966      delete node._x_ignore;
967    });
968    addedNodes = null;
969    removedNodes = null;
970    addedAttributes = null;
971    removedAttributes = null;
972  }
973  function scope(node) {
974    return mergeProxies(closestDataStack(node));
975  }
976  function addScopeToNode(node, data2, referenceNode) {
977    node._x_dataStack = [data2, ...closestDataStack(referenceNode || node)];
978    return () => {
979      node._x_dataStack = node._x_dataStack.filter((i) => i !== data2);
980    };
981  }
982  function closestDataStack(node) {
983    if (node._x_dataStack)
984      return node._x_dataStack;
985    if (typeof ShadowRoot === "function" && node instanceof ShadowRoot) {
986      return closestDataStack(node.host);
987    }
988    if (!node.parentNode) {
989      return [];
990    }
991    return closestDataStack(node.parentNode);
992  }
993  function mergeProxies(objects) {
994    return new Proxy({ objects }, mergeProxyTrap);
995  }
996  var mergeProxyTrap = {
997    ownKeys({ objects }) {
998      return Array.from(new Set(objects.flatMap((i) => Object.keys(i))));
999    },
1000    has({ objects }, name) {
1001      if (name == Symbol.unscopables)
1002        return false;
1003      return objects.some((obj) => Object.prototype.hasOwnProperty.call(obj, name) || Reflect.has(obj, name));
1004    },
1005    get({ objects }, name, thisProxy) {
1006      if (name == "toJSON")
1007        return collapseProxies;
1008      return Reflect.get(objects.find((obj) => Reflect.has(obj, name)) || {}, name, thisProxy);
1009    },
1010    set({ objects }, name, value, thisProxy) {
1011      const target = objects.find((obj) => Object.prototype.hasOwnProperty.call(obj, name)) || objects[objects.length - 1];
1012      const descriptor = Object.getOwnPropertyDescriptor(target, name);
1013      if (descriptor?.set && descriptor?.get)
1014        return Reflect.set(target, name, value, thisProxy);
1015      return Reflect.set(target, name, value);
1016    }
1017  };
1018  function collapseProxies() {
1019    let keys = Reflect.ownKeys(this);
1020    return keys.reduce((acc, key) => {
1021      acc[key] = Reflect.get(this, key);
1022      return acc;
1023    }, {});
1024  }
1025  function initInterceptors(data2) {
1026    let isObject22 = (val) => typeof val === "object" && !Array.isArray(val) && val !== null;
1027    let recurse = (obj, basePath = "") => {
1028      Object.entries(Object.getOwnPropertyDescriptors(obj)).forEac

1028h(([key, { value, enumerable }]) => {
1029        if (enumerable === false || value === void 0)
1030          return;
1031        if (typeof value === "object" && value !== null && value.__v_skip)
1032          return;
1033        let path = basePath === "" ? key : `${basePath}.${key}`;
1034        if (typeof value === "object" && value !== null && value._x_interceptor) {
1035          obj[key] = value.initialize(data2, path, key);
1036        } else {
1037          if (isObject22(value) && value !== obj && !(value instanceof Element)) {
1038            recurse(value, path);
1039          }
1040        }
1041      });
1042    };
1043    return recurse(data2);
1044  }
1045  function interceptor(callback, mutateObj = () => {
1046  }) {
1047    let obj = {
1048      initialValue: void 0,
1049      _x_interceptor: true,
1050      initialize(data2, path, key) {
1051        return callback(this.initialValue, () => get(data2, path), (value) => set(data2, path, value), path, key);
1052      }
1053    };
1054    mutateObj(obj);
1055    return (initialValue) => {
1056      if (typeof initialValue === "object" && initialValue !== null && initialValue._x_interceptor) {
1057        let initialize = obj.initialize.bind(obj);
1058        obj.initialize = (data2, path, key) => {
1059          let innerValue = initialValue.initialize(data2, path, key);
1060          obj.initialValue = innerValue;
1061          return initialize(data2, path, key);
1062        };
1063      } else {
1064        obj.initialValue = initialValue;
1065      }
1066      return obj;
1067    };
1068  }
1069  function get(obj, path) {
1070    return path.split(".").reduce((carry, segment) => carry[segment], obj);
1071  }
1072  function set(obj, path, value) {
1073    if (typeof path === "string")
1074      path = path.split(".");
1075    if (path.length === 1)
1076      obj[path[0]] = value;
1077    else if (path.length === 0)
1078      throw error;
1079    else {
1080      if (obj[path[0]])
1081        return set(obj[path[0]], path.slice(1), value);
1082      else {
1083        obj[path[0]] = {};
1084        return set(obj[path[0]], path.slice(1), value);
1085      }
1086    }
1087  }
1088  var magics = {};
1089  function magic(name, callback) {
1090    magics[name] = callback;
1091  }
1092  function injectMagics(obj, el) {
1093    Object.entries(magics).forEach(([name, callback]) => {
1094      let memoizedUtilities = null;
1095      function getUtilities() {
1096        if (memoizedUtilities) {
1097          return memoizedUtilities;
1098        } else {
1099          let [utilities, cleanup2] = getElementBoundUtilities(el);
1100          memoizedUtilities = { interceptor, ...utilities };
1101          onElRemoved(el, cleanup2);
1102          return memoizedUtilities;
1103        }
1104      }
1105      Object.defineProperty(obj, `$${name}`, {
1106        get() {
1107          return callback(el, getUtilities());
1108        },
1109        enumerable: false
1110      });
1111    });
1112    return obj;
1113  }
1114  function tryCatch(el, expression, callback, ...args) {
1115    try {
1116      return callback(...args);
1117    } catch (e) {
1118      handleError(e, el, expression);
1119    }
1120  }
1121  function handleError(error2, el, expression = void 0) {
1122    error2 = Object.assign(error2 ?? { message: "No error message given." }, { el, expression });
1123    console.warn(`Alpine Expression Error: ${error2.message}
1124
1125${expression ? 'Expression: "' + expression + '"\n\n' : ""}`, el);
1126    setTimeout(() => {
1127      throw error2;
1128    }, 0);
1129  }
1130  var shouldAutoEvaluateFunctions = true;
1131  function dontAutoEvaluateFunctions(callback) {

vendor: 27,772 bytes, lines 1132-1945

1132    let cache = shouldAutoEvaluateFunctions;
1133    shouldAutoEvaluateFunctions = false;
1134    let result = callback();
1135    shouldAutoEvaluateFunctions = cache;
1136    return result;
1137  }
1138  function evaluate(el, expression, extras = {}) {
1139    let result;
1140    evaluateLater(el, expression)((value) => result = value, extras);
1141    return result;
1142  }
1143  function evaluateLater(...args) {
1144    return theEvaluatorFunction(...args);
1145  }
1146  var theEvaluatorFunction = normalEvaluator;
1147  function setEvaluator(newEvaluator) {
1148    theEvaluatorFunction = newEvaluator;
1149  }
1150  function normalEvaluator(el, expression) {
1151    let overriddenMagics = {};
1152    injectMagics(overriddenMagics, el);
1153    let dataStack = [overriddenMagics, ...closestDataStack(el)];
1154    let evaluator = typeof expression === "function" ? generateEvaluatorFromFunction(dataStack, expression) : generateEvaluatorFromString(dataStack, expression, el);
1155    return tryCatch.bind(null, el, expression, evaluator);
1156  }
1157  function generateEvaluatorFromFunction(dataStack, func) {
1158    return (receiver = () => {
1159    }, { scope: scope2 = {}, params = [] } = {}) => {
1160      let result = func.apply(mergeProxies([scope2, ...dataStack]), params);
1161      runIfTypeOfFunction(receiver, result);
1162    };
1163  }
1164  var evaluatorMemo = {};
1165  function generateFunctionFromString(expression, el) {
1166    if (evaluatorMemo[expression]) {
1167      return evaluatorMemo[expression];
1168    }
1169    let AsyncFunction = Object.getPrototypeOf(async function() {
1170    }).constructor;
1171    let rightSideSafeExpression = /^[\n\s]*if.*\(.*\)/.test(expression.trim()) || /^(let|const)\s/.test(expression.trim()) ? `(async()=>{ ${expression} })()` : expression;
1172    const safeAsyncFunction = () => {
1173      try {
1174        let func2 = new AsyncFunction(["__self", "scope"], `with (scope) { __self.result = ${rightSideSafeExpression} }; __self.finished = true; return __self.result;`);
1175        Object.defineProperty(func2, "name", {
1176          value: `[Alpine] ${expression}`
1177        });
1178        return func2;
1179      } catch (error2) {
1180        handleError(error2, el, expression);
1181        return Promise.resolve();
1182      }
1183    };
1184    let func = safeAsyncFunction();
1185    evaluatorMemo[expression] = func;
1186    return func;
1187  }
1188  function generateEvaluatorFromString(dataStack, expression, el) {
1189    let func = generateFunctionFromString(expression, el);
1190    return (receiver = () => {
1191    }, { scope: scope2 = {}, params = [] } = {}) => {
1192      func.result = void 0;
1193      func.finished = false;
1194      let completeScope = mergeProxies([scope2, ...dataStack]);
1195      if (typeof func === "function") {
1196        let promise = func(func, completeScope).catch((error2) => handleError(error2, el, expression));
1197        if (func.finished) {
1198          runIfTypeOfFunction(receiver, func.result, completeScope, params, el);
1199          func.result = void 0;
1200        } else {
1201          promise.then((result) => {
1202            runIfTypeOfFunction(receiver, result, completeScope, params, el);
1203          }).catch((error2) => handleError(error2, el, expression)).finally(() => func.result = void 0);
1204        }
1205      }
1206    };
1207  }
1208  function runIfTypeOfFunction(receiver, value, scope2, params, el) {
1209    if (shouldAutoEvaluateFunctions && typeof value === "function") {
1210      let result = value.apply(scope2, params);
1211      if (result instanceof Promise) {
1212        result.then((i) => runIfTypeOfFunction(receiver, i, scope2, params)).catch((error2) => handleError(error2, el, value));
1213      } else {
1214        receiver(result);
1215      }
1216    } else if (typeof value === "object" && value instanceof Promise) {
1217      value.then((i) => receiver(i));
1218    } else {
1219      receiver(value);
1220    }
1221  }
1222  var prefixAsString = "x-";
1223  function prefix(subject = "") {
1224    return prefixAsString + subject;
1225  }
1226  function setPrefix(newPrefix) {
1227    prefixAsString = newPrefix;
1228  }
1229  var directiveHandlers = {};
1230  function directive(name, callback) {
1231    directiveHandlers[name] = callback;
1232    return {
1233      before(directive22) {
1234        if (!directiveHandlers[directive22]) {
1235          console.warn(String.raw`Cannot find directive \`${directive22}\`. \`${name}\` will use the default order of execution`);
1236          return;
1237        }
1238        const pos = directiveOrder.indexOf(directive22);
1239        directiveOrder.splice(pos >= 0 ? pos : directiveOrder.indexOf("DEFAULT"), 0, name);
1240      }
1241    };
1242  }
1243  function directiveExists(name) {
1244    return Object.keys(directiveHandlers).includes(name);
1245  }
1246  function directives(el, attributes, originalAttributeOverride) {
1247    attributes = Array.from(attributes);
1248    if (el._x_virtualDirectives) {
1249      let vAttributes = Object.entries(el._x_virtualDirectives).map(([name, value]) => ({ name, value }));
1250      let staticAttributes = attributesOnly(vAttributes);
1251      vAttributes = vAttributes.map((attribute) => {
1252        if (staticAttributes.find((attr) => attr.name === attribute.name)) {
1253          return {
1254            name: `x-bind:${attribute.name}`,
1255            value: `"${attribute.value}"`
1256          };
1257        }
1258        return attribute;
1259      });
1260      attributes = attributes.concat(vAttributes);
1261    }
1262    let transformedAttributeMap = {};
1263    let directives2 = attributes.map(toTransformedAttributes((newName, oldName) => transformedAttributeMap[newName] = oldName)).filter(outNonAlpineAttributes).map(toParsedDirectives(transformedAttributeMap, originalAttributeOverride)).sort(byPriority);
1264    return directives2.map((directive22) => {
1265      return getDirectiveHandler(el, directive22);
1266    });
1267  }
1268  function attributesOnly(attributes) {
1269    return Array.from(attributes).map(toTransformedAttributes()).filter((attr) => !outNonAlpineAttributes(attr));
1270  }
1271  var isDeferringHandlers = false;
1272  var directiveHandlerStacks = /* @__PURE__ */ new Map();
1273  var currentHandlerStackKey = Symbol();
1274  function deferHandlingDirectives(callback) {
1275    isDeferringHandlers = true;
1276    let key = Symbol();
1277    currentHandlerStackKey = key;
1278    directiveHandlerStacks.set(key, []);
1279    let flushHandlers = () => {
1280      while (directiveHandlerStacks.get(key).length)
1281        directiveHandlerStacks.get(key).shift()();
1282      directiveHandlerStacks.delete(key);
1283    };
1284    let stopDeferring = () => {
1285      isDeferringHandlers = false;
1286      flushHandlers();
1287    };
1288    callback(flushHandlers);
1289    stopDeferring();
1290  }
1291  function getElementBoundUtilities(el) {
1292    let cleanups2 = [];
1293    let cleanup2 = (callback) => cleanups2.push(callback);
1294    let [effect3, cleanupEffect] = elementBoundEffect(el);
1295    cleanups2.push(cleanupEffect);
1296    let utilities = {
1297      Alpine: alpine_default,
1298      effect: effect3,
1299      cleanup: cleanup2,
1300      evaluateLater: evaluateLater.bind(evaluateLater, el),
1301      evaluate: evaluate.bind(evaluate, el)
1302    };
1303    let doCleanup = () => cleanups2.forEach((i) => i());
1304    return [utilities, doCleanup];
1305  }
1306  function getDirectiveHandler(el, directive22) {
1307    let noop = () => {
1308    };
1309    let handler4 = directiveHandlers[directive22.type] || noop;
1310    let [utilities, cleanup2] = getElementBoundUtilities(el);
1311    onAttributeRemoved(el, directive22.original, cleanup2);
1312    let fullHandler = () => {
1313      if (el._x_ignore || el._x_ignoreSelf)
1314        return;
1315      handler4.inline && handler4.inline(el, directive22, utilities);
1316      handler4 = handler4.bind(handler4, el, directive22, utilities);
1317      isDeferringHandlers ? directiveHandlerStacks.get(currentHandlerStackKey).push(handler4) : handler4();
1318    };
1319    fullHandler.runCleanups = cleanup2;
1320    return fullHandler;
1321  }
1322  var startingWith = (subject, replacement) => ({ name, value }) => {
1323    if (name.startsWith(subject))
1324      name = name.replace(subject, replacement);
1325    return { name, value };
1326  };
1327  var into = (i) => i;
1328  function toTransformedAttributes(callback = () => {
1329  }) {
1330    return ({ name, value }) => {
1331      let { name: newName, value: newValue } = attributeTransformers.reduce((carry, transform) => {
1332        return transform(carry);
1333      }, { name, value });
1334      if (newName !== name)
1335        callback(newName, name);
1336      return { name: newName, value: newValue };
1337    };
1338  }
1339  var attributeTransformers = [];
1340  function mapAttributes(callback) {
1341    attributeTransformers.push(callback);
1342  }
1343  function outNonAlpineAttributes({ name }) {
1344    return alpineAttributeRegex().test(name);
1345  }
1346  var alpineAttributeRegex = () => new RegExp(`^${prefixAsString}([^:^.]+)\\b`);
1347  function toParsedDirectives(transformedAttributeMap, originalAttributeOverride) {
1348    return ({ name, value }) => {
1349      let typeMatch = name.match(alpineAttributeRegex());
1350      let valueMatch = name.match(/:([a-zA-Z0-9\-_:]+)/);
1351      let modifiers = name.match(/\.[^.\]]+(?=[^\]]*$)/g) || [];
1352      let original = originalAttributeOverride || transformedAttributeMap[name] || name;
1353      return {
1354        type: typeMatch ? typeMatch[1] : null,
1355        value: valueMatch ? valueMatch[1] : null,
1356        modifiers: modifiers.map((i) => i.replace(".", "")),
1357        expression: value,
1358        original
1359      };
1360    };
1361  }
1362  var DEFAULT = "DEFAULT";
1363  var directiveOrder = [
1364    "ignore",
1365    "ref",
1366    "data",
1367    "id",
1368    "anchor",
1369    "bind",
1370    "init",
1371    "for",
1372    "model",
1373    "modelable",
1374    "transition",
1375    "show",
1376    "if",
1377    DEFAULT,
1378    "teleport"
1379  ];
1380  function byPriority(a, b) {
1381    let typeA = directiveOrder.indexOf(a.type) === -1 ? DEFAULT : a.type;
1382    let typeB = directiveOrder.indexOf(b.type) === -1 ? DEFAULT : b.type;
1383    return directiveOrder.indexOf(typeA) - directiveOrder.indexOf(typeB);
1384  }
1385  function dispatch2(el, name, detail = {}) {
1386    el.dispatchEvent(new CustomEvent(name, {
1387      detail,
1388      bubbles: true,
1389      composed: true,
1390      cancelable: true
1391    }));
1392  }
1393  function walk(el, callback) {
1394    if (typeof ShadowRoot === "function" && el instanceof ShadowRoot) {
1395      Array.from(el.children).forEach((el2) => walk(el2, callback));
1396      return;
1397    }
1398    let skip = false;
1399    callback(el, () => skip = true);
1400    if (skip)
1401      return;
1402    let node = el.firstElementChild;
1403    while (node) {
1404      walk(node, callback, false);
1405      node = node.nextElementSibling;
1406    }
1407  }
1408  function warn(message, ...args) {
1409    console.warn(`Alpine Warning: ${message}`, ...args);
1410  }
1411  var started = false;
1412  function start() {
1413    if (started)
1414      warn("Alpine has already been initialized on this page. Calling Alpine.start() more than once can cause problems.");
1415    started = true;
1416    if (!document.body)
1417      warn("Unable to initialize. Trying to load Alpine before `<body>` is available. Did you forget to add `defer` in Alpine's `<script>` tag?");
1418    dispatch2(document, "alpine:init");
1419    dispatch2(document, "alpine:initializing");
1420    startObservingMutations();
1421    onElAdded((el) => initTree(el, walk));
1422    onElRemoved((el) => destroyTree(el));
1423    onAttributesAdded((el, attrs) => {
1424      directives(el, attrs).forEach((handle) => handle());
1425    });
1426    let outNestedComponents = (el) => !closestRoot(el.parentElement, true);
1427    Array.from(document.querySelectorAll(allSelectors().join(","))).filter(outNestedComponents).forEach((el) => {
1428      initTree(el);
1429    });
1430    dispatch2(document, "alpine:initialized");
1431    setTimeout(() => {
1432      warnAboutMissingPlugins();
1433    });
1434  }
1435  var rootSelectorCallbacks = [];
1436  var initSelectorCallbacks = [];
1437  function rootSelectors() {
1438    return rootSelectorCallbacks.map((fn) => fn());
1439  }
1440  function allSelectors() {
1441    return rootSelectorCallbacks.concat(initSelectorCallbacks).map((fn) => fn());
1442  }
1443  function addRootSelector(selectorCallback) {
1444    rootSelectorCallbacks.push(selectorCallback);
1445  }
1446  function addInitSelector(selectorCallback) {
1447    initSelectorCallbacks.push(selectorCallback);
1448  }
1449  function closestRoot(el, includeInitSelectors = false) {
1450    return findClosest(el, (element) => {
1451      const selectors = includeInitSelectors ? allSelectors() : rootSelectors();
1452      if (selectors.some((selector) => element.matches(selector)))
1453        return true;
1454    });
1455  }
1456  function findClosest(el, callback) {
1457    if (!el)
1458      return;
1459    if (callback(el))
1460      return el;
1461    if (el._x_teleportBack)
1462      el = el._x_teleportBack;
1463    if (!el.parentElement)
1464      return;
1465    return findClosest(el.parentElement, callback);
1466  }
1467  function isRoot(el) {
1468    return rootSelectors().some((selector) => el.matches(selector));
1469  }
1470  var initInterceptors2 = [];
1471  function interceptInit(callback) {
1472    initInterceptors2.push(callback);
1473  }
1474  function initTree(el, walker = walk, intercept = () => {
1475  }) {
1476    deferHandlingDirectives(() => {
1477      walker(el, (el2, skip) => {
1478        intercept(el2, skip);
1479        initInterceptors2.forEach((i) => i(el2, skip));
1480        directives(el2, el2.attributes).forEach((handle) => handle());
1481        el2._x_ignore && skip();
1482      });
1483    });
1484  }
1485  function destroyTree(root, walker = walk) {
1486    walker(root, (el) => {
1487      cleanupAttributes(el);
1488      cleanupElement(el);
1489    });
1490  }
1491  function warnAboutMissingPlugins() {
1492    let pluginDirectives = [
1493      ["ui", "dialog", ["[x-dialog], [x-popover]"]],
1494      ["anchor", "anchor", ["[x-anchor]"]],
1495      ["sort", "sort", ["[x-sort]"]]
1496    ];
1497    pluginDirectives.forEach(([plugin2, directive22, selectors]) => {
1498      if (directiveExists(directive22))
1499        return;
1500      selectors.some((selector) => {
1501        if (document.querySelector(selector)) {
1502          warn(`found "${selector}", but missing ${plugin2} plugin`);
1503          return true;
1504        }
1505      });
1506    });
1507  }
1508  var tickStack = [];
1509  var isHolding = false;
1510  function nextTick(callback = () => {
1511  }) {
1512    queueMicrotask(() => {
1513      isHolding || setTimeout(() => {
1514        releaseNextTicks();
1515      });
1516    });
1517    return new Promise((res) => {
1518      tickStack.push(() => {
1519        callback();
1520        res();
1521      });
1522    });
1523  }
1524  function releaseNextTicks() {
1525    isHolding = false;
1526    while (tickStack.length)
1527      tickStack.shift()();
1528  }
1529  function holdNextTicks() {
1530    isHolding = true;
1531  }
1532  function setClasses(el, value) {
1533    if (Array.isArray(value)) {
1534      return setClassesFromString(el, value.join(" "));
1535    } else if (typeof value === "object" && value !== null) {
1536      return setClassesFromObject(el, value);
1537    } else if (typeof value === "function") {
1538      return setClasses(el, value());
1539    }
1540    return setClassesFromString(el, value);
1541  }
1542  function setClassesFromString(el, classString) {
1543    let split = (classString2) => classString2.split(" ").filter(Boolean);
1544    let missingClasses = (classString2) => classString2.split(" ").filter((i) => !el.classList.contains(i)).filter(Boolean);
1545    let addClassesAndReturnUndo = (classes) => {
1546      el.classList.add(...classes);
1547      return () => {
1548        el.classList.remove(...classes);
1549      };
1550    };
1551    classString = classString === true ? classString = "" : classString || "";
1552    return addClassesAndReturnUndo(missingClasses(classString));
1553  }
1554  function setClassesFromObject(el, classObject) {
1555    let split = (classString) => classString.split(" ").filter(Boolean);
1556    let forAdd = Object.entries(classObject).flatMap(([classString, bool]) => bool ? split(classString) : false).filter(Boolean);
1557    let forRemove = Object.entries(classObject).flatMap(([classString, bool]) => !bool ? split(classString) : false).filter(Boolean);
1558    let added = [];
1559    let removed = [];
1560    forRemove.forEach((i) => {
1561      if (el.classList.contains(i)) {
1562        el.classList.remove(i);
1563        removed.push(i);
1564      }
1565    });
1566    forAdd.forEach((i) => {
1567      if (!el.classList.contains(i)) {
1568        el.classList.add(i);
1569        added.push(i);
1570      }
1571    });
1572    return () => {
1573      removed.forEach((i) => el.classList.add(i));
1574      added.forEach((i) => el.classList.remove(i));
1575    };
1576  }
1577  function setStyles(el, value) {
1578    if (typeof value === "object" && value !== null) {
1579      return setStylesFromObject(el, value);
1580    }
1581    return setStylesFromString(el, value);
1582  }
1583  function setStylesFromObject(el, value) {
1584    let previousStyles = {};
1585    Object.entries(value).forEach(([key, value2]) => {
1586      previousStyles[key] = el.style[key];
1587      if (!key.startsWith("--")) {
1588        key = kebabCase(key);
1589      }
1590      el.style.setProperty(key, value2);
1591    });
1592    setTimeout(() => {
1593      if (el.style.length === 0) {
1594        el.removeAttribute("style");
1595      }
1596    });
1597    return () => {
1598      setStyles(el, previousStyles);
1599    };
1600  }
1601  function setStylesFromString(el, value) {
1602    let cache = el.getAttribute("style", value);
1603    el.setAttribute("style", value);
1604    return () => {
1605      el.setAttribute("style", cache || "");
1606    };
1607  }
1608  function kebabCase(subject) {
1609    return subject.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
1610  }
1611  function once(callback, fallback2 = () => {
1612  }) {
1613    let called = false;
1614    return function() {
1615      if (!called) {
1616        called = true;
1617        callback.apply(this, arguments);
1618      } else {
1619        fallback2.apply(this, arguments);
1620      }
1621    };
1622  }
1623  directive("transition", (el, { value, modifiers, expression }, { evaluate: evaluate22 }) => {
1624    if (typeof expression === "function")
1625      expression = evaluate22(expression);
1626    if (expression === false)
1627      return;
1628    if (!expression || typeof expression === "boolean") {
1629      registerTransitionsFromHelper(el, modifiers, value);
1630    } else {
1631      registerTransitionsFromClassString(el, expression, value);
1632    }
1633  });
1634  function registerTransitionsFromClassString(el, classString, stage) {
1635    registerTransitionObject(el, setClasses, "");
1636    let directiveStorageMap = {
1637      "enter": (classes) => {
1638        el._x_transition.enter.during = classes;
1639      },
1640      "enter-start": (classes) => {
1641        el._x_transition.enter.start = classes;
1642      },
1643      "enter-end": (classes) => {
1644        el._x_transition.enter.end = classes;
1645      },
1646      "leave": (classes) => {
1647        el._x_transition.leave.during = classes;
1648      },
1649      "leave-start": (classes) => {
1650        el._x_transition.leave.start = classes;
1651      },
1652      "leave-end": (classes) => {
1653        el._x_transition.leave.end = classes;
1654      }
1655    };
1656    directiveStorageMap[stage](classString);
1657  }
1658  function registerTransitionsFromHelper(el, modifiers, stage) {
1659    registerTransitionObject(el, setStyles);
1660    let doesntSpecify = !modifiers.includes("in") && !modifiers.includes("out") && !stage;
1661    let transitioningIn = doesntSpecify || modifiers.includes("in") || ["enter"].includes(stage);
1662    let transitioningOut = doesntSpecify || modifiers.includes("out") || ["leave"].includes(stage);
1663    if (modifiers.includes("in") && !doesntSpecify) {
1664      modifiers = modifiers.filter((i, index) => index < modifiers.indexOf("out"));
1665    }
1666    if (modifiers.includes("out") && !doesntSpecify) {
1667      modifiers = modifiers.filter((i, index) => index > modifiers.indexOf("out"));
1668    }
1669    let wantsAll = !modifiers.includes("opacity") && !modifiers.includes("scale");
1670    let wantsOpacity = wantsAll || modifiers.includes("opacity");
1671    let wantsScale = wantsAll || modifiers.includes("scale");
1672    let opacityValue = wantsOpacity ? 0 : 1;
1673    let scaleValue = wantsScale ? modifierValue(modifiers, "scale", 95) / 100 : 1;
1674    let delay3 = modifierValue(modifiers, "delay", 0) / 1e3;
1675    let origin = modifierValue(modifiers, "origin", "center");
1676    let property = "opacity, transform";
1677    let durationIn = modifierValue(modifiers, "duration", 150) / 1e3;
1678    let durationOut = modifierValue(modifiers, "duration", 75) / 1e3;
1679    let easing = `cubic-bezier(0.4, 0.0, 0.2, 1)`;
1680    if (transitioningIn) {
1681      el._x_transition.enter.during = {
1682        transformOrigin: origin,
1683        transitionDelay: `${delay3}s`,
1684        transitionProperty: property,
1685        transitionDuration: `${durationIn}s`,
1686        transitionTimingFunction: easing
1687      };
1688      el._x_transition.enter.start = {
1689        opacity: opacityValue,
1690        transform: `scale(${scaleValue})`
1691      };
1692      el._x_transition.enter.end = {
1693        opacity: 1,
1694        transform: `scale(1)`
1695      };
1696    }
1697    if (transitioningOut) {
1698      el._x_transition.leave.during = {
1699        transformOrigin: origin,
1700        transitionDelay: `${delay3}s`,
1701        transitionProperty: property,
1702        transitionDuration: `${durationOut}s`,
1703        transitionTimingFunction: easing
1704      };
1705      el._x_transition.leave.start = {
1706        opacity: 1,
1707        transform: `scale(1)`
1708      };
1709      el._x_transition.leave.end = {
1710        opacity: opacityValue,
1711        transform: `scale(${scaleValue})`
1712      };
1713    }
1714  }
1715  function registerTransitionObject(el, setFunction, defaultValue = {}) {
1716    if (!el._x_transition)
1717      el._x_transition = {
1718        enter: { during: defaultValue, start: defaultValue, end: defaultValue },
1719        leave: { during: defaultValue, start: defaultValue, end: defaultValue },
1720        in(before = () => {
1721        }, after = () => {
1722        }) {
1723          transition(el, setFunction, {
1724            during: this.enter.during,
1725            start: this.enter.start,
1726            end: this.enter.end
1727          }, before, after);
1728        },
1729        out(before = () => {
1730        }, after = () => {
1731        }) {
1732          transition(el, setFunction, {
1733            during: this.leave.during,
1734            start: this.leave.start,
1735            end: this.leave.end
1736          }, before, after);
1737        }
1738      };
1739  }
1740  window.Element.prototype._x_toggleAndCascadeWithTransitions = function(el, value, show, hide) {
1741    const nextTick2 = document.visibilityState === "visible" ? requestAnimationFrame : setTimeout;
1742    let clickAwayCompatibleShow = () => nextTick2(show);
1743    if (value) {
1744      if (el._x_transition && (el._x_transition.enter || el._x_transition.leave)) {
1745        el._x_transition.enter && (Object.entries(el._x_transition.enter.during).length || Object.entries(el._x_transition.enter.start).length || Object.entries(el._x_transition.enter.end).length) ? el._x_transition.in(show) : clickAwayCompatibleShow();
1746      } else {
1747        el._x_transition ? el._x_transition.in(show) : clickAwayCompatibleShow();
1748      }
1749      return;
1750    }
1751    el._x_hidePromise = el._x_transition ? new Promise((resolve, reject) => {
1752      el._x_transition.out(() => {
1753      }, () => resolve(hide));
1754      el._x_transitioning && el._x_transitioning.beforeCancel(() => reject({ isFromCancelledTransition: true }));
1755    }) : Promise.resolve(hide);
1756    queueMicrotask(() => {
1757      let closest = closestHide(el);
1758      if (closest) {
1759        if (!closest._x_hideChildren)
1760          closest._x_hideChildren = [];
1761        closest._x_hideChildren.push(el);
1762      } else {
1763        nextTick2(() => {
1764          let hideAfterChildren = (el2) => {
1765            let carry = Promise.all([
1766              el2._x_hidePromise,
1767              ...(el2._x_hideChildren || []).map(hideAfterChildren)
1768            ]).then(([i]) => i?.());
1769            delete el2._x_hidePromise;
1770            delete el2._x_hideChildren;
1771            return carry;
1772          };
1773          hideAfterChildren(el).catch((e) => {
1774            if (!e.isFromCancelledTransition)
1775              throw e;
1776          });
1777        });
1778      }
1779    });
1780  };
1781  function closestHide(el) {
1782    let parent = el.parentNode;
1783    if (!parent)
1784      return;
1785    return parent._x_hidePromise ? parent : closestHide(parent);
1786  }
1787  function transition(el, setFunction, { during, start: start22, end } = {}, before = () => {
1788  }, after = () => {
1789  }) {
1790    if (el._x_transitioning)
1791      el._x_transitioning.cancel();
1792    if (Object.keys(during).length === 0 && Object.keys(start22).length === 0 && Object.keys(end).length === 0) {
1793      before();
1794      after();
1795      return;
1796    }
1797    let undoStart, undoDuring, undoEnd;
1798    performTransition(el, {
1799      start() {
1800        undoStart = setFunction(el, start22);
1801      },
1802      during() {
1803        undoDuring = setFunction(el, during);
1804      },
1805      before,
1806      end() {
1807        undoStart();
1808        undoEnd = setFunction(el, end);
1809      },
1810      after,
1811      cleanup() {
1812        undoDuring();
1813        undoEnd();
1814      }
1815    });
1816  }
1817  function performTransition(el, stages) {
1818    let interrupted, reachedBefore, reachedEnd;
1819    let finish = once(() => {
1820      mutateDom(() => {
1821        interrupted = true;
1822        if (!reachedBefore)
1823          stages.before();
1824        if (!reachedEnd) {
1825          stages.end();
1826          releaseNextTicks();
1827        }
1828        stages.after();
1829        if (el.isConnected)
1830          stages.cleanup();
1831        delete el._x_transitioning;
1832      });
1833    });
1834    el._x_transitioning = {
1835      beforeCancels: [],
1836      beforeCancel(callback) {
1837        this.beforeCancels.push(callback);
1838      },
1839      cancel: once(function() {
1840        while (this.beforeCancels.length) {
1841          this.beforeCancels.shift()();
1842        }
1843        ;
1844        finish();
1845      }),
1846      finish
1847    };
1848    mutateDom(() => {
1849      stages.start();
1850      stages.during();
1851    });
1852    holdNextTicks();
1853    requestAnimationFrame(() => {
1854      if (interrupted)
1855        return;
1856      let duration = Number(getComputedStyle(el).transitionDuration.replace(/,.*/, "").replace("s", "")) * 1e3;
1857      let delay3 = Number(getComputedStyle(el).transitionDelay.replace(/,.*/, "").replace("s", "")) * 1e3;
1858      if (duration === 0)
1859        duration = Number(getComputedStyle(el).animationDuration.replace("s", "")) * 1e3;
1860      mutateDom(() => {
1861        stages.before();
1862      });
1863      reachedBefore = true;
1864      requestAnimationFrame(() => {
1865        if (interrupted)
1866          return;
1867        mutateDom(() => {
1868          stages.end();
1869        });
1870        releaseNextTicks();
1871        setTimeout(el._x_transitioning.finish, duration + delay3);
1872        reachedEnd = true;
1873      });
1874    });
1875  }
1876  function modifierValue(modifiers, key, fallback2) {
1877    if (modifiers.indexOf(key) === -1)
1878      return fallback2;
1879    const rawValue = modifiers[modifiers.indexOf(key) + 1];
1880    if (!rawValue)
1881      return fallback2;
1882    if (key === "scale") {
1883      if (isNaN(rawValue))
1884        return fallback2;
1885    }
1886    if (key === "duration" || key === "delay") {
1887      let match = rawValue.match(/([0-9]+)ms/);
1888      if (match)
1889        return match[1];
1890    }
1891    if (key === "origin") {
1892      if (["top", "right", "left", "center", "bottom"].includes(modifiers[modifiers.indexOf(key) + 2])) {
1893        return [rawValue, modifiers[modifiers.indexOf(key) + 2]].join(" ");
1894      }
1895    }
1896    return rawValue;
1897  }
1898  var isCloning = false;
1899  function skipDuringClone(callback, fallback2 = () => {
1900  }) {
1901    return (...args) => isCloning ? fallback2(...args) : callback(...args);
1902  }
1903  function onlyDuringClone(callback) {
1904    return (...args) => isCloning && callback(...args);
1905  }
1906  var interceptors = [];
1907  function interceptClone(callback) {
1908    interceptors.push(callback);
1909  }
1910  function cloneNode(from, to) {
1911    interceptors.forEach((i) => i(from, to));
1912    isCloning = true;
1913    dontRegisterReactiveSideEffects(() => {
1914      initTree(to, (el, callback) => {
1915        callback(el, () => {
1916        });
1917      });
1918    });
1919    isCloning = false;
1920  }
1921  var isCloningLegacy = false;
1922  function clone(oldEl, newEl) {
1923    if (!newEl._x_dataStack)
1924      newEl._x_dataStack = oldEl._x_dataStack;
1925    isCloning = true;
1926    isCloningLegacy = true;
1927    dontRegisterReactiveSideEffects(() => {
1928      cloneTree(newEl);
1929    });
1930    isCloning = false;
1931    isCloningLegacy = false;
1932  }
1933  function cloneTree(el) {
1934    let hasRunThroughFirstEl = false;
1935    let shallowWalker = (el2, callback) => {
1936      walk(el2, (el3, skip) => {
1937        if (hasRunThroughFirstEl && isRoot(el3))
1938          return skip();
1939        hasRunThroughFirstEl = true;
1940        callback(el3, skip);
1941      });
1942    };
1943    initTree(el, shallowWalker);
1944  }
1945  function dontRegisterReactiveSideEffects(callback) {

1946    let cache = effect;
1947    overrideEffect((callback2, el) => {
1948      let storedEffect = cache(callback2);
1949      release(storedEffect);
1950      return () => {
1951      };
1952    });
1953    callback();
1954    overrideEffect(cache);
1955  }
1956  function bind(el, name, value, modifiers = []) {
1957    if (!el._x_bindings)
1958      el._x_bindings = reactive({});
1959    el._x_bindings[name] = value;
1960    name = modifiers.includes("camel") ? camelCase(name) : name;
1961    switch (name) {
1962      case "value":
1963        bindInputValue(el, value);
1964        break;
1965      case "style":
1966        bindStyles(el, value);
1967        break;
1968      case "class":
1969        bindClasses(el, value);
1970        break;
1971      case "selected":
1972      case "checked":
1973        bindAttributeAndProperty(el, name, value);
1974        break;
1975      default:
1976        bindAttribute(el, name, value);
1977        break;
1978    }
1979  }
1980  function bindInputValue(el, value) {
1981    if (el.type === "radio") {
1982      if (el.attributes.value === void 0) {
1983        el.value = value;
1984      }
1985      if (window.fromModel) {
1986        if (typeof value === "boolean") {
1987          el.checked = safeParseBoolean(el.value) === value;
1988        } else {
1989          el.checked = checkedAttrLooseCompare(el.value, value);
1990        }
1991      }
1992    } else if (el.type === "checkbox") {
1993      if (Number.isInteger(value)) {
1994        el.value = value;
1995      } else if (!Array.isArray(value) && typeof value !== "boolean" && ![null, void 0].includes(value)) {

1996        el.value = String(value);
1997      } else {
1998        if (Array.isArray(value)) {
1999          el.checked = value.some((val) => checkedAttrLooseCompare(val, el.value));
2000        } else {
2001          el.checked = !!value;
2002        }
2003      }
2004    } else if (el.tagName === "SELECT") {
2005      updateSelect(el, value);
2006    } else {
2007      if (el.value === value)
2008        return;
2009      el.value = value === void 0 ? "" : value;
2010    }
2011  }
2012  function bindClasses(el, value) {
2013    if (el._x_undoAddedClasses)
2014      el._x_undoAddedClasses();
2015    el._x_undoAddedClasses = setClasses(el, value);
2016  }
2017  function bindStyles(el, value) {
2018    if (el._x_undoAddedStyles)
2019      el._x_undoAddedStyles();
2020    el._x_undoAddedStyles = setStyles(el, value);
2021  }
2022  function bindAttributeAndProperty(el, name, value) {
2023    bindAttribute(el, name, value);
2024    setPropertyIfChanged(el, name, value);
2025  }
2026  function bindAttribute(el, name, value) {
2027    if ([null, void 0, false].includes(value) && attributeShouldntBePreservedIfFalsy(name)) {
2028      el.removeAttribute(name);
2029    } else {
2030      if (isBooleanAttr(name))
2031        value = name;
2032      setIfChanged(el, name, value);
2033    }
2034  }
2035  function setIfChanged(el, attrName, value) {
2036    if (el.getAttribute(attrName) != value) {
2037      el.setAttribute(attrName, value);
2038    }
2039  }
2040  function setPropertyIfChanged(el, propName, value) {
2041    if (el[propName] !== value) {
2042      el[propName] = value;
2043    }
2044  }
2045  function updateSelect(el, value) {
2046    const arrayWrappedValue = [].concat(value).map((value2) => {
2047      return value2 + "";
2048    });
2049    Array.from(el.options).forEach((option) => {
2050      option.selected = arrayWrappedValue.includes(option.value);
2051    });
2052  }
2053  function camelCase(subject) {
2054    return subject.toLowerCase().replace(/-(\w)/g, (match, char) => char.toUpperCase());
2055  }
2056  function checkedAttrLooseCompare(valueA, valueB) {
2057    return valueA == valueB;
2058  }
2059  function safeParseBoolean(rawValue) {
2060    if ([1, "1", "true", "on", "yes", true].includes(rawValue)) {
2061      return true;
2062    }
2063    if ([0, "0", "false", "off", "no", false].includes(rawValue)) {
2064      return false;
2065    }
2066    return rawValue ? Boolean(rawValue) : null;
2067  }
2068  function isBooleanAttr(attrName) {
2069    const booleanAttributes = [
2070      "disabled",
2071      "checked",
2072      "required",
2073      "readonly",
2074      "open",
2075      "selected",
2076      "autofocus",
2077      "itemscope",
2078      "multiple",
2079      "novalidate",
2080      "allowfullscreen",
2081      "allowpaymentrequest",
2082      "formnovalidate",
2083      "autoplay",
2084      "controls",
2085      "loop",
2086      "muted",
2087      "playsinline",
2088      "default",
2089      "ismap",
2090      "reversed",
2091      "async",
2092      "defer",
2093      "nomodule"
2094    ];
2095    return booleanAttributes.includes(attrName);
2096  }
2097  function attributeShouldntBePreservedIfFalsy(name) {
2098    return !["aria-pressed", "aria-checked", "aria-expanded", "aria-selected"].includes(name);
2099  }
2100  function getBinding(el, name, fallback2) {
2101    if (el._x_bindings && el._x_bindings[name] !== void 0)
2102      return el._x_bindings[name];
2103    return getAttributeBinding(el, name, fallback2);
2104  }
2105  function extractProp(el, name, fallback2, extract = true) {
2106    if (el._x_bindings && el._x_bindings[name] !== void 0)
2107      return el._x_bindings[name];
2108    if (el._x_inlineBindings && el._x_inlineBindings[name] !== void 0) {
2109      let binding = el._x_inlineBindings[name];
2110      binding.extract = extract;
2111      return dontAutoEvaluateFunctions(() => {
2112        return evaluate(el, binding.expression);
2113      });
2114    }
2115    return getAttributeBinding(el, name, fallback2);
2116  }
2117  function getAttributeBinding(el, name, fallback2) {
2118    let attr = el.getAttribute(name);
2119    if (attr === null)
2120      return typeof fallback2 === "function" ? fallback2() : fallback2;
2121    if (attr === "")
2122      return true;
2123    if (isBooleanAttr(name)) {
2124      return !![name, "true"].includes(attr);
2125    }
2126    return attr;
2127  }
2128  function debounce(func, wait) {
2129    var timeout;
2130    return function() {
2131      var context = this, args = arguments;
2132      var later = function() {
2133        timeout = null;

vendor: 1,392 bytes, lines 2134-2181

2134        func.apply(context, args);
2135      };
2136      clearTimeout(timeout);
2137      timeout = setTimeout(later, wait);
2138    };
2139  }
2140  function throttle(func, limit) {
2141    let inThrottle;
2142    return function() {
2143      let context = this, args = arguments;
2144      if (!inThrottle) {
2145        func.apply(context, args);
2146        inThrottle = true;
2147        setTimeout(() => inThrottle = false, limit);
2148      }
2149    };
2150  }
2151  function entangle({ get: outerGet, set: outerSet }, { get: innerGet, set: innerSet }) {
2152    let firstRun = true;
2153    let outerHash;
2154    let innerHash;
2155    let reference = effect(() => {
2156      let outer = outerGet();
2157      let inner = innerGet();
2158      if (firstRun) {
2159        innerSet(cloneIfObject(outer));
2160        firstRun = false;
2161      } else {
2162        let outerHashLatest = JSON.stringify(outer);
2163        let innerHashLatest = JSON.stringify(inner);
2164        if (outerHashLatest !== outerHash) {
2165          innerSet(cloneIfObject(outer));
2166        } else if (outerHashLatest !== innerHashLatest) {
2167          outerSet(cloneIfObject(inner));
2168        } else {
2169        }
2170      }
2171      outerHash = JSON.stringify(outerGet());
2172      innerHash = JSON.stringify(innerGet());
2173    });
2174    return () => {
2175      release(reference);
2176    };
2177  }
2178  function cloneIfObject(value) {
2179    return typeof value === "object" ? JSON.parse(JSON.stringify(value)) : value;
2180  }
2181  function plugin(callback) {

2182    let callbacks = Array.isArray(callback) ? callback : [callback];
2183    callbacks.forEach((i) => i(alpine_default));
2184  }
2185  var stores = {};
2186  var isReactive = false;
2187  function store(name, value) {
2188    if (!isReactive) {
2189      stores = reactive(stores);
2190      isReactive = true;
2191    }
2192    if (value === void 0) {
2193      return stores[name];
2194    }
2195    stores[name] = value;
2196    if (typeof value === "object" && value !== null && value.hasOwnProperty("init") && typeof value.init === "function") {
2197      stores[name].init();
2198    }
2199    initInterceptors(stores[name]);
2200  }
2201  function getStores() {
2202    return stores;
2203  }
2204  var binds = {};
2205  function bind2(name, bindings) {
2206    let getBindings = typeof bindings !== "function" ? () => bindings : bindings;
2207    if (name instanceof Element) {
2208      return applyBindingsObject(name, getBindings());
2209    } else {
2210      binds[name] = getBindings;
2211    }
2212    return () => {
2213    };
2214  }
2215  function injectBindingProviders(obj) {
2216    Object.entries(binds).forEach(([name, callback]) => {
2217      Object.defineProperty(obj, name, {
2218        get() {
2219          return (...args) => {
2220            return callback(...args);
2221          };
2222        }
2223      });
2224    });
2225    return obj;
2226  }
2227  function applyBindingsObject(el, obj, original) {
2228    let cleanupRunners = [];
2229    while (cleanupRunners.length)
2230      cleanupRunners.pop()();
2231    let attributes = Object.entries(obj).map(([name, value]) => ({ name, value }));
2232    let staticAttributes = attributesOnly(attributes);
2233    attributes = attributes.map((attribute) => {
2234      if (staticAttributes.find((attr) => attr.name === attribute.name)) {
2235        return {
2236          name: `x-bind:${attribute.name}`,
2237          value: `"${attribute.value}"`
2238        };
2239      }
2240      return attribute;
2241    });
2242    directives(el, attributes, original).map((handle) => {
2243      cleanupRunners.push(handle.runCleanups);
2244      handle();
2245    });
2246    return () => {
2247      while (cleanupRunners.length)
2248        cleanupRunners.pop()();
2249    };
2250  }
2251  var datas = {};
2252  function data(name, callback) {
2253    datas[name] = callback;
2254  }
2255  function injectDataProviders(obj, context) {
2256    Object.entries(datas).forEach(([name, callback]) => {
2257      Object.defineProperty(obj, name, {
2258        get() {
2259          return (...args) => {
2260            return callback.bind(context)(...args);
2261          };
2262        },
2263        enumerable: false
2264      });
2265    });
2266    return obj;
2267  }
2268  var Alpine2 = {
2269    get reactive() {
2270      return reactive;
2271    },
2272    get release() {
2273      return release;
2274    },
2275    get effect() {
2276      return effect;
2277    },
2278    get raw() {
2279      return raw;
2280    },
2281    version: "3.14.0",
2282    flushAndStopDeferringMutations,
2283    dontAutoEvaluateFunctions,
2284    disableEffectScheduling,
2285    startObservingMutations,
2286    stopObservingMutations,
2287    setReactivityEngine,
2288    onAttributeRemoved,
2289    onAttributesAdded,
2290    closestDataStack,
2291    skipDuringClone,
2292    onlyDuringClone,
2293    addRootSelector,
2294    addInitSelector,
2295    interceptClone,
2296    addScopeToNode,
2297    deferMutations,
2298    mapAttributes,
2299    evaluateLater,
2300    interceptInit,
2301    setEvaluator,
2302    mergeProxies,
2303    extractProp,
2304    findClosest,
2305    onElRemoved,
2306    closestRoot,
2307    destroyTree,
2308    interceptor,
2309    transition,
2310    setStyles,
2311    mutateDom,
2312    directive,
2313    entangle,
2314    throttle,
2315    debounce,
2316    evaluate,
2317    initTree,
2318    nextTick,
2319    prefixed: prefix,
2320    prefix: setPrefix,
2321    plugin,
2322    magic,
2323    store,
2324    start,
2325    clone,
2326    cloneNode,
2327    bound: getBinding,
2328    $data: scope,
2329    watch,
2330    walk,
2331    data,
2332    bind: bind2
2333  };
2334  var alpine_default = Alpine2;
2335  function makeMap(str, expectsLowerCase) {
2336    const map = /* @__PURE__ */ Object.create(null);
2337    const list = str.split(",");
2338    for (let i = 0; i < list.length; i++) {
2339      map[list[i]] = true;
2340    }
2341    return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];
2342  }
2343  var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
2344  var isBooleanAttr2 = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,loop,open,required,reversed,scoped,seamless,

2344checked,muted,multiple,selected`);
2345  var EMPTY_OBJ = true ? Object.freeze({}) : {};
2346  var EMPTY_ARR = true ? Object.freeze([]) : [];
2347  var hasOwnProperty = Object.prototype.hasOwnProperty;
2348  var hasOwn = (val, key) => hasOwnProperty.call(val, key);
2349  var isArray2 = Array.isArray;
2350  var isMap = (val) => toTypeString(val) === "[object Map]";
2351  var isString = (val) => typeof val === "string";
2352  var isSymbol = (val) => typeof val === "symbol";
2353  var isObject2 = (val) => val !== null && typeof val === "object";
2354  var objectToString = Object.prototype.toString;
2355  var toTypeString = (value) => objectToString.call(value);
2356  var toRawType = (value) => {
2357    return toTypeString(value).slice(8, -1);
2358  };
2359  var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
2360  var cacheStringFunction = (fn) => {
2361    const cache = /* @__PURE__ */ Object.create(null);
2362    return (str) => {
2363      const hit = cache[str];
2364      return hit || (cache[str] = fn(str));
2365    };
2366  };
2367  var camelizeRE = /-(\w)/g;
2368  var camelize = cacheStringFunction((str) => {
2369    return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
2370  });
2371  var hyphenateRE = /\B([A-Z])/g;
2372  var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
2373  var capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
2374  var toHandlerKey = cacheStringFunction((str) => str ? `on${capitalize(str)}` : ``);
2375  var hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);
2376  var targetMap = /* @__PURE__ */ new WeakMap();
2377  var effectStack = [];
2378  var activeEffect;
2379  var ITERATE_KEY = Symbol(true ? "iterate" : "");
2380  var MAP_KEY_ITERATE_KEY = Symbol(true ? "Map key iterate" : "");
2381  function isEffect(fn) {
2382    return fn && fn._isEffect === true;
2383  }
2384  function effect2(fn, options = EMPTY_OBJ) {
2385    if (isEffect(fn)) {
2386      fn = fn.raw;
2387    }
2388    const effect3 = createReactiveEffect(fn, options);
2389    if (!options.lazy) {
2390      effect3();
2391    }
2392    return effect3;
2393  }
2394  function stop(effect3) {
2395    if (effect3.active) {
2396      cleanup(effect3);
2397      if (effect3.options.onStop) {
2398        effect3.options.onStop();
2399      }
2400      effect3.active = false;
2401    }
2402  }
2403  var uid = 0;
2404  function createReactiveEffect(fn, options) {
2405    const effect3 = function reactiveEffect() {
2406      if (!effect3.active) {
2407        return fn();
2408      }
2409      if (!effectStack.includes(effect3)) {
2410        cleanup(effect3);
2411        try {
2412          enableTracking();
2413          effectStack.push(effect3);
2414          activeEffect = effect3;
2415          return fn();
2416        } finally {
2417          effectStack.pop();
2418          resetTracking();
2419          activeEffect = effectStack[effectStack.length - 1];
2420        }
2421      }
2422    };
2423    effect3.id = uid++;
2424    effect3.allowRecurse = !!options.allowRecurse;
2425    effect3._isEffect = true;
2426    effect3.active = true;
2427    effect3.raw = fn;
2428    effect3.deps = [];
2429    effect3.options = options;
2430    return effect3;
2431  }
2432  function cleanup(effect3) {
2433    const { deps } = effect3;
2434    if (deps.length) {
2435      for (let i = 0; i < deps.length; i++) {
2436        deps[i].delete(effect3);
2437      }
2438      deps.length = 0;
2439    }
2440  }
2441  var shouldTrack = true;
2442  var trackStack = [];
2443  function pauseTracking() {
2444    trackStack.push(shouldTrack);
2445    shouldTrack = false;
2446  }
2447  function enableTracking() {
2448    trackStack.push(shouldTrack);
2449    shouldTrack = true;
2450  }
2451  function resetTracking() {
2452    const last = trackStack.pop();
2453    shouldTrack = last === void 0 ? true : last;
2454  }
2455  function track(target, type, key) {
2456    if (!shouldTrack || activeEffect === void 0) {
2457      return;
2458    }
2459    let depsMap = targetMap.get(target);
2460    if (!depsMap) {
2461      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
2462    }
2463    let dep = depsMap.get(key);
2464    if (!dep) {
2465      depsMap.set(key, dep = /* @__PURE__ */ new Set());
2466    }
2467    if (!dep.has(activeEffect)) {
2468      dep.add(activeEffect);
2469      activeEffect.deps.push(dep);
2470      if (activeEffect.options.onTrack) {
2471        activeEffect.options.onTrack({
2472          effect: activeEffect,
2473          target,
2474          type,
2475          key
2476        });
2477      }
2478    }
2479  }
2480  function trigger(target, type, key, newValue, oldValue, oldTarget) {
2481    const depsMap = targetMap.get(target);
2482    if (!depsMap) {
2483      return;
2484    }
2485    const effects = /* @__PURE__ */ new Set();
2486    const add2 = (effectsToAdd) => {
2487      if (effectsToAdd) {

2488        effectsToAdd.forEach((effect3) => {
2489          if (effect3 !== activeEffect || effect3.allowRecurse) {
2490            effects.add(effect3);
2491          }
2492        });
2493      }
2494    };
2495    if (type === "clear") {
2496      depsMap.forEach(add2);
2497    } else if (key === "length" && isArray2(target)) {
2498      depsMap.forEach((dep, key2) => {
2499        if (key2 === "length" || key2 >= newValue) {
2500          add2(dep);
2501        }
2502      });
2503    } else {
2504      if (key !== void 0) {
2505        add2(depsMap.get(key));
2506      }
2507      switch (type) {
2508        case "add":
2509          if (!isArray2(target)) {
2510            add2(depsMap.get(ITERATE_KEY));
2511            if (isMap(target)) {
2512              add2(depsMap.get(MAP_KEY_ITERATE_KEY));
2513            }
2514          } else if (isIntegerKey(key)) {
2515            add2(depsMap.get("length"));
2516          }
2517          break;
2518        case "delete":
2519          if (!isArray2(target)) {
2520            add2(depsMap.get(ITERATE_KEY));
2521            if (isMap(target)) {
2522              add2(depsMap.get(MAP_KEY_ITERATE_KEY));
2523            }
2524          }
2525          break;
2526        case "set":
2527          if (isMap(target)) {
2528            add2(depsMap.get(ITERATE_KEY));
2529          }
2530          break;
2531      }
2532    }
2533    const run = (effect3) => {
2534      if (effect3.options.onTrigger) {
2535        effect3.options.onTrigger({
2536          effect: effect3,
2537          target,
2538          key,
2539          type,
2540          newValue,
2541          oldValue,
2542          oldTarget
2543        });
2544      }
2545      if (effect3.options.scheduler) {
2546        effect3.options.scheduler(effect3);
2547      } else {
2548        effect3();
2549      }
2550    };
2551    effects.forEach(run);
2552  }
2553  var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
2554  var builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map((key) => Symbol[key]).filter(isSymbol));
2555  var get2 = /* @__PURE__ */ createGetter();
2556  var readonlyGet = /* @__PURE__ */ createGetter(true);
2557  var arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
2558  function createArrayInstrumentations() {
2559    const instrumentations = {};
2560    ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
2561      instrumentations[key] = function(...args) {
2562        const arr = toRaw(this);
2563        for (let i = 0, l = this.length; i < l; i++) {
2564          track(arr, "get", i + "");
2565        }
2566        const res = arr[key](...args);
2567        if (res === -1 || res === false) {
2568          return arr[key](...args.map(toRaw));
2569        } else {
2570          return res;
2571        }
2572      };
2573    });
2574    ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
2575      instrumentations[key] = function(...args) {
2576        pauseTracking();
2577        const res = toRaw(this)[key].apply(this, args);
2578        resetTracking();
2579        return res;
2580      };
2581    });
2582    return instrumentations;
2583  }
2584  function createGetter(isReadonly = false, shallow = false) {
2585    return function get3(target, key, receiver) {
2586      if (key === "__v_isReactive") {
2587        return !isReadonly;
2588      } else if (key === "__v_isReadonly") {
2589        return isReadonly;
2590      } else if (key === "__v_raw" && receiver === (isReadonly ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
2591        return target;
2592      }
2593      const targetIsArray = isArray2(target);
2594      if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
2595        return Reflect.get(arrayInstrumentations, key, receiver);
2596      }
2597      const res = Reflect.get(target, key, receiver);
2598      if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
2599        return res;
2600      }
2601      if (!isReadonly) {
2602        track(target, "get", key);
2603      }
2604      if (shallow) {
2605        return res;
2606      }
2607      if (isRef(res)) {
2608        const shouldUnwrap = !targetIsArray || !isIntegerKey(key);
2609        return shouldUnwrap ? res.value : res;
2610      }
2611      if (isObject2(res)) {
2612        return isReadonly ? readonly(res) : reactive2(res);
2613      }
2614      return res;
2615    };
2616  }
2617  var set2 = /* @__PURE__ */ createSetter();
2618  function createSetter(shallow = false) {
2619    return function set3(target, key, value, receiver) {
2620      let oldValue = target[key];
2621      if (!shallow) {
2622        value = toRaw(value);
2623        oldValue = toRaw(oldValue);
2624        if (!isArray2(target) && isRef(oldValue) && !isRef(value)) {
2625          oldValue.value = value;
2626          return true;
2627        }
2628      }
2629      const hadKey = isArray2(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
2630      const result = Reflect.set(target, key, value, receiver);
2631      if (target === toRaw(receiver)) {
2632        if (!hadKey) {
2633          trigger(target, "add", key, value);
2634        } else if (hasChanged(value, oldValue)) {
2635          trigger(target, "set", key, value, oldValue);
2636        }
2637      }
2638      return result;
2639    };
2640  }
2641  function deleteProperty(target, key) {
2642    const hadKey = hasOwn(target, key);
2643    const oldValue = target[key];
2644    const result = Reflect.deleteProperty(target, key);
2645    if (result && hadKey) {
2646      trigger(target, "delete", key, void 0, oldValue);
2647    }
2648    return result;
2649  }
2650  function has(target, key) {
2651    const result = Reflect.has(target, key);

2652    if (!isSymbol(key) || !builtInSymbols.has(key)) {
2653      track(target, "has", key);
2654    }
2655    return result;
2656  }
2657  function ownKeys(target) {
2658    track(target, "iterate", isArray2(target) ? "length" : ITERATE_KEY);
2659    return Reflect.ownKeys(target);
2660  }
2661  var mutableHandlers = {
2662    get: get2,
2663    set: set2,
2664    deleteProperty,
2665    has,
2666    ownKeys
2667  };
2668  var readonlyHandlers = {
2669    get: readonlyGet,
2670    set(target, key) {
2671      if (true) {
2672        console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
2673      }
2674      return true;
2675    },
2676    deleteProperty(target, key) {
2677      if (true) {
2678        console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
2679      }
2680      return true;
2681    }
2682  };
2683  var toReactive = (value) => isObject2(value) ? reactive2(value) : value;
2684  var toReadonly = (value) => isObject2(value) ? readonly(value) : value;
2685  var toShallow = (value) => value;
2686  var getProto = (v) => Reflect.getPrototypeOf(v);
2687  function get$1(target, key, isReadonly = false, isShallow = false) {
2688    target = target["__v_raw"];
2689    const rawTarget = toRaw(target);
2690    const rawKey = toRaw(key);
2691    if (key !== rawKey) {
2692      !isReadonly && track(rawTarget, "get", key);
2693    }
2694    !isReadonly && track(rawTarget, "get", rawKey);
2695    const { has: has2 } = getProto(rawTarget);
2696    const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
2697    if (has2.call(rawTarget, key)) {
2698      return wrap(target.get(key));
2699    } else if (has2.call(rawTarget, rawKey)) {
2700      return wrap(target.get(rawKey));
2701    } else if (target !== rawTarget) {
2702      target.get(key);
2703    }
2704  }
2705  function has$1(key, isReadonly = false) {
2706    const target = this["__v_raw"];
2707    const rawTarget = toRaw(target);
2708    const rawKey = toRaw(key);
2709    if (key !== rawKey) {
2710      !isReadonly && track(rawTarget, "has", key);
2711    }
2712    !isReadonly && track(rawTarget, "has", rawKey);
2713    return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
2714  }
2715  function size(target, isReadonly = false) {
2716    target = target["__v_raw"];
2717    !isReadonly && track(toRaw(target), "iterate", ITERATE_KEY);
2718    return Reflect.get(target, "size", target);
2719  }
2720  function add(value) {
2721    value = toRaw(value);
2722    const target = toRaw(this);
2723    const proto = getProto(target);
2724    const hadKey = proto.has.call(target, value);
2725    if (!hadKey) {
2726      target.add(value);
2727      trigger(target, "add", value, value);
2728    }
2729    return this;
2730  }
2731  function set$1(key, value) {
2732    value = toRaw(value);
2733    const target = toRaw(this);
2734    const { has: has2, get: get3 } = getProto(target);
2735    let hadKey = has2.call(target, key);
2736    if (!hadKey) {
2737      key = toRaw(key);
2738      hadKey = has2.call(target, key);
2739    } else if (true) {
2740      checkIdentityKeys(target, has2, key);
2741    }
2742    const oldValue = get3.call(target, key);
2743    target.set(key, value);
2744    if (!hadKey) {
2745      trigger(target, "add", key, value);
2746    } else if (hasChanged(value, oldValue)) {
2747      trigger(target, "set", key, value, oldValue);
2748    }
2749    return this;
2750  }
2751  function deleteEntry(key) {
2752    const target = toRaw(this);
2753    const { has: has2, get: get3 } = getProto(target);
2754    let hadKey = has2.call(target, key);
2755    if (!hadKey) {
2756      key = toRaw(key);
2757      hadKey = has2.call(target, key);
2758    } else if (true) {
2759      checkIdentityKeys(target, has2, key);
2760    }
2761    const oldValue = get3 ? get3.call(target, key) : void 0;
2762    const result = target.delete(key);
2763    if (hadKey) {
2764      trigger(target, "delete", key, void 0, oldValue);
2765    }
2766    return result;
2767  }
2768  function clear() {
2769    const target = toRaw(this);
2770    const hadItems = target.size !== 0;
2771    const oldTarget = true ? isMap(target) ? new Map(target) : new Set(target) : void 0;
2772    const result = target.clear();
2773    if (hadItems) {
2774      trigger(target, "clear", void 0, void 0, oldTarget);
2775    }
2776    return result;
2777  }
2778  function createForEach(isReadonly, isShallow) {
2779    return function forEach(callback, thisArg) {
2780      const observed = this;
2781      const target = observed["__v_raw"];
2782      const rawTarget = toRaw(target);
2783      const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
2784      !isReadonly && track(rawTarget, "iterate", ITERATE_KEY);
2785      return target.forEach((value, key) => {
2786        return callback.call(thisArg, wrap(value), wrap(key), observed);
2787      });
2788    };
2789  }
2790  function createIterableMethod(method, isReadonly, isShallow) {
2791    return function(...args) {
2792      const target = this["__v_raw"];
2793      const rawTarget = toRaw(target);
2794      const targetIsMap = isMap(rawTarget);
2795      const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
2796      const isKeyOnly = method === "keys" && targetIsMap;
2797      const innerIterator = target[method](...args);
2798      const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
2799      !isReadonly && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
2800      return {
2801        next() {
2802          const { value, done } = innerIterator.next();
2803          return done ? { value, done } : {
2804            value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),

2805            done
2806          };
2807        },
2808        [Symbol.iterator]() {
2809          return this;
2810        }
2811      };
2812    };
2813  }
2814  function createReadonlyMethod(type) {
2815    return function(...args) {
2816      if (true) {
2817        const key = args[0] ? `on key "${args[0]}" ` : ``;
2818        console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
2819      }
2820      return type === "delete" ? false : this;
2821    };
2822  }
2823  function createInstrumentations() {
2824    const mutableInstrumentations2 = {
2825      get(key) {
2826        return get$1(this, key);
2827      },
2828      get size() {
2829        return size(this);
2830      },
2831      has: has$1,
2832      add,
2833      set: set$1,
2834      delete: deleteEntry,
2835      clear,
2836      forEach: createForEach(false, false)
2837    };
2838    const shallowInstrumentations2 = {
2839      get(key) {
2840        return get$1(this, key, false, true);
2841      },
2842      get size() {
2843        return size(this);
2844      },
2845      has: has$1,
2846      add,
2847      set: set$1,
2848      delete: deleteEntry,
2849      clear,
2850      forEach: createForEach(false, true)
2851    };
2852    const readonlyInstrumentations2 = {
2853      get(key) {
2854        return get$1(this, key, true);
2855      },
2856      get size() {
2857        return size(this, true);
2858      },
2859      has(key) {
2860        return has$1.call(this, key, true);
2861      },
2862      add: createReadonlyMethod("add"),
2863      set: createReadonlyMethod("set"),
2864      delete: createReadonlyMethod("delete"),
2865      clear: createReadonlyMethod("clear"),
2866      forEach: createForEach(true, false)
2867    };
2868    const shallowReadonlyInstrumentations2 = {
2869      get(key) {
2870        return get$1(this, key, true, true);
2871      },
2872      get size() {
2873        return size(this, true);
2874      },
2875      has(key) {
2876        return has$1.call(this, key, true);
2877      },
2878      add: createReadonlyMethod("add"),
2879      set: createReadonlyMethod("set"),
2880      delete: createReadonlyMethod("delete"),
2881      clear: createReadonlyMethod("clear"),
2882      forEach: createForEach(true, true)
2883    };
2884    const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
2885    iteratorMethods.forEach((method) => {
2886      mutableInstrumentations2[method] = createIterableMethod(method, false, false);
2887      readonlyInstrumentations2[method] = createIterableMethod(method, true, false);
2888      shallowInstrumentations2[method] = createIterableMethod(method, false, true);
2889      shallowReadonlyInstrumentations2[method] = createIterableMethod(method, true, true);
2890    });
2891    return [
2892      mutableInstrumentations2,
2893      readonlyInstrumentations2,
2894      shallowInstrumentations2,
2895      shallowReadonlyInstrumentations2
2896    ];
2897  }
2898  var [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* @__PURE__ */ createInstrumentations();
2899  function createInstrumentationGetter(isReadonly, shallow) {
2900    const instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations;
2901    return (target, key, receiver) => {
2902      if (key === "__v_isReactive") {
2903        return !isReadonly;
2904      } else if (key === "__v_isReadonly") {
2905        return isReadonly;
2906      } else if (key === "__v_raw") {
2907        return target;
2908      }
2909      return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
2910    };
2911  }
2912  var mutableCollectionHandlers = {
2913    get: /* @__PURE__ */ createInstrumentationGetter(false, false)
2914  };
2915  var readonlyCollectionHandlers = {
2916    get: /* @__PURE__ */ createInstrumentationGetter(true, false)
2917  };
2918  function checkIdentityKeys(target, has2, key) {
2919    const rawKey = toRaw(key);
2920    if (rawKey !== key && has2.call(target, rawKey)) {
2921      const type = toRawType(target);
2922      console.warn(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`);
2923    }
2924  }
2925  var reactiveMap = /* @__PURE__ */ new WeakMap();
2926  var shallowReactiveMap = /* @__PURE__ */ new WeakMap();
2927  var readonlyMap = /* @__PURE__ */ new WeakMap();
2928  var shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
2929  function targetTypeMap(rawType) {
2930    switch (rawType) {
2931      case "Object":
2932      case "Array":
2933        return 1;
2934      case "Map":
2935      case "Set":
2936      case "WeakMap":
2937      case "WeakSet":
2938        return 2;
2939      default:
2940        return 0;
2941    }
2942  }
2943  function getTargetType(value) {
2944    return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
2945  }
2946  function reactive2(target) {
2947    if (target && target["__v_isReadonly"]) {
2948      return target;
2949    }
2950    return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
2951  }
2952  function readonly(target) {
2953    return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
2954  }
2955  function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
2956    if (!isObject2(target)) {
2957      if (true) {
2958        console.warn(`value cannot be made reactive: ${String(target)}`);
2959      }
2960      return target;
2961    }
2962    if (target["__v_raw"] && !(isReadonly && target["__v_isReactive"])) {
2963      return target;
2964    }
2965    const existingProxy = proxyMap.get(target);
2966    if (existingProxy) {
2967      return existingProxy;
2968    }
2969    const targetType = getTargetType(target);
2970    if (targetType === 0) {
2971      return target;
2972    }
2973    const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
2974    proxyMap.set(target, proxy);
2975    return proxy;
2976  }
2977  function toRaw(observed) {
2978    return observed && toRaw(observed["__v_raw"]) || observed;
2979  }
2980  function isRef(r) {
2981    return Boolean(r && r.__v_isRef === true);
2982  }
2983  magic("nextTick", () => nextTick);
2984  magic("dispatch", (el) => dispatch2.bind(dispatch2, el));
2985  magic("watch", (el, { evaluateLater: evaluateLater2, cleanup: cleanup2 }) => (key, callback) => {
2986    let evaluate22 = evaluateLater2(key);
2987    let getter = () => {
2988      let value;
2989      evaluate22((i) => value = i);
2990      return value;
2991    };
2992    let unwatch = watch(getter, callback);
2993    cleanup2(unwatch);
2994  });

vendor: 18,946 bytes, lines 2995-3520

2995  magic("store", getStores);
2996  magic("data", (el) => scope(el));
2997  magic("root", (el) => closestRoot(el));
2998  magic("refs", (el) => {
2999    if (el._x_refs_proxy)
3000      return el._x_refs_proxy;
3001    el._x_refs_proxy = mergeProxies(getArrayOfRefObject(el));
3002    return el._x_refs_proxy;
3003  });
3004  function getArrayOfRefObject(el) {
3005    let refObjects = [];
3006    findClosest(el, (i) => {
3007      if (i._x_refs)
3008        refObjects.push(i._x_refs);
3009    });
3010    return refObjects;
3011  }
3012  var globalIdMemo = {};
3013  function findAndIncrementId(name) {
3014    if (!globalIdMemo[name])
3015      globalIdMemo[name] = 0;
3016    return ++globalIdMemo[name];
3017  }
3018  function closestIdRoot(el, name) {
3019    return findClosest(el, (element) => {
3020      if (element._x_ids && element._x_ids[name])
3021        return true;
3022    });
3023  }
3024  function setIdRoot(el, name) {
3025    if (!el._x_ids)
3026      el._x_ids = {};
3027    if (!el._x_ids[name])
3028      el._x_ids[name] = findAndIncrementId(name);
3029  }
3030  magic("id", (el, { cleanup: cleanup2 }) => (name, key = null) => {
3031    let cacheKey = `${name}${key ? `-${key}` : ""}`;
3032    return cacheIdByNameOnElement(el, cacheKey, cleanup2, () => {
3033      let root = closestIdRoot(el, name);
3034      let id = root ? root._x_ids[name] : findAndIncrementId(name);
3035      return key ? `${name}-${id}-${key}` : `${name}-${id}`;
3036    });
3037  });
3038  interceptClone((from, to) => {
3039    if (from._x_id) {
3040      to._x_id = from._x_id;
3041    }
3042  });
3043  function cacheIdByNameOnElement(el, cacheKey, cleanup2, callback) {
3044    if (!el._x_id)
3045      el._x_id = {};
3046    if (el._x_id[cacheKey])
3047      return el._x_id[cacheKey];
3048    let output = callback();
3049    el._x_id[cacheKey] = output;
3050    cleanup2(() => {
3051      delete el._x_id[cacheKey];
3052    });
3053    return output;
3054  }
3055  magic("el", (el) => el);
3056  warnMissingPluginMagic("Focus", "focus", "focus");
3057  warnMissingPluginMagic("Persist", "persist", "persist");
3058  function warnMissingPluginMagic(name, magicName, slug) {
3059    magic(magicName, (el) => warn(`You can't use [$${magicName}] without first installing the "${name}" plugin here: https://alpinejs.dev/plugins/${slug}`, el));
3060  }
3061  directive("modelable", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2, cleanup: cleanup2 }) => {
3062    let func = evaluateLater2(expression);
3063    let innerGet = () => {
3064      let result;
3065      func((i) => result = i);
3066      return result;
3067    };
3068    let evaluateInnerSet = evaluateLater2(`${expression} = __placeholder`);
3069    let innerSet = (val) => evaluateInnerSet(() => {
3070    }, { scope: { "__placeholder": val } });
3071    let initialValue = innerGet();
3072    innerSet(initialValue);
3073    queueMicrotask(() => {
3074      if (!el._x_model)
3075        return;
3076      el._x_removeModelListeners["default"]();
3077      let outerGet = el._x_model.get;
3078      let outerSet = el._x_model.set;
3079      let releaseEntanglement = entangle({
3080        get() {
3081          return outerGet();
3082        },
3083        set(value) {
3084          outerSet(value);
3085        }
3086      }, {
3087        get() {
3088          return innerGet();
3089        },
3090        set(value) {
3091          innerSet(value);
3092        }
3093      });
3094      cleanup2(releaseEntanglement);
3095    });
3096  });
3097  directive("teleport", (el, { modifiers, expression }, { cleanup: cleanup2 }) => {
3098    if (el.tagName.toLowerCase() !== "template")
3099      warn("x-teleport can only be used on a <template> tag", el);
3100    let target = getTarget(expression);
3101    let clone2 = el.content.cloneNode(true).firstElementChild;
3102    el._x_teleport = clone2;
3103    clone2._x_teleportBack = el;
3104    el.setAttribute("data-teleport-template", true);
3105    clone2.setAttribute("data-teleport-target", true);
3106    if (el._x_forwardEvents) {
3107      el._x_forwardEvents.forEach((eventName) => {
3108        clone2.addEventListener(eventName, (e) => {
3109          e.stopPropagation();
3110          el.dispatchEvent(new e.constructor(e.type, e));
3111        });
3112      });
3113    }
3114    addScopeToNode(clone2, {}, el);
3115    let placeInDom = (clone3, target2, modifiers2) => {
3116      if (modifiers2.includes("prepend")) {
3117        target2.parentNode.insertBefore(clone3, target2);
3118      } else if (modifiers2.includes("append")) {
3119        target2.parentNode.insertBefore(clone3, target2.nextSibling);
3120      } else {
3121        target2.appendChild(clone3);
3122      }
3123    };
3124    mutateDom(() => {
3125      placeInDom(clone2, target, modifiers);
3126      skipDuringClone(() => {
3127        initTree(clone2);
3128        clone2._x_ignore = true;
3129      })();
3130    });
3131    el._x_teleportPutBack = () => {
3132      let target2 = getTarget(expression);
3133      mutateDom(() => {
3134        placeInDom(el._x_teleport, target2, modifiers);
3135      });
3136    };
3137    cleanup2(() => clone2.remove());
3138  });
3139  var teleportContainerDuringClone = document.createElement("div");
3140  function getTarget(expression) {
3141    let target = skipDuringClone(() => {
3142      return document.querySelector(expression);
3143    }, () => {
3144      return teleportContainerDuringClone;
3145    })();
3146    if (!target)
3147      warn(`Cannot find x-teleport element for selector: "${expression}"`);
3148    return target;
3149  }
3150  var handler = () => {
3151  };
3152  handler.inline = (el, { modifiers }, { cleanup: cleanup2 }) => {
3153    modifiers.includes("self") ? el._x_ignoreSelf = true : el._x_ignore = true;
3154    cleanup2(() => {
3155      modifiers.includes("self") ? delete el._x_ignoreSelf : delete el._x_ignore;
3156    });
3157  };
3158  directive("ignore", handler);
3159  directive("effect", skipDuringClone((el, { expression }, { effect: effect3 }) => {
3160    effect3(evaluateLater(el, expression));
3161  }));
3162  function on(el, event, modifiers, callback) {
3163    let listenerTarget = el;
3164    let handler4 = (e) => callback(e);
3165    let options = {};
3166    let wrapHandler = (callback2, wrapper) => (e) => wrapper(callback2, e);
3167    if (modifiers.includes("dot"))
3168      event = dotSyntax(event);
3169    if (modifiers.includes("camel"))
3170      event = camelCase2(event);
3171    if (modifiers.includes("passive"))
3172      options.passive = true;
3173    if (modifiers.includes("capture"))
3174      options.capture = true;
3175    if (modifiers.includes("window"))
3176      listenerTarget = window;
3177    if (modifiers.includes("document"))
3178      listenerTarget = document;
3179    if (modifiers.includes("debounce")) {
3180      let nextModifier = modifiers[modifiers.indexOf("debounce") + 1] || "invalid-wait";
3181      let wait = isNumeric(nextModifier.split("ms")[0]) ? Number(nextModifier.split("ms")[0]) : 250;
3182      handler4 = debounce(handler4, wait);
3183    }
3184    if (modifiers.includes("throttle")) {
3185      let nextModifier = modifiers[modifiers.indexOf("throttle") + 1] || "invalid-wait";
3186      let wait = isNumeric(nextModifier.split("ms")[0]) ? Number(nextModifier.split("ms")[0]) : 250;
3187      handler4 = throttle(handler4, wait);
3188    }
3189    if (modifiers.includes("prevent"))
3190      handler4 = wrapHandler(handler4, (next, e) => {
3191        e.preventDefault();
3192        next(e);
3193      });
3194    if (modifiers.includes("stop"))
3195      handler4 = wrapHandler(handler4, (next, e) => {
3196        e.stopPropagation();
3197        next(e);
3198      });
3199    if (modifiers.includes("once")) {
3200      handler4 = wrapHandler(handler4, (next, e) => {
3201        next(e);
3202        listenerTarget.removeEventListener(event, handler4, options);
3203      });
3204    }
3205    if (modifiers.includes("away") || modifiers.includes("outside")) {
3206      listenerTarget = document;
3207      handler4 = wrapHandler(handler4, (next, e) => {
3208        if (el.contains(e.target))
3209          return;
3210        if (e.target.isConnected === false)
3211          return;
3212        if (el.offsetWidth < 1 && el.offsetHeight < 1)
3213          return;
3214        if (el._x_isShown === false)
3215          return;
3216        next(e);
3217      });
3218    }
3219    if (modifiers.includes("self"))
3220      handler4 = wrapHandler(handler4, (next, e) => {
3221        e.target === el && next(e);
3222      });
3223    if (isKeyEvent(event) || isClickEvent(event)) {
3224      handler4 = wrapHandler(handler4, (next, e) => {
3225        if (isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers)) {
3226          return;
3227        }
3228        next(e);
3229      });
3230    }
3231    listenerTarget.addEventListener(event, handler4, options);
3232    return () => {
3233      listenerTarget.removeEventListener(event, handler4, options);
3234    };
3235  }
3236  function dotSyntax(subject) {
3237    return subject.replace(/-/g, ".");
3238  }
3239  function camelCase2(subject) {
3240    return subject.toLowerCase().replace(/-(\w)/g, (match, char) => char.toUpperCase());
3241  }
3242  function isNumeric(subject) {
3243    return !Array.isArray(subject) && !isNaN(subject);
3244  }
3245  function kebabCase2(subject) {
3246    if ([" ", "_"].includes(subject))
3247      return subject;
3248    return subject.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]/, "-").toLowerCase();
3249  }
3250  function isKeyEvent(event) {
3251    return ["keydown", "keyup"].includes(event);
3252  }
3253  function isClickEvent(event) {
3254    return ["contextmenu", "click", "mouse"].some((i) => event.includes(i));
3255  }
3256  function isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers) {
3257    let keyModifiers = modifiers.filter((i) => {
3258      return !["window", "document", "prevent", "stop", "once", "capture", "self", "away", "outside", "passive"].includes(i);
3259    });
3260    if (keyModifiers.includes("debounce")) {
3261      let debounceIndex = keyModifiers.indexOf("debounce");
3262      keyModifiers.splice(debounceIndex, isNumeric((keyModifiers[debounceIndex + 1] || "invalid-wait").split("ms")[0]) ? 2 : 1);
3263    }
3264    if (keyModifiers.includes("throttle")) {
3265      let debounceIndex = keyModifiers.indexOf("throttle");
3266      keyModifiers.splice(debounceIndex, isNumeric((keyModifiers[debounceIndex + 1] || "invalid-wait").split("ms")[0]) ? 2 : 1);
3267    }
3268    if (keyModifiers.length === 0)
3269      return false;
3270    if (keyModifiers.length === 1 && keyToModifiers(e.key).includes(keyModifiers[0]))
3271      return false;
3272    const systemKeyModifiers = ["ctrl", "shift", "alt", "meta", "cmd", "super"];
3273    const selectedSystemKeyModifiers = systemKeyModifiers.filter((modifier) => keyModifiers.includes(modifier));
3274    keyModifiers = keyModifiers.filter((i) => !selectedSystemKeyModifiers.includes(i));
3275    if (selectedSystemKeyModifiers.length > 0) {
3276      const activelyPressedKeyModifiers = selectedSystemKeyModifiers.filter((modifier) => {
3277        if (modifier === "cmd" || modifier === "super")
3278          modifier = "meta";
3279        return e[`${modifier}Key`];
3280      });
3281      if (activelyPressedKeyModifiers.length === selectedSystemKeyModifiers.length) {
3282        if (isClickEvent(e.type))
3283          return false;
3284        if (keyToModifiers(e.key).includes(keyModifiers[0]))
3285          return false;
3286      }
3287    }
3288    return true;
3289  }
3290  function keyToModifiers(key) {
3291    if (!key)
3292      return [];
3293    key = kebabCase2(key);
3294    let modifierToKeyMap = {
3295      "ctrl": "control",
3296      "slash": "/",
3297      "space": " ",
3298      "spacebar": " ",
3299      "cmd": "meta",
3300      "esc": "escape",
3301      "up": "arrow-up",
3302      "down": "arrow-down",
3303      "left": "arrow-left",
3304      "right": "arrow-right",
3305      "period": ".",
3306      "comma": ",",
3307      "equal": "=",
3308      "minus": "-",
3309      "underscore": "_"
3310    };
3311    modifierToKeyMap[key] = key;
3312    return Object.keys(modifierToKeyMap).map((modifier) => {
3313      if (modifierToKeyMap[modifier] === key)
3314        return modifier;
3315    }).filter((modifier) => modifier);
3316  }
3317  directive("model", (el, { modifiers, expression }, { effect: effect3, cleanup: cleanup2 }) => {
3318    let scopeTarget = el;
3319    if (modifiers.includes("parent")) {
3320      scopeTarget = el.parentNode;
3321    }
3322    let evaluateGet = evaluateLater(scopeTarget, expression);
3323    let evaluateSet;
3324    if (typeof expression === "string") {
3325      evaluateSet = evaluateLater(scopeTarget, `${expression} = __placeholder`);
3326    } else if (typeof expression === "function" && typeof expression() === "string") {
3327      evaluateSet = evaluateLater(scopeTarget, `${expression()} = __placeholder`);
3328    } else {
3329      evaluateSet = () => {
3330      };
3331    }
3332    let getValue = () => {
3333      let result;
3334      evaluateGet((value) => result = value);
3335      return isGetterSetter(result) ? result.get() : result;
3336    };
3337    let setValue = (value) => {
3338      let result;
3339      evaluateGet((value2) => result = value2);
3340      if (isGetterSetter(result)) {
3341        result.set(value);
3342      } else {
3343        evaluateSet(() => {
3344        }, {
3345          scope: { "__placeholder": value }
3346        });
3347      }
3348    };
3349    if (typeof expression === "string" && el.type === "radio") {
3350      mutateDom(() => {
3351        if (!el.hasAttribute("name"))
3352          el.setAttribute("name", expression);
3353      });
3354    }
3355    var event = el.tagName.toLowerCase() === "select" || ["checkbox", "radio"].includes(el.type) || modifiers.includes("lazy") ? "change" : "input";
3356    let removeListener = isCloning ? () => {
3357    } : on(el, event, modifiers, (e) => {
3358      setValue(getInputValue(el, modifiers, e, getValue()));
3359    });
3360    if (modifiers.includes("fill")) {
3361      if ([void 0, null, ""].includes(getValue()) || el.type === "checkbox" && Array.isArray(getValue()) || el.tagName.toLowerCase() === "select" && el.multiple) {
3362        setValue(getInputValue(el, modifiers, { target: el }, getValue()));
3363      }
3364    }
3365    if (!el._x_removeModelListeners)
3366      el._x_removeModelListeners = {};
3367    el._x_removeModelListeners["default"] = removeListener;
3368    cleanup2(() => el._x_removeModelListeners["default"]());
3369    if (el.form) {
3370      let removeResetListener = on(el.form, "reset", [], (e) => {
3371        nextTick(() => el._x_model && el._x_model.set(getInputValue(el, modifiers, { target: el }, getValue())));
3372      });
3373      cleanup2(() => removeResetListener());
3374    }
3375    el._x_model = {
3376      get() {
3377        return getValue();
3378      },
3379      set(value) {
3380        setValue(value);
3381      }
3382    };
3383    el._x_forceModelUpdate = (value) => {
3384      if (value === void 0 && typeof expression === "string" && expression.match(/\./))
3385        value = "";
3386      window.fromModel = true;
3387      mutateDom(() => bind(el, "value", value));
3388      delete window.fromModel;
3389    };
3390    effect3(() => {
3391      let value = getValue();
3392      if (modifiers.includes("unintrusive") && document.activeElement.isSameNode(el))
3393        return;
3394      el._x_forceModelUpdate(value);
3395    });
3396  });
3397  function getInputValue(el, modifiers, event, currentValue) {
3398    return mutateDom(() => {
3399      if (event instanceof CustomEvent && event.detail !== void 0)
3400        return event.detail !== null && event.detail !== void 0 ? event.detail : event.target.value;
3401      else if (el.type === "checkbox") {
3402        if (Array.isArray(currentValue)) {
3403          let newValue = null;
3404          if (modifiers.includes("number")) {
3405            newValue = safeParseNumber(event.target.value);
3406          } else if (modifiers.includes("boolean")) {
3407            newValue = safeParseBoolean(event.target.value);
3408          } else {
3409            newValue = event.target.value;
3410          }
3411          return event.target.checked ? currentValue.includes(newValue) ? currentValue : currentValue.concat([newValue]) : currentValue.filter((el2) => !checkedAttrLooseCompare2(el2, newValue));
3412        } else {
3413          return event.target.checked;
3414        }
3415      } else if (el.tagName.toLowerCase() === "select" && el.multiple) {
3416        if (modifiers.includes("number")) {
3417          return Array.from(event.target.selectedOptions).map((option) => {
3418            let rawValue = option.value || option.text;
3419            return safeParseNumber(rawValue);
3420          });
3421        } else if (modifiers.includes("boolean")) {
3422          return Array.from(event.target.selectedOptions).map((option) => {
3423            let rawValue = option.value || option.text;
3424            return safeParseBoolean(rawValue);
3425          });
3426        }
3427        return Array.from(event.target.selectedOptions).map((option) => {
3428          return option.value || option.text;
3429        });
3430      } else {
3431        let newValue;
3432        if (el.type === "radio") {
3433          if (event.target.checked) {
3434            newValue = event.target.value;
3435          } else {
3436            newValue = currentValue;
3437          }
3438        } else {
3439          newValue = event.target.value;
3440        }
3441        if (modifiers.includes("number")) {
3442          return safeParseNumber(newValue);
3443        } else if (modifiers.includes("boolean")) {
3444          return safeParseBoolean(newValue);
3445        } else if (modifiers.includes("trim")) {
3446          return newValue.trim();
3447        } else {
3448          return newValue;
3449        }
3450      }
3451    });
3452  }
3453  function safeParseNumber(rawValue) {
3454    let number = rawValue ? parseFloat(rawValue) : null;
3455    return isNumeric2(number) ? number : rawValue;
3456  }
3457  function checkedAttrLooseCompare2(valueA, valueB) {
3458    return valueA == valueB;
3459  }
3460  function isNumeric2(subject) {
3461    return !Array.isArray(subject) && !isNaN(subject);
3462  }
3463  function isGetterSetter(value) {
3464    return value !== null && typeof value === "object" && typeof value.get === "function" && typeof value.set === "function";
3465  }
3466  directive("cloak", (el) => queueMicrotask(() => mutateDom(() => el.removeAttribute(prefix("cloak")))));
3467  addInitSelector(() => `[${prefix("init")}]`);
3468  directive("init", skipDuringClone((el, { expression }, { evaluate: evaluate22 }) => {
3469    if (typeof expression === "string") {
3470      return !!expression.trim() && evaluate22(expression, {}, false);
3471    }
3472    return evaluate22(expression, {}, false);
3473  }));
3474  directive("text", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2 }) => {
3475    let evaluate22 = evaluateLater2(expression);
3476    effect3(() => {
3477      evaluate22((value) => {
3478        mutateDom(() => {
3479          el.textContent = value;
3480        });
3481      });
3482    });
3483  });
3484  directive("html", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2 }) => {
3485    let evaluate22 = evaluateLater2(expression);
3486    effect3(() => {
3487      evaluate22((value) => {
3488        mutateDom(() => {
3489          el.innerHTML = value;
3490          el._x_ignoreSelf = true;
3491          initTree(el);
3492          delete el._x_ignoreSelf;
3493        });
3494      });
3495    });
3496  });
3497  mapAttributes(startingWith(":", into(prefix("bind:"))));
3498  var handler2 = (el, { value, modifiers, expression, original }, { effect: effect3, cleanup: cleanup2 }) => {
3499    if (!value) {
3500      let bindingProviders = {};
3501      injectBindingProviders(bindingProviders);
3502      let getBindings = evaluateLater(el, expression);
3503      getBindings((bindings) => {
3504        applyBindingsObject(el, bindings, original);
3505      }, { scope: bindingProviders });
3506      return;
3507    }
3508    if (value === "key")
3509      return storeKeyForXFor(el, expression);
3510    if (el._x_inlineBindings && el._x_inlineBindings[value] && el._x_inlineBindings[value].extract) {
3511      return;
3512    }
3513    let evaluate22 = evaluateLater(el, expression);
3514    effect3(() => evaluate22((result) => {
3515      if (result === void 0 && typeof expression === "string" && expression.match(/\./)) {
3516        result = "";
3517      }
3518      mutateDom(() => bind(el, value, result, modifiers));
3519    }));
3520    cleanup2(() => {

3521      el._x_undoAddedClasses && el._x_undoAddedClasses();
3522      el._x_undoAddedStyles && el._x_undoAddedStyles();
3523    });
3524  };
3525  handler2.inline = (el, { value, modifiers, expression }) => {
3526    if (!value)
3527      return;
3528    if (!el._x_inlineBindings)
3529      el._x_inlineBindings = {};
3530    el._x_inlineBindings[value] = { expression, extract: false };
3531  };
3532  directive("bind", handler2);
3533  function storeKeyForXFor(el, expression) {
3534    el._x_keyExpression = expression;
3535  }
3536  addRootSelector(() => `[${prefix("data")}]`);
3537  directive("data", (el, { expression }, { cleanup: cleanup2 }) => {
3538    if (shouldSkipRegisteringDataDuringClone(el))
3539      return;
3540    expression = expression === "" ? "{}" : expression;
3541    let magicContext = {};
3542    injectMagics(magicContext, el);
3543    let dataProviderContext = {};
3544    injectDataProviders(dataProviderContext, magicContext);
3545    let data2 = evaluate(el, expression, { scope: dataProviderContext });
3546    if (data2 === void 0 || data2 === true)
3547      data2 = {};
3548    injectMagics(data2, el);
3549    let reactiveData = reactive(data2);
3550    initInterceptors(reactiveData);
3551    let undo = addScopeToNode(el, reactiveData);
3552    reactiveData["init"] && evaluate(el, reactiveData["init"]);
3553    cleanup2(() => {
3554      reactiveData["destroy"] && evaluate(el, reactiveData["destroy"]);
3555      undo();
3556    });
3557  });
3558  interceptClone((from, to) => {
3559    if (from._x_dataStack) {
3560      to._x_dataStack = from._x_dataStack;
3561      to.setAttribute("data-has-alpine-state", true);
3562    }
3563  });
3564  function shouldSkipRegisteringDataDuringClone(el) {
3565    if (!isCloning)
3566      return false;
3567    if (isCloningLegacy)
3568      return true;
3569    return el.hasAttribute("data-has-alpine-state");
3570  }
3571  directive("show", (el, { modifiers, expression }, { effect: effect3 }) => {
3572    let evaluate22 = evaluateLater(el, expression);
3573    if (!el._x_doHide)
3574      el._x_doHide = () => {
3575        mutateDom(() => {
3576          el.style.setProperty("display", "none", modifiers.includes("important") ? "important" : void 0);
3577        });
3578      };
3579    if (!el._x_doShow)
3580      el._x_doShow = () => {
3581        mutateDom(() => {
3582          if (el.style.length === 1 && el.style.display === "none") {
3583            el.removeAttribute("style");
3584          } else {
3585            el.style.removeProperty("display");
3586          }
3587        });
3588      };
3589    let hide = () => {
3590      el._x_doHide();
3591      el._x_isShown = false;
3592    };
3593    let show = () => {
3594      el._x_doShow();
3595      el._x_isShown = true;
3596    };
3597    let clickAwayCompatibleShow = () => setTimeout(show);
3598    let toggle = once((value) => value ? show() : hide(), (value) => {
3599      if (typeof el._x_toggleAndCascadeWithTransitions === "function") {
3600        el._x_toggleAndCascadeWithTransitions(el, value, show, hide);
3601      } else {
3602        value ? clickAwayCompatibleShow() : hide();
3603      }
3604    });
3605    let oldValue;
3606    let firstTime = true;
3607    effect3(() => evaluate22((value) => {
3608      if (!firstTime && value === oldValue)
3609        return;
3610      if (modifiers.includes("immediate"))
3611        value ? clickAwayCompatibleShow() : hide();
3612      toggle(value);
3613      oldValue = value;
3614      firstTime = false;
3615    }));
3616  });
3617  directive("for", (el, { expression }, { effect: effect3, cleanup: cleanup2 }) => {
3618    let iteratorNames = parseForExpression(expression);
3619    let evaluateItems = evaluateLater(el, iteratorNames.items);
3620    let evaluateKey = evaluateLater(el, el._x_keyExpression || "index");
3621    el._x_prevKeys = [];
3622    el._x_lookup = {};
3623    effect3(() => loop(el, iteratorNames, evaluateItems, evaluateKey));
3624    cleanup2(() => {
3625      Object.values(el._x_lookup).forEach((el2) => el2.remove());
3626      delete el._x_prevKeys;
3627      delete el._x_lookup;
3628    });
3629  });
3630  function loop(el, iteratorNames, evaluateItems, evaluateKey) {
3631    let isObject22 = (i) => typeof i === "object" && !Array.isArray(i);
3632    let templateEl = el;
3633    evaluateItems((items) => {
3634      if (isNumeric3(items) && items >= 0) {
3635        items = Array.from(Array(items).keys(), (i) => i + 1);
3636      }
3637      if (items === void 0)
3638        items = [];
3639      let lookup = el._x_lookup;
3640      let prevKeys = el._x_prevKeys;
3641      let scopes = [];
3642      let keys = [];
3643      if (isObject22(items)) {
3644        items = Object.entries(items).map(([key, value]) => {
3645          let scope2 = getIterationScopeVariables(iteratorNames, value, key, items);
3646          evaluateKey((value2) => {
3647            if (keys.includes(value2))
3648              warn("Duplicate key on x-for", el);
3649            keys.push(value2);
3650          }, { scope: { index: key, ...scope2 } });
3651          scopes.push(scope2);
3652        });
3653      } else {
3654        for (let i = 0; i < items.length; i++) {
3655          let scope2 = getIterationScopeVariables(iteratorNames, items[i], i, items);
3656          evaluateKey((value) => {
3657            if (keys.includes(value))
3658              warn("Duplicate key on x-for", el);
3659            keys.push(value);
3660          }, { scope: { index: i, ...scope2 } });
3661          scopes.push(scope2);
3662        }
3663      }
3664      let adds = [];
3665      let moves = [];
3666      let removes = [];
3667      let sames = [];
3668      for (let i = 0; i < prevKeys.length; i++) {
3669        let key = prevKeys[i];
3670        if (keys.indexOf(key) === -1)
3671          removes.push(key);
3672      }
3673      prevKeys = prevKeys.filter((key) => !removes.includes(key));
3674      let lastKey = "template";
3675      for (let i = 0; i < keys.length; i++) {
3676        let key = keys[i];
3677        let prevIndex = prevKeys.indexOf(key);
3678        if (prevIndex === -1) {
3679          prevKeys.splice(i, 0, key);
3680          adds.push([lastKey, i]);
3681        } else if (prevIndex !== i) {
3682          let keyInSpot = prevKeys.splice(i, 1)[0];
3683          let keyForSpot = prevKeys.splice(prevIndex - 1, 1)[0];
3684          prevKeys.splice(i, 0, keyForSpot);
3685          prevKeys.splice(prevIndex, 0, keyInSpot);
3686          moves.push([keyInSpot, keyForSpot]);
3687        } else {
3688          sames.push(key);
3689        }
3690        lastKey = key;
3691      }
3692      for (let i = 0; i < removes.length; i++) {
3693        let key = removes[i];
3694        if (!!lookup[key]._x_effects) {

3695          lookup[key]._x_effects.forEach(dequeueJob);
3696        }
3697        lookup[key].remove();
3698        lookup[key] = null;
3699        delete lookup[key];
3700      }
3701      for (let i = 0; i < moves.length; i++) {
3702        let [keyInSpot, keyForSpot] = moves[i];
3703        let elInSpot = lookup[keyInSpot];
3704        let elForSpot = lookup[keyForSpot];
3705        let marker = document.createElement("div");
3706        mutateDom(() => {
3707          if (!elForSpot)
3708            warn(`x-for ":key" is undefined or invalid`, templateEl, keyForSpot, lookup);
3709          elForSpot.after(marker);
3710          elInSpot.after(elForSpot);
3711          elForSpot._x_currentIfEl && elForSpot.after(elForSpot._x_currentIfEl);
3712          marker.before(elInSpot);
3713          elInSpot._x_currentIfEl && elInSpot.after(elInSpot._x_currentIfEl);
3714          marker.remove();
3715        });
3716        elForSpot._x_refreshXForScope(scopes[keys.indexOf(keyForSpot)]);
3717      }
3718      for (let i = 0; i < adds.length; i++) {
3719        let [lastKey2, index] = adds[i];
3720        let lastEl = lastKey2 === "template" ? templateEl : lookup[lastKey2];
3721        if (lastEl._x_currentIfEl)
3722          lastEl = lastEl._x_currentIfEl;
3723        let scope2 = scopes[index];
3724        let key = keys[index];
3725        let clone2 = document.importNode(templateEl.content, true).firstElementChild;
3726        let reactiveScope = reactive(scope2);
3727        addScopeToNode(clone2, reactiveScope, templateEl);
3728        clone2._x_refreshXForScope = (newScope) => {
3729          Object.entries(newScope).forEach(([key2, value]) => {
3730            reactiveScope[key2] = value;
3731          });
3732        };
3733        mutateDom(() => {
3734          lastEl.after(clone2);
3735          skipDuringClone(() => initTree(clone2))();
3736        });
3737        if (typeof key === "object") {
3738          warn("x-for key cannot be an object, it must be a string or an integer", templateEl);
3739        }
3740        lookup[key] = clone2;
3741      }
3742      for (let i = 0; i < sames.length; i++) {
3743        lookup[sames[i]]._x_refreshXForScope(scopes[keys.indexOf(sames[i])]);
3744      }
3745      templateEl._x_prevKeys = keys;
3746    });
3747  }
3748  function parseForExpression(expression) {
3749    let forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
3750    let stripParensRE = /^\s*\(|\)\s*$/g;
3751    let forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
3752    let inMatch = expression.match(forAliasRE);
3753    if (!inMatch)
3754      return;
3755    let res = {};
3756    res.items = inMatch[2].trim();
3757    let item = inMatch[1].replace(stripParensRE, "").trim();
3758    let iteratorMatch = item.match(forIteratorRE);
3759    if (iteratorMatch) {
3760      res.item = item.replace(forIteratorRE, "").trim();
3761      res.index = iteratorMatch[1].trim();
3762      if (iteratorMatch[2]) {
3763        res.collection = iteratorMatch[2].trim();
3764      }
3765    } else {
3766      res.item = item;
3767    }
3768    return res;
3769  }
3770  function getIterationScopeVariables(iteratorNames, item, index, items) {
3771    let scopeVariables = {};
3772    if (/^\[.*\]$/.test(iteratorNames.item) && Array.isArray(item)) {
3773      let names = iteratorNames.item.replace("[", "").replace("]", "").split(",").map((i) => i.trim());
3774      names.forEach((name, i) => {
3775        scopeVariables[name] = item[i];
3776      });
3777    } else if (/^\{.*\}$/.test(iteratorNames.item) && !Array.isArray(item) && typeof item === "object") {
3778      let names = iteratorNames.item.replace("{", "").replace("}", "").split(",").map((i) => i.trim());
3779      names.forEach((name) => {
3780        scopeVariables[name] = item[name];
3781      });
3782    } else {
3783      scopeVariables[iteratorNames.item] = item;
3784    }
3785    if (iteratorNames.index)
3786      scopeVariables[iteratorNames.index] = index;
3787    if (iteratorNames.collection)
3788      scopeVariables[iteratorNames.collection] = items;
3789    return scopeVariables;
3790  }
3791  function isNumeric3(subject) {
3792    return !Array.isArray(subject) && !isNaN(subject);
3793  }
3794  function handler3() {
3795  }
3796  handler3.inline = (el, { expression }, { cleanup: cleanup2 }) => {
3797    let root = closestRoot(el);
3798    if (!root._x_refs)
3799      root._x_refs = {};
3800    root._x_refs[expression] = el;
3801    cleanup2(() => delete root._x_refs[expression]);
3802  };
3803  directive("ref", handler3);
3804  directive("if", (el, { expression }, { effect: effect3, cleanup: cleanup2 }) => {
3805    if (el.tagName.toLowerCase() !== "template")
3806      warn("x-if can only be used on a <template> tag", el);
3807    let evaluate22 = evaluateLater(el, expression);
3808    let show = () => {
3809      if (el._x_currentIfEl)
3810        return el._x_currentIfEl;
3811      let clone2 = el.content.cloneNode(true).firstElementChild;
3812      addScopeToNode(clone2, {}, el);
3813      mutateDom(() => {
3814        el.after(clone2);
3815        skipDuringClone(() => initTree(clone2))();
3816      });
3817      el._x_currentIfEl = clone2;
3818      el._x_undoIf = () => {
3819        walk(clone2, (node) => {
3820          if (!!node._x_effects) {

3821            node._x_effects.forEach(dequeueJob);
3822          }
3823        });
3824        clone2.remove();
3825        delete el._x_currentIfEl;
3826      };
3827      return clone2;
3828    };
3829    let hide = () => {
3830      if (!el._x_undoIf)
3831        return;
3832      el._x_undoIf();
3833      delete el._x_undoIf;
3834    };
3835    effect3(() => evaluate22((value) => {
3836      value ? show() : hide();
3837    }));
3838    cleanup2(() => el._x_undoIf && el._x_undoIf());
3839  });
3840  directive("id", (el, { expression }, { evaluate: evaluate22 }) => {
3841    let names = evaluate22(expression);
3842    names.forEach((name) => setIdRoot(el, name));
3843  });
3844  interceptClone((from, to) => {
3845    if (from._x_ids) {
3846      to._x_ids = from._x_ids;
3847    }
3848  });
3849  mapAttributes(startingWith("@", into(prefix("on:"))));
3850  directive("on", skipDuringClone((el, { value, modifiers, expression }, { cleanup: cleanup2 }) => {
3851    let evaluate22 = expression ? evaluateLater(el, expression) : () => {
3852    };
3853    if (el.tagName.toLowerCase() === "template") {
3854      if (!el._x_forwardEvents)
3855        el._x_forwardEvents = [];
3856      if (!el._x_forwardEvents.includes(value))
3857        el._x_forwardEvents.push(value);
3858    }
3859    let removeListener = on(el, value, modifiers, (e) => {
3860      evaluate22(() => {
3861      }, { scope: { "$event": e }, params: [e] });
3862    });
3863    cleanup2(() => removeListener());
3864  }));
3865  warnMissingPluginDirective("Collapse", "collapse", "collapse");
3866  warnMissingPluginDirective("Intersect", "intersect", "intersect");
3867  warnMissingPluginDirective("Focus", "trap", "focus");
3868  warnMissingPluginDirective("Mask", "mask", "mask");
3869  function warnMissingPluginDirective(name, directiveName, slug) {
3870    directive(directiveName, (el) => warn(`You can't use [x-${directiveName}] without first installing the "${name}" plugin here: https://alpinejs.dev/plugins/${slug}`, el));
3871  }
3872  alpine_default.setEvaluator(normalEvaluator);
3873  alpine_default.setReactivityEngine({ reactive: reactive2, effect: effect2, release: stop, raw: toRaw });
3874  var src_default = alpine_default;
3875  var module_default = src_default;
3876
3877

3877// js/features/supportEntangle.js
3878  function generateEntangleFunction(component, cleanup2) {
3879    if (!cleanup2)
3880      cleanup2 = () => {
3881      };
3882    return (name, live = false) => {
3883      let isLive = live;
3884      let livewireProperty = name;
3885      let livewireComponent = component.$wire;
3886      let livewirePropertyValue = livewireComponent.get(livewireProperty);
3887      let interceptor2 = module_default.interceptor((initialValue, getter, setter, path, key) => {
3888        if (typeof livewirePropertyValue === "undefined") {
3889          console.error(`Livewire Entangle Error: Livewire property ['${livewireProperty}'] cannot be found on component: ['${component.name}']`);
3890          return;
3891        }
3892        let release2 = module_default.entangle({
3893          get() {
3894            return livewireComponent.get(name);
3895          },
3896          set(value) {
3897            livewireComponent.set(name, value, isLive);
3898          }
3899        }, {
3900          get() {
3901            return getter();
3902          },
3903          set(value) {
3904            setter(value);
3905          }
3906        });
3907        cleanup2(() => release2());
3908        return cloneIfObject2(livewireComponent.get(name));
3909      }, (obj) => {
3910        Object.defineProperty(obj, "live", {
3911          get() {
3912            isLive = true;
3913            return obj;
3914          }
3915        });
3916      });
3917      return interceptor2(livewirePropertyValue);
3918    };
3919  }
3920  function cloneIfObject2(value) {
3921    return typeof value === "object" ? JSON.parse(JSON.stringify(value)) : value;
3922  }
3923
3924

3924// js/hooks.js
3925  var listeners = [];
3926  function on2(name, callback) {
3927    if (!listeners[name])
3928      listeners[name] = [];
3929    listeners[name].push(callback);
3930    return () => {
3931      listeners[name] = listeners[name].filter((i) => i !== callback);
3932    };
3933  }
3934  function trigger2(name, ...params) {
3935    let callbacks = listeners[name] || [];
3936    let finishers = [];
3937    for (let i = 0; i < callbacks.length; i++) {
3938      let finisher = callbacks[i](...params);
3939      if (isFunction(finisher))
3940        finishers.push(finisher);
3941    }
3942    return (result) => {
3943      return runFinishers(finishers, result);
3944    };
3945  }
3946  async function triggerAsync(name, ...params) {
3947    let callbacks = listeners[name] || [];
3948    let finishers = [];
3949    for (let i = 0; i < callbacks.length; i++) {
3950      let finisher = await callbacks[i](...params);
3951      if (isFunction(finisher))
3952        finishers.push(finisher);
3953    }
3954    return (result) => {
3955      return runFinishers(finishers, result);
3956    };
3957  }
3958  function runFinishers(finishers, result) {
3959    let latest = result;
3960    for (let i = 0; i < finishers.length; i++) {
3961      let iResult = finishers[i](latest);
3962      if (iResult !== void 0) {
3963        latest = iResult;
3964      }
3965    }
3966    return latest;
3967  }
3968
3969

3969// js/request/modal.js
3970  function showHtmlModal(html) {
3971    let page = document.createElement("html");
3972    page.innerHTML = html;
3973    page.querySelectorAll("a").forEach((a) => a.setAttribute("target", "_top"));
3974    let modal = document.getElementById("livewire-error");
3975    if (typeof modal != "undefined" && modal != null) {
3976      modal.innerHTML = "";
3977    } else {
3978      modal = document.createElement("div");
3979      modal.id = "livewire-error";
3980      modal.style.position = "fixed";
3981      modal.style.width = "100vw";
3982      modal.style.height = "100vh";
3983      modal.style.padding = "50px";
3984      modal.style.backgroundColor = "rgba(0, 0, 0, .6)";
3985      modal.style.zIndex = 2e5;
3986    }
3987    let iframe = document.createElement("iframe");
3988    iframe.style.backgroundColor = "#17161A";
3989    iframe.style.borderRadius = "5px";
3990    iframe.style.width = "100%";
3991    iframe.style.height = "100%";
3992    modal.appendChild(iframe);
3993    document.body.prepend(modal);
3994    document.body.style.overflow = "hidden";
3995    iframe.contentWindow.document.open();
3996    iframe.contentWindow.document.write(page.outerHTML);
3997    iframe.contentWindow.document.close();
3998    modal.addEventListener("click", () => hideHtmlModal(modal));
3999    modal.setAttribute("tabindex", 0);
4000    modal.addEventListener("keydown", (e) => {
4001      if (e.key === "Escape")
4002        hideHtmlModal(modal);
4003    });
4004    modal.focus();
4005  }
4006  function hideHtmlModal(modal) {
4007    modal.outerHTML = "";
4008    document.body.style.overflow = "visible";
4009  }
4010
4011

4011// js/request/pool.js
4012  var RequestPool = class {
4013    constructor() {
4014      this.commits = /* @__PURE__ */ new Set();
4015    }
4016    add(commit) {
4017      this.commits.add(commit);
4018    }
4019    delete(commit) {
4020      this.commits.delete(commit);
4021    }
4022    hasCommitFor(component) {
4023      return !!this.findCommitByComponent(component);
4024    }
4025    findCommitByComponent(component) {
4026      for (let [idx, commit] of this.commits.entries()) {
4027        if (commit.component === component)
4028          return commit;
4029      }
4030    }
4031    shouldHoldCommit(commit) {
4032      return !commit.isolate;
4033    }
4034    empty() {
4035      return this.commits.size === 0;
4036    }
4037    async send() {
4038      this.prepare();
4039      await sendRequest(this);
4040    }
4041    prepare() {
4042      this.commits.forEach((i) => i.prepare());
4043    }
4044    payload() {
4045      let commitPayloads = [];
4046      let successReceivers = [];
4047      let failureReceivers = [];
4048      this.commits.forEach((commit) => {
4049        let [payload, succeed2, fail2] = commit.toRequestPayload();
4050        commitPayloads.push(payload);
4051        successReceivers.push(succeed2);
4052        failureReceivers.push(fail2);
4053      });
4054      let succeed = (components2) => successReceivers.forEach((receiver) => receiver(components2.shift()));
4055      let fail = () => failureReceivers.forEach((receiver) => receiver());
4056      return [commitPayloads, succeed, fail];
4057    }
4058  };
4059
4060

4060// js/request/commit.js
4061  var Commit = class {
4062    constructor(component) {
4063      this.component = component;
4064      this.isolate = false;
4065      this.calls = [];
4066      this.receivers = [];
4067      this.resolvers = [];
4068    }
4069    addResolver(resolver) {
4070      this.resolvers.push(resolver);
4071    }
4072    addCall(method, params, receiver) {
4073      this.calls.push({
4074        path: "",
4075        method,
4076        params,
4077        handleReturn(value) {
4078          receiver(value);
4079        }
4080      });
4081    }
4082    prepare() {
4083      trigger2("commit.prepare", { component: this.component });
4084    }
4085    toRequestPayload() {
4086      let propertiesDiff = diff(this.component.canonical, this.component.ephemeral);
4087      let updates = this.component.mergeQueuedUpdates(propertiesDiff);
4088      let payload = {
4089        snapshot: this.component.snapshotEncoded,
4090        updates,
4091        calls: this.calls.map((i) => ({
4092          path: i.path,
4093          method: i.method,
4094          params: i.params
4095        }))
4096      };
4097      let succeedCallbacks = [];
4098      let failCallbacks = [];
4099      let respondCallbacks = [];
4100      let succeed = (fwd) => succeedCallbacks.forEach((i) => i(fwd));
4101      let fail = () => failCallbacks.forEach((i) => i());
4102      let respond = () => respondCallbacks.forEach((i) => i());
4103      let finishTarget = trigger2("commit", {
4104        component: this.component,
4105        commit: payload,
4106        succeed: (callback) => {
4107          succeedCallbacks.push(callback);
4108        },
4109        fail: (callback) => {
4110          failCallbacks.push(callback);
4111        },
4112        respond: (callback) => {
4113          respondCallbacks.push(callback);
4114        }
4115      });
4116      let handleResponse = (response) => {
4117        let { snapshot, effects } = response;
4118        respond();
4119        this.component.mergeNewSnapshot(snapshot, effects, updates);
4120        this.component.processEffects(this.component.effects);
4121        if (effects["returns"]) {
4122          let returns = effects["returns"];
4123          let returnHandlerStack = this.calls.map(({ handleReturn }) => handleReturn);
4124          returnHandlerStack.forEach((handleReturn, index) => {
4125            handleReturn(returns[index]);
4126          });
4127        }
4128        let parsedSnapshot = JSON.parse(snapshot);
4129        finishTarget({ snapshot: parsedSnapshot, effects });
4130        this.resolvers.forEach((i) => i());
4131        succeed(response);
4132      };
4133      let handleFailure = () => {
4134        respond();
4135        fail();
4136      };
4137      return [payload, handleResponse, handleFailure];
4138    }
4139  };
4140
4141

4141// js/request/bus.js
4142  var CommitBus = class {
4143    constructor() {
4144      this.commits = /* @__PURE__ */ new Set();
4145      this.pools = /* @__PURE__ */ new Set();
4146    }
4147    add(component) {
4148      let commit = this.findCommitOr(component, () => {
4149        let newCommit = new Commit(component);
4150        this.commits.add(newCommit);
4151        return newCommit;
4152      });
4153      bufferPoolingForFiveMs(commit, () => {
4154        let pool = this.findPoolWithComponent(commit.component);
4155        if (!pool) {
4156          this.createAndSendNewPool();
4157        }
4158      });
4159      return commit;
4160    }
4161    findCommitOr(component, callback) {
4162      for (let [idx, commit] of this.commits.entries()) {
4163        if (commit.component === component) {
4164          return commit;
4165        }
4166      }
4167      return callback();
4168    }
4169    findPoolWithComponent(component) {
4170      for (let [idx, pool] of this.pools.entries()) {
4171        if (pool.hasCommitFor(component))
4172          return pool;
4173      }
4174    }
4175    createAndSendNewPool() {
4176      trigger2("commit.pooling", { commits: this.commits });
4177      let pools = this.corraleCommitsIntoPools();
4178      this.commits.clear();
4179      trigger2("commit.pooled", { pools });
4180      pools.forEach((pool) => {
4181        if (pool.empty())
4182          return;
4183        this.pools.add(pool);
4184        pool.send().then(() => {
4185          this.pools.delete(pool);
4186          this.sendAnyQueuedCommits();
4187        });
4188      });
4189    }
4190    corraleCommitsIntoPools() {
4191      let pools = /* @__PURE__ */ new Set();
4192      for (let [idx, commit] of this.commits.entries()) {
4193        let hasFoundPool = false;

4194        pools.forEach((pool) => {
4195          if (pool.shouldHoldCommit(commit)) {
4196            pool.add(commit);
4197            hasFoundPool = true;
4198          }
4199        });
4200        if (!hasFoundPool) {
4201          let newPool = new RequestPool();
4202          newPool.add(commit);
4203          pools.add(newPool);
4204        }
4205      }
4206      return pools;
4207    }
4208    sendAnyQueuedCommits() {
4209      if (this.commits.size > 0) {
4210        this.createAndSendNewPool();
4211      }
4212    }
4213  };
4214  var buffersByCommit = /* @__PURE__ */ new WeakMap();
4215  function bufferPoolingForFiveMs(commit, callback) {
4216    if (buffersByCommit.has(commit))
4217      return;
4218    buffersByCommit.set(commit, setTimeout(() => {
4219      callback();
4220      buffersByCommit.delete(commit);
4221    }, 5));
4222  }
4223
4224

4224// js/request/index.js
4225  var commitBus = new CommitBus();
4226  async function requestCommit(component) {
4227    let commit = commitBus.add(component);
4228    let promise = new Promise((resolve) => {
4229      commit.addResolver(resolve);
4230    });
4231    promise.commit = commit;
4232    return promise;
4233  }
4234  async function requestCall(component, method, params) {
4235    let commit = commitBus.add(component);
4236    let promise = new Promise((resolve) => {
4237      commit.addCall(method, params, (value) => resolve(value));
4238    });
4239    promise.commit = commit;
4240    return promise;
4241  }
4242  async function sendRequest(pool) {
4243    let [payload, handleSuccess, handleFailure] = pool.payload();
4244    let options = {
4245      method: "POST",
4246      body: JSON.stringify({
4247        _token: getCsrfToken(),
4248        components: payload
4249      }),
4250      headers: {
4251        "Content-type": "application/json",
4252        "X-Livewire": ""
4253      }
4254    };
4255    let succeedCallbacks = [];
4256    let failCallbacks = [];
4257    let respondCallbacks = [];
4258    let succeed = (fwd) => succeedCallbacks.forEach((i) => i(fwd));
4259    let fail = (fwd) => failCallbacks.forEach((i) => i(fwd));
4260    let respond = (fwd) => respondCallbacks.forEach((i) => i(fwd));
4261    let finishProfile = trigger2("request.profile", options);
4262    let updateUri = getUpdateUri();
4263    trigger2("request", {
4264      url: updateUri,
4265      options,
4266      payload: options.body,
4267      respond: (i) => respondCallbacks.push(i),
4268      succeed: (i) => succeedCallbacks.push(i),
4269      fail: (i) => failCallbacks.push(i)
4270    });
4271    let response;
4272    try {
4273      response = await fetch(updateUri, options);
4274    } catch (e) {
4275      finishProfile({ content: "{}", failed: true });
4276      handleFailure();
4277      fail({
4278        status: 503,
4279        content: null,
4280        preventDefault: () => {
4281        }
4282      });
4283      return;
4284    }
4285    let mutableObject = {
4286      status: response.status,
4287      response
4288    };
4289    respond(mutableObject);
4290    response = mutableObject.response;
4291    let content = await response.text();
4292    if (!response.ok) {
4293      finishProfile({ content: "{}", failed: true });
4294      let preventDefault = false;

4295      handleFailure();
4296      fail({
4297        status: response.status,
4298        content,
4299        preventDefault: () => preventDefault = true
4300      });
4301      if (preventDefault)
4302        return;
4303      if (response.status === 419) {
4304        handlePageExpiry();
4305      }
4306      return showFailureModal(content);
4307    }
4308    if (response.redirected) {
4309      window.location.href = response.url;
4310    }
4311    if (contentIsFromDump(content)) {
4312      let dump;
4313      [dump, content] = splitDumpFromContent(content);
4314      showHtmlModal(dump);
4315      finishProfile({ content: "{}", failed: true });
4316    } else {
4317      finishProfile({ content, failed: false });
4318    }
4319    let { components: components2, assets } = JSON.parse(content);
4320    await triggerAsync("payload.intercept", { components: components2, assets });
4321    await handleSuccess(components2);
4322    succeed({ status: response.status, json: JSON.parse(content) });
4323  }
4324  function handlePageExpiry() {
4325    confirm("This page has expired.\nWould you like to refresh the page?") && window.location.reload();
4326  }
4327  function showFailureModal(content) {
4328    let html = content;
4329    showHtmlModal(html);
4330  }
4331
4332  // js/$wire.js
4333  var properties = {};
4334  var fallback;
4335  function wireProperty(name, callback, component = null) {
4336    properties[name] = callback;
4337  }
4338  function wireFallback(callback) {
4339    fallback = callback;
4340  }
4341  var aliases = {
4342    "on": "$on",
4343    "el": "$el",
4344    "id": "$id",
4345    "get": "$get",
4346    "set": "$set",
4347    "call": "$call",
4348    "commit": "$commit",
4349    "watch": "$watch",
4350    "entangle": "$entangle",
4351    "dispatch": "$dispatch",
4352    "dispatchTo": "$dispatchTo",
4353    "dispatchSelf": "$dispatchSelf",
4354    "upload": "$upload",
4355    "uploadMultiple": "$uploadMultiple",
4356    "removeUpload": "$removeUpload",
4357    "cancelUpload": "$cancelUpload"
4358  };
4359  function generateWireObject(component, state) {
4360    return new Proxy({}, {
4361      get(target, property) {
4362        if (property === "__instance")
4363          return component;
4364        if (property in aliases) {
4365          return getProperty(component, aliases[property]);
4366        } else if (property in properties) {
4367          return getProperty(component, property);
4368        } else if (property in state) {
4369          return state[property];
4370        } else if (!["then"].includes(property)) {
4371          return getFallback(component)(property);
4372        }
4373      },
4374      set(target, property, value) {
4375        if (property in state) {
4376          state[property] = value;
4377        }
4378        return true;
4379      }
4380    });
4381  }
4382  function getProperty(component, name) {
4383    return properties[name](component);
4384  }
4385  function getFallback(component) {
4386    return fallback(component);
4387  }
4388  module_default.magic("wire", (el, { cleanup: cleanup2 }) => {

4389    let component;
4390    return new Proxy({}, {
4391      get(target, property) {
4392        if (!component)
4393          component = closestComponent(el);
4394        if (["$entangle", "entangle"].includes(property)) {
4395          return generateEntangleFunction(component, cleanup2);
4396        }
4397        return component.$wire[property];
4398      },
4399      set(target, property, value) {
4400        if (!component)
4401          component = closestComponent(el);
4402        component.$wire[property] = value;
4403        return true;
4404      }
4405    });
4406  });
4407  wireProperty("__instance", (component) => component);
4408  wireProperty("$get", (component) => (property, reactive3 = true) => dataGet(reactive3 ? component.reactive : component.ephemeral, property));
4409  wireProperty("$el", (component) => {
4410    return component.el;
4411  });
4412  wireProperty("$id", (component) => {
4413    return component.id;
4414  });
4415  wireProperty("$set", (component) => async (property, value, live = true) => {
4416    dataSet(component.reactive, property, value);
4417    if (live) {
4418      component.queueUpdate(property, value);
4419      return await requestCommit(component);
4420    }
4421    return Promise.resolve();
4422  });
4423  wireProperty("$call", (component) => async (method, ...params) => {
4424    return await component.$wire[method](...params);
4425  });
4426  wireProperty("$entangle", (component) => (name, live = false) => {
4427    return generateEntangleFunction(component)(name, live);
4428  });
4429  wireProperty("$toggle", (component) => (name, live = true) => {
4430    return component.$wire.set(name, !component.$wire.get(name), live);
4431  });
4432  wireProperty("$watch", (component) => (path, callback) => {
4433    let getter = () => {
4434      return dataGet(component.reactive, path);
4435    };
4436    let unwatch = module_default.watch(getter, callback);
4437    component.addCleanup(unwatch);
4438  });
4439  wireProperty("$refresh", (component) => component.$wire.$commit);
4440  wireProperty("$commit", (component) => async () => await requestCommit(component));
4441  wireProperty("$on", (component) => (...params) => listen2(component, ...params));
4442  wireProperty("$dispatch", (component) => (...params) => dispatch3(component, ...params));
4443  wireProperty("$dispatchSelf", (component) => (...params) => dispatchSelf(component, ...params));
4444  wireProperty("$dispatchTo", () => (...params) => dispatchTo(...params));
4445  wireProperty("$upload", (component) => (...params) => upload(component, ...params));
4446  wireProperty("$uploadMultiple", (component) => (...params) => uploadMultiple(component, ...params));
4447  wireProperty("$removeUpload", (component) => (...params) => removeUpload(component, ...params));
4448  wireProperty("$cancelUpload", (component) => (...params) => cancelUpload(component, ...params));
4449  var parentMemo = /* @__PURE__ */ new WeakMap();
4450  wireProperty("$parent", (component) => {
4451    if (parentMemo.has(component))
4452      return parentMemo.get(component).$wire;
4453    let parent = component.parent;
4454    parentMemo.set(component, parent);
4455    return parent.$wire;
4456  });
4457  var overriddenMethods = /* @__PURE__ */ new WeakMap();
4458  function overrideMethod(component, method, callback) {
4459    if (!overriddenMethods.has(component)) {
4460      overriddenMethods.set(component, {});
4461    }
4462    let obj = overriddenMethods.get(component);
4463    obj[method] = callback;
4464    overriddenMethods.set(component, obj);
4465  }
4466  wireFallback((component) => (property) => async (...params) => {
4467    if (params.length === 1 && params[0] instanceof Event) {
4468      params = [];
4469    }
4470    if (overriddenMethods.has(component)) {
4471      let overrides = overriddenMethods.get(component);
4472      if (typeof overrides[property] === "function") {
4473        return overrides[property](params);
4474      }
4475    }
4476    return await requestCall(component, property, params);
4477  });
4478
4479

4479// js/component.js
4480  var Component = class {
4481    constructor(el) {
4482      if (el.__livewire)
4483        throw "Component already initialized";
4484      el.__livewire = this;
4485      this.el = el;
4486      this.id = el.getAttribute("wire:id");
4487      this.__livewireId = this.id;
4488      this.snapshotEncoded = el.getAttribute("wire:snapshot");
4489      this.snapshot = JSON.parse(this.snapshotEncoded);
4490      if (!this.snapshot) {
4491        throw `Snapshot missing on Livewire component with id: ` + this.id;
4492      }
4493      this.name = this.snapshot.memo.name;
4494      this.effects = JSON.parse(el.getAttribute("wire:effects"));
4495      this.originalEffects = deepClone(this.effects);
4496      this.canonical = extractData(deepClone(this.snapshot.data));
4497      this.ephemeral = extractData(deepClone(this.snapshot.data));
4498      this.reactive = Alpine.reactive(this.ephemeral);
4499      this.queuedUpdates = {};
4500      this.$wire = generateWireObject(this, this.reactive);
4501      this.cleanups = [];
4502      this.processEffects(this.effects);
4503    }
4504    mergeNewSnapshot(snapshotEncoded, effects, updates = {}) {
4505      let snapshot = JSON.parse(snapshotEncoded);
4506      let oldCanonical = deepClone(this.canonical);
4507      let updatedOldCanonical = this.applyUpdates(oldCanonical, updates);
4508      let newCanonical = extractData(deepClone(snapshot.data));
4509      let dirty = diff(updatedOldCanonical, newCanonical);
4510      this.snapshotEncoded = snapshotEncoded;
4511      this.snapshot = snapshot;
4512      this.effects = effects;
4513      this.canonical = extractData(deepClone(snapshot.data));
4514      let newData = extractData(deepClone(snapshot.data));
4515      Object.entries(dirty).forEach(([key, value]) => {
4516        let rootKey = key.split(".")[0];
4517        this.reactive[rootKey] = newData[rootKey];
4518      });
4519      return dirty;
4520    }
4521    queueUpdate(propertyName, value) {
4522      this.queuedUpdates[propertyName] = value;
4523    }
4524    mergeQueuedUpdates(diff2) {
4525      Object.entries(this.queuedUpdates).forEach(([updateKey, updateValue]) => {
4526        Object.entries(diff2).forEach(([diffKey, diffValue]) => {
4527          if (diffKey.startsWith(updateValue)) {
4528            delete diff2[diffKey];
4529          }
4530        });
4531        diff2[updateKey] = updateValue;
4532      });
4533      this.queuedUpdates = [];
4534      return diff2;
4535    }
4536    applyUpdates(object, updates) {
4537      for (let key in updates) {
4538        dataSet(object, key, updates[key]);
4539      }
4540      return object;
4541    }
4542    replayUpdate(snapshot, html) {
4543      let effects = { ...this.effects, html };
4544      this.mergeNewSnapshot(JSON.stringify(snapshot), effects);
4545      this.processEffects({ html });
4546    }
4547    processEffects(effects) {
4548      trigger2("effects", this, effects);
4549      trigger2("effect", {
4550        component: this,
4551        effects,
4552        cleanup: (i) => this.addCleanup(i)
4553      });
4554    }
4555    get children() {
4556      let meta = this.snapshot.memo;
4557      let childIds = Object.values(meta.children).map((i) => i[1]);
4558      return childIds.map((id) => findComponent(id));
4559    }
4560    get parent() {
4561      return closestComponent(this.el.parentElement);
4562    }
4563    inscribeSnapshotAndEffectsOnElement() {
4564      let el = this.el;
4565      el.setAttribute("wire:snapshot", this.snapshotEncoded);
4566      let effects = this.originalEffects.listeners ? { listeners: this.originalEffects.listeners } : {};
4567      if (this.originalEffects.url) {
4568        effects.url = this.originalEffects.url;
4569      }
4570      el.setAttribute("wire:effects", JSON.stringify(effects));
4571    }
4572    addCleanup(cleanup2) {
4573      this.cleanups.push(cleanup2);
4574    }
4575    cleanup() {
4576      delete this.el.__livewire;
4577      while (this.cleanups.length > 0) {
4578        this.cleanups.pop()();
4579      }
4580    }
4581  };
4582
4583

4583// js/store.js
4584  var components = {};
4585  function initComponent(el) {
4586    let component = new Component(el);
4587    if (components[component.id])
4588      throw "Component already registered";
4589    let cleanup2 = (i) => component.addCleanup(i);
4590    trigger2("component.init", { component, cleanup: cleanup2 });
4591    components[component.id] = component;
4592    return component;
4593  }
4594  function destroyComponent(id) {
4595    let component = components[id];
4596    if (!component)
4597      return;
4598    component.cleanup();
4599    delete components[id];
4600  }
4601  function findComponent(id) {
4602    let component = components[id];
4603    if (!component)
4604      throw "Component not found: " + id;
4605    return component;
4606  }
4607  function closestComponent(el, strict = true) {
4608    let closestRoot2 = Alpine.findClosest(el, (i) => i.__livewire);
4609    if (!closestRoot2) {
4610      if (strict)
4611        throw "Could not find Livewire component in DOM tree";
4612      return;
4613    }
4614    return closestRoot2.__livewire;
4615  }
4616  function componentsByName(name) {
4617    return Object.values(components).filter((component) => {
4618      return name == component.name;
4619    });
4620  }
4621  function getByName(name) {
4622    return componentsByName(name).map((i) => i.$wire);
4623  }
4624  function find(id) {

4625    let component = components[id];
4626    return component && component.$wire;
4627  }
4628  function first() {
4629    return Object.values(components)[0].$wire;
4630  }
4631  function all() {
4632    return Object.values(components);
4633  }
4634
4635

4635// js/events.js
4636  function dispatch3(component, name, params) {
4637    dispatchEvent(component.el, name, params);
4638  }
4639  function dispatchGlobal(name, params) {
4640    dispatchEvent(window, name, params);
4641  }
4642  function dispatchSelf(component, name, params) {
4643    dispatchEvent(component.el, name, params, false);
4644  }
4645  function dispatchTo(componentName, name, params) {
4646    let targets = componentsByName(componentName);
4647    targets.forEach((target) => {
4648      dispatchEvent(target.el, name, params, false);
4649    });
4650  }
4651  function listen2(component, name, callback) {
4652    component.el.addEventListener(name, (e) => {
4653      callback(e.detail);
4654    });
4655  }
4656  function on3(eventName, callback) {
4657    let handler4 = (e) => {
4658      if (!e.__livewire)
4659        return;
4660      callback(e.detail);
4661    };
4662    window.addEventListener(eventName, handler4);
4663    return () => {
4664      window.removeEventListener(eventName, handler4);
4665    };
4666  }
4667  function dispatchEvent(target, name, params, bubbles = true) {
4668    let e = new CustomEvent(name, { bubbles, detail: params });
4669    e.__livewire = { name, params, receivedBy: [] };
4670    target.dispatchEvent(e);
4671  }
4672
4673

4673// js/directives.js
4674  var customDirectiveNames = /* @__PURE__ */ new Set();
4675  function matchesForLivewireDirective(attributeName) {
4676    return attributeName.match(new RegExp("wire:"));
4677  }
4678  function extractDirective(el, name) {
4679    let [value, ...modifiers] = name.replace(new RegExp("wire:"), "").split(".");
4680    return new Directive(value, modifiers, name, el);
4681  }
4682  function directive2(name, callback) {
4683    if (customDirectiveNames.has(name))
4684      return;
4685    customDirectiveNames.add(name);
4686    on2("directive.init", ({ el, component, directive: directive3, cleanup: cleanup2 }) => {
4687      if (directive3.value === name) {
4688        callback({
4689          el,
4690          directive: directive3,
4691          component,
4692          $wire: component.$wire,
4693          cleanup: cleanup2
4694        });
4695      }
4696    });
4697  }
4698  function getDirectives(el) {
4699    return new DirectiveManager(el);
4700  }
4701  function customDirectiveHasBeenRegistered(name) {
4702    return customDirectiveNames.has(name);
4703  }
4704  var DirectiveManager = class {
4705    constructor(el) {
4706      this.el = el;
4707      this.directives = this.extractTypeModifiersAndValue();
4708    }
4709    all() {
4710      return this.directives;
4711    }
4712    has(value) {
4713      return this.directives.map((directive3) => directive3.value).includes(value);
4714    }
4715    missing(value) {
4716      return !this.has(value);
4717    }
4718    get(value) {
4719      return this.directives.find((directive3) => directive3.value === value);
4720    }
4721    extractTypeModifiersAndValue() {
4722      return Array.from(this.el.getAttributeNames().filter((name) => matchesForLivewireDirective(name)).map((name) => extractDirective(this.el, name)));
4723    }
4724  };
4725  var Directive = class {
4726    constructor(value, modifiers, rawName, el) {
4727      this.rawName = this.raw = rawName;
4728      this.el = el;
4729      this.eventContext;
4730      this.value = value;
4731      this.modifiers = modifiers;
4732      this.expression = this.el.getAttribute(this.rawName);
4733    }
4734    get method() {
4735      const { method } = this.parseOutMethodAndParams(this.expression);
4736      return method;
4737    }
4738    get params() {
4739      const { params } = this.parseOutMethodAndParams(this.expression);
4740      return params;
4741    }
4742    parseOutMethodAndParams(rawMethod) {
4743      let method = rawMethod;
4744      let params = [];
4745      const methodAndParamString = method.match(/(.*?)\((.*)\)/s);
4746      if (methodAndParamString) {
4747        method = methodAndParamString[1];
4748        let func = new Function("$event", `return (function () {
4749                for (var l=arguments.length, p=new Array(l), k=0; k<l; k++) {
4750                    p[k] = arguments[k];
4751                }
4752                return [].concat(p);
4753            })(${methodAndParamString[2]})`);
4754        params = func(this.eventContext);
4755      }
4756      return { method, params };
4757    }
4758  };
4759
4760

vendor: 3,040 bytes, lines 4760-4854

4760// ../alpine/packages/collapse/dist/module.esm.js
4761  function src_default2(Alpine3) {
4762    Alpine3.directive("collapse", collapse);
4763    collapse.inline = (el, { modifiers }) => {
4764      if (!modifiers.includes("min"))
4765        return;
4766      el._x_doShow = () => {
4767      };
4768      el._x_doHide = () => {
4769      };
4770    };
4771    function collapse(el, { modifiers }) {
4772      let duration = modifierValue2(modifiers, "duration", 250) / 1e3;
4773      let floor2 = modifierValue2(modifiers, "min", 0);
4774      let fullyHide = !modifiers.includes("min");
4775      if (!el._x_isShown)
4776        el.style.height = `${floor2}px`;
4777      if (!el._x_isShown && fullyHide)
4778        el.hidden = true;
4779      if (!el._x_isShown)
4780        el.style.overflow = "hidden";
4781      let setFunction = (el2, styles) => {
4782        let revertFunction = Alpine3.setStyles(el2, styles);
4783        return styles.height ? () => {
4784        } : revertFunction;
4785      };
4786      let transitionStyles = {
4787        transitionProperty: "height",
4788        transitionDuration: `${duration}s`,
4789        transitionTimingFunction: "cubic-bezier(0.4, 0.0, 0.2, 1)"
4790      };
4791      el._x_transition = {
4792        in(before = () => {
4793        }, after = () => {
4794        }) {
4795          if (fullyHide)
4796            el.hidden = false;
4797          if (fullyHide)
4798            el.style.display = null;
4799          let current = el.getBoundingClientRect().height;
4800          el.style.height = "auto";
4801          let full = el.getBoundingClientRect().height;
4802          if (current === full) {
4803            current = floor2;
4804          }
4805          Alpine3.transition(el, Alpine3.setStyles, {
4806            during: transitionStyles,
4807            start: { height: current + "px" },
4808            end: { height: full + "px" }
4809          }, () => el._x_isShown = true, () => {
4810            if (Math.abs(el.getBoundingClientRect().height - full) < 1) {
4811              el.style.overflow = null;
4812            }
4813          });
4814        },
4815        out(before = () => {
4816        }, after = () => {
4817        }) {
4818          let full = el.getBoundingClientRect().height;
4819          Alpine3.transition(el, setFunction, {
4820            during: transitionStyles,
4821            start: { height: full + "px" },
4822            end: { height: floor2 + "px" }
4823          }, () => el.style.overflow = "hidden", () => {
4824            el._x_isShown = false;
4825            if (el.style.height == `${floor2}px` && fullyHide) {
4826              el.style.display = "none";
4827              el.hidden = true;
4828            }
4829          });
4830        }
4831      };
4832    }
4833  }
4834  function modifierValue2(modifiers, key, fallback2) {
4835    if (modifiers.indexOf(key) === -1)
4836      return fallback2;
4837    const rawValue = modifiers[modifiers.indexOf(key) + 1];
4838    if (!rawValue)
4839      return fallback2;
4840    if (key === "duration") {
4841      let match = rawValue.match(/([0-9]+)ms/);
4842      if (match)
4843        return match[1];
4844    }
4845    if (key === "min") {
4846      let match = rawValue.match(/([0-9]+)px/);
4847      if (match)
4848        return match[1];
4849    }
4850    return rawValue;
4851  }
4852  var module_default2 = src_default2;
4853
4854

4854// ../alpine/packages/focus/dist/module.esm.js
4855  var candidateSelectors = ["input", "select", "textarea", "a[href]", "button", "[tabindex]:not(slot)", "audio[controls]", "video[controls]", '[contenteditable]:not([contenteditable="false"])', "details>summary:first-of-type", "details"];
4856  var candidateSelector = /* @__PURE__ */ candidateSelectors.join(",");
4857  var NoElement = typeof Element === "undefined";
4858  var matches = NoElement ? function() {
4859  } : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
4860  var getRootNode = !NoElement && Element.prototype.getRootNode ? function(element) {
4861    return element.getRootNode();
4862  } : function(element) {
4863    return element.ownerDocument;
4864  };
4865  var getCandidates = function getCandidates2(el, includeContainer, filter) {
4866    var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));
4867    if (includeContainer && matches.call(el, candidateSelector)) {
4868      candidates.unshift(el);
4869    }
4870    candidates = candidates.filter(filter);
4871    return candidates;
4872  };
4873  var getCandidatesIteratively = function getCandidatesIteratively2(elements, includeContainer, options) {
4874    var candidates = [];
4875    var elementsToCheck = Array.from(elements);
4876    while (elementsToCheck.length) {
4877      var element = elementsToCheck.shift();
4878      if (element.tagName === "SLOT") {
4879        var assigned = element.assignedElements();
4880        var content = assigned.length ? assigned : element.children;
4881        var nestedCandidates = getCandidatesIteratively2(content, true, options);
4882        if (options.flatten) {
4883          candidates.push.apply(candidates, nestedCandidates);
4884        } else {
4885          candidates.push({
4886            scope: element,
4887            candidates: nestedCandidates
4888          });
4889        }
4890      } else {
4891        var validCandidate = matches.call(element, candidateSelector);
4892        if (validCandidate && options.filter(element) && (includeContainer || !elements.includes(element))) {
4893          candidates.push(element);
4894        }
4895        var shadowRoot = element.shadowRoot || typeof options.getShadowRoot === "function" && options.getShadowRoot(element);
4896        var validShadowRoot = !options.shadowRootFilter || options.shadowRootFilter(element);
4897        if (shadowRoot && validShadowRoot) {
4898          var _nestedCandidates = getCandidatesIteratively2(shadowRoot === true ? element.children : shadowRoot.children, true, options);
4899          if (options.flatten) {
4900            candidates.push.apply(candidates, _nestedCandidates);
4901          } else {
4902            candidates.push({
4903              scope: element,
4904              candidates: _nestedCandidates
4905            });
4906          }
4907        } else {
4908          elementsToCheck.unshift.apply(elementsToCheck, element.children);
4909        }
4910      }
4911    }
4912    return candidates;
4913  };
4914  var getTabindex = function getTabindex2(node, isScope) {
4915    if (node.tabIndex < 0) {
4916      if ((isScope || /^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || node.isContentEditable) && isNaN(parseInt(node.getAttribute("tabindex"), 10))) {
4917        return 0;
4918      }
4919    }
4920    return node.tabIndex;
4921  };
4922  var sortOrderedTabbables = function sortOrderedTabbables2(a, b) {
4923    return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;
4924  };
4925  var isInput = function isInput2(node) {
4926    return node.tagName === "INPUT";
4927  };
4928  var isHiddenInput = function isHiddenInput2(node) {
4929    return isInput(node) && node.type === "hidden";
4930  };
4931  var isDetailsWithSummary = function isDetailsWithSummary2(node) {
4932    var r = node.tagName === "DETAILS" && Array.prototype.slice.apply(node.children).some(function(child) {
4933      return child.tagName === "SUMMARY";
4934    });
4935    return r;
4936  };
4937  var getCheckedRadio = function getCheckedRadio2(nodes, form) {
4938    for (var i = 0; i < nodes.length; i++) {
4939      if (nodes[i].checked && nodes[i].form === form) {
4940        return nodes[i];
4941      }
4942    }
4943  };
4944  var isTabbableRadio = function isTabbableRadio2(node) {
4945    if (!node.name) {
4946      return true;
4947    }
4948    var radioScope = node.form || getRootNode(node);
4949    var queryRadios = function queryRadios2(name) {
4950      return radioScope.querySelectorAll('input[type="radio"][name="' + name + '"]');
4951    };
4952    var radioSet;
4953    if (typeof window !== "undefined" && typeof window.CSS !== "undefined" && typeof window.CSS.escape === "function") {
4954      radioSet = queryRadios(window.CSS.escape(node.name));
4955    } else {

4956      try {
4957        radioSet = queryRadios(node.name);
4958      } catch (err) {
4959        console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", err.message);
4960        return false;
4961      }
4962    }
4963    var checked = getCheckedRadio(radioSet, node.form);
4964    return !checked || checked === node;
4965  };
4966  var isRadio = function isRadio2(node) {
4967    return isInput(node) && node.type === "radio";
4968  };
4969  var isNonTabbableRadio = function isNonTabbableRadio2(node) {
4970    return isRadio(node) && !isTabbableRadio(node);
4971  };
4972  var isZeroArea = function isZeroArea2(node) {
4973    var _node$getBoundingClie = node.getBoundingClientRect(), width = _node$getBoundingClie.width, height = _node$getBoundingClie.height;
4974    return width === 0 && height === 0;
4975  };
4976  var isHidden = function isHidden2(node, _ref) {
4977    var displayCheck = _ref.displayCheck, getShadowRoot = _ref.getShadowRoot;
4978    if (getComputedStyle(node).visibility === "hidden") {
4979      return true;
4980    }
4981    var isDirectSummary = matches.call(node, "details>summary:first-of-type");
4982    var nodeUnderDetails = isDirectSummary ? node.parentElement : node;
4983    if (matches.call(nodeUnderDetails, "details:not([open]) *")) {
4984      return true;
4985    }
4986    var nodeRootHost = getRootNode(node).host;
4987    var nodeIsAttached = (nodeRootHost === null || nodeRootHost === void 0 ? void 0 : nodeRootHost.ownerDocument.contains(nodeRootHost)) || node.ownerDocument.contains(node);
4988    if (!displayCheck || displayCheck === "full") {
4989      if (typeof getShadowRoot === "function") {
4990        var originalNode = node;
4991        while (node) {
4992          var parentElement = node.parentElement;
4993          var rootNode = getRootNode(node);
4994          if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true) {
4995            return isZeroArea(node);
4996          } else if (node.assignedSlot) {
4997            node = node.assignedSlot;
4998          } else if (!parentElement && rootNode !== node.ownerDocument) {
4999            node = rootNode.host;
5000          } else {
5001            node = parentElement;
5002          }
5003        }
5004        node = originalNode;
5005      }
5006      if (nodeIsAttached) {
5007        return !node.getClientRects().length;
5008      }
5009    } else if (displayCheck === "non-zero-area") {
5010      return isZeroArea(node);
5011    }
5012    return false;
5013  };
5014  var isDisabledFromFieldset = function isDisabledFromFieldset2(node) {
5015    if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {
5016      var parentNode = node.parentElement;
5017      while (parentNode) {
5018        if (parentNode.tagName === "FIELDSET" && parentNode.disabled) {
5019          for (var i = 0; i < parentNode.children.length; i++) {
5020            var child = parentNode.children.item(i);
5021            if (child.tagName === "LEGEND") {
5022              return matches.call(parentNode, "fieldset[disabled] *") ? true : !child.contains(node);
5023            }
5024          }
5025          return true;
5026        }
5027        parentNode = parentNode.parentElement;
5028      }
5029    }
5030    return false;
5031  };
5032  var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable2(options, node) {
5033    if (node.disabled || isHiddenInput(node) || isHidden(node, options) || isDetailsWithSummary(node) || isDisabledFromFieldset(node)) {
5034      return false;
5035    }
5036    return true;
5037  };
5038  var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable2(options, node) {
5039    if (isNonTabbableRadio(node) || getTabindex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) {
5040      return false;
5041    }
5042    return true;
5043  };
5044  var isValidShadowRootTabbable = function isValidShadowRootTabbable2(shadowHostNode) {
5045    var tabIndex = parseInt(shadowHostNode.getAttribute("tabindex"), 10);
5046    if (isNaN(tabIndex) || tabIndex >= 0) {
5047      return true;
5048    }
5049    return false;
5050  };
5051  var sortByOrder = function sortByOrder2(candidates) {
5052    var regularTabbables = [];
5053    var orderedTabbables = [];
5054    candidates.forEach(function(item, i) {
5055      var isScope = !!item.scope;
5056      var element = isScope ? item.scope : item;
5057      var candidateTabindex = getTabindex(element, isScope);
5058      var elements = isScope ? sortByOrder2(item.candidates) : element;
5059      if (candidateTabindex === 0) {
5060        isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element);
5061      } else {
5062        orderedTabbables.push({
5063          documentOrder: i,
5064          tabIndex: candidateTabindex,
5065          item,
5066          isScope,
5067          content: elements
5068        });
5069      }
5070    });
5071    return orderedTabbables.sort(sortOrderedTabbables).reduce(function(acc, sortable) {
5072      sortable.isScope ? acc.push.apply(acc, sortable.content) : acc.push(sortable.content);
5073      return acc;
5074    }, []).concat(regularTabbables);
5075  };
5076  var tabbable = function tabbable2(el, options) {
5077    options = options || {};
5078    var candidates;
5079    if (options.getShadowRoot) {

5080      candidates = getCandidatesIteratively([el], options.includeContainer, {
5081        filter: isNodeMatchingSelectorTabbable.bind(null, options),
5082        flatten: false,
5083        getShadowRoot: options.getShadowRoot,
5084        shadowRootFilter: isValidShadowRootTabbable
5085      });
5086    } else {
5087      candidates = getCandidates(el, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
5088    }
5089    return sortByOrder(candidates);
5090  };
5091  var focusable = function focusable2(el, options) {
5092    options = options || {};
5093    var candidates;
5094    if (options.getShadowRoot) {
5095      candidates = getCandidatesIteratively([el], options.includeContainer, {
5096        filter: isNodeMatchingSelectorFocusable.bind(null, options),
5097        flatten: true,
5098        getShadowRoot: options.getShadowRoot
5099      });
5100    } else {
5101      candidates = getCandidates(el, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));
5102    }
5103    return candidates;
5104  };
5105  var isTabbable = function isTabbable2(node, options) {
5106    options = options || {};
5107    if (!node) {
5108      throw new Error("No node provided");
5109    }
5110    if (matches.call(node, candidateSelector) === false) {
5111      return false;
5112    }
5113    return isNodeMatchingSelectorTabbable(options, node);
5114  };
5115  var focusableCandidateSelector = /* @__PURE__ */ candidateSelectors.concat("iframe").join(",");
5116  var isFocusable = function isFocusable2(node, options) {
5117    options = options || {};
5118    if (!node) {
5119      throw new Error("No node provided");
5120    }
5121    if (matches.call(node, focusableCandidateSelector) === false) {
5122      return false;
5123    }
5124    return isNodeMatchingSelectorFocusable(options, node);
5125  };
5126  function ownKeys2(object, enumerableOnly) {
5127    var keys = Object.keys(object);
5128    if (Object.getOwnPropertySymbols) {
5129      var symbols = Object.getOwnPropertySymbols(object);
5130      enumerableOnly && (symbols = symbols.filter(function(sym) {
5131        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
5132      })), keys.push.apply(keys, symbols);
5133    }
5134    return keys;
5135  }
5136  function _objectSpread2(target) {
5137    for (var i = 1; i < arguments.length; i++) {
5138      var source = null != arguments[i] ? arguments[i] : {};
5139      i % 2 ? ownKeys2(Object(source), true).forEach(function(key) {
5140        _defineProperty(target, key, source[key]);
5141      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys2(Object(source)).forEach(function(key) {
5142        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
5143      });
5144    }
5145    return target;
5146  }
5147  function _defineProperty(obj, key, value) {
5148    if (key in obj) {
5149      Object.defineProperty(obj, key, {
5150        value,
5151        enumerable: true,
5152        configurable: true,
5153        writable: true
5154      });
5155    } else {
5156      obj[key] = value;
5157    }
5158    return obj;
5159  }
5160  var activeFocusTraps = function() {
5161    var trapQueue = [];
5162    return {
5163      activateTrap: function activateTrap(trap) {
5164        if (trapQueue.length > 0) {
5165          var activeTrap = trapQueue[trapQueue.length - 1];
5166          if (activeTrap !== trap) {
5167            activeTrap.pause();
5168          }
5169        }
5170        var trapIndex = trapQueue.indexOf(trap);
5171        if (trapIndex === -1) {
5172          trapQueue.push(trap);
5173        } else {
5174          trapQueue.splice(trapIndex, 1);
5175          trapQueue.push(trap);
5176        }
5177      },
5178      deactivateTrap: function deactivateTrap(trap) {
5179        var trapIndex = trapQueue.indexOf(trap);
5180        if (trapIndex !== -1) {
5181          trapQueue.splice(trapIndex, 1);
5182        }
5183        if (trapQueue.length > 0) {
5184          trapQueue[trapQueue.length - 1].unpause();
5185        }
5186      }
5187    };
5188  }();
5189  var isSelectableInput = function isSelectableInput2(node) {
5190    return node.tagName && node.tagName.toLowerCase() === "input" && typeof node.select === "function";
5191  };
5192  var isEscapeEvent = function isEscapeEvent2(e) {
5193    return e.key === "Escape" || e.key === "Esc" || e.keyCode === 27;
5194  };
5195  var isTabEvent = function isTabEvent2(e) {
5196    return e.key === "Tab" || e.keyCode === 9;
5197  };

5198  var delay = function delay2(fn) {
5199    return setTimeout(fn, 0);
5200  };
5201  var findIndex = function findIndex2(arr, fn) {
5202    var idx = -1;
5203    arr.every(function(value, i) {
5204      if (fn(value)) {
5205        idx = i;
5206        return false;
5207      }
5208      return true;
5209    });
5210    return idx;
5211  };
5212  var valueOrHandler = function valueOrHandler2(value) {
5213    for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
5214      params[_key - 1] = arguments[_key];
5215    }
5216    return typeof value === "function" ? value.apply(void 0, params) : value;
5217  };
5218  var getActualTarget = function getActualTarget2(event) {
5219    return event.target.shadowRoot && typeof event.composedPath === "function" ? event.composedPath()[0] : event.target;
5220  };
5221  var createFocusTrap = function createFocusTrap2(elements, userOptions) {
5222    var doc = (userOptions === null || userOptions === void 0 ? void 0 : userOptions.document) || document;
5223    var config = _objectSpread2({
5224      returnFocusOnDeactivate: true,
5225      escapeDeactivates: true,
5226      delayInitialFocus: true
5227    }, userOptions);
5228    var state = {
5229      containers: [],
5230      containerGroups: [],
5231      tabbableGroups: [],
5232      nodeFocusedBeforeActivation: null,
5233      mostRecentlyFocusedNode: null,
5234      active: false,
5235      paused: false,
5236      delayInitialFocusTimer: void 0
5237    };
5238    var trap;
5239    var getOption = function getOption2(configOverrideOptions, optionName, configOptionName) {
5240      return configOverrideOptions && configOverrideOptions[optionName] !== void 0 ? configOverrideOptions[optionName] : config[configOptionName || optionName];
5241    };
5242    var findContainerIndex = function findContainerIndex2(element) {
5243      return state.containerGroups.findIndex(function(_ref) {
5244        var container = _ref.container, tabbableNodes = _ref.tabbableNodes;
5245        return container.contains(element) || tabbableNodes.find(function(node) {
5246          return node === element;
5247        });
5248      });
5249    };
5250    var getNodeForOption = function getNodeForOption2(optionName) {
5251      var optionValue = config[optionName];
5252      if (typeof optionValue === "function") {
5253        for (var _len2 = arguments.length, params = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
5254          params[_key2 - 1] = arguments[_key2];
5255        }
5256        optionValue = optionValue.apply(void 0, params);
5257      }
5258      if (optionValue === true) {
5259        optionValue = void 0;
5260      }
5261      if (!optionValue) {
5262        if (optionValue === void 0 || optionValue === false) {
5263          return optionValue;
5264        }
5265        throw new Error("`".concat(optionName, "` was specified but was not a node, or did not return a node"));
5266      }
5267      var node = optionValue;
5268      if (typeof optionValue === "string") {
5269        node = doc.querySelector(optionValue);
5270        if (!node) {
5271          throw new Error("`".concat(optionName, "` as selector refers to no known node"));
5272        }
5273      }
5274      return node;
5275    };
5276    var getInitialFocusNode = function getInitialFocusNode2() {
5277      var node = getNodeForOption("initialFocus");
5278      if (node === false) {
5279        return false;
5280      }
5281      if (node === void 0) {
5282        if (findContainerIndex(doc.activeElement) >= 0) {
5283          node = doc.activeElement;
5284        } else {
5285          var firstTabbableGroup = state.tabbableGroups[0];
5286          var firstTabbableNode = firstTabbableGroup && firstTabbableGroup.firstTabbableNode;
5287          node = firstTabbableNode || getNodeForOption("fallbackFocus");
5288        }
5289      }
5290      if (!node) {
5291        throw new Error("Your focus-trap needs to have at least one focusable element");
5292      }
5293      return node;
5294    };
5295    var updateTabbableNodes = function updateTabbableNodes2() {
5296      state.containerGroups = state.containers.map(function(container) {
5297        var tabbableNodes = tabbable(container, config.tabbableOptions);
5298        var focusableNodes = focusable(container, config.tabbableOptions);
5299        return {
5300          container,
5301          tabbableNodes,
5302          focusableNodes,
5303          firstTabbableNode: tabbableNodes.length > 0 ? tabbableNodes[0] : null,
5304          lastTabbableNode: tabbableNodes.length > 0 ? tabbableNodes[tabbableNodes.length - 1] : null,
5305          nextTabbableNode: function nextTabbableNode(node) {
5306            var forward = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;

5307            var nodeIdx = focusableNodes.findIndex(function(n) {
5308              return n === node;
5309            });
5310            if (nodeIdx < 0) {
5311              return void 0;
5312            }
5313            if (forward) {
5314              return focusableNodes.slice(nodeIdx + 1).find(function(n) {
5315                return isTabbable(n, config.tabbableOptions);
5316              });
5317            }
5318            return focusableNodes.slice(0, nodeIdx).reverse().find(function(n) {
5319              return isTabbable(n, config.tabbableOptions);
5320            });
5321          }
5322        };
5323      });
5324      state.tabbableGroups = state.containerGroups.filter(function(group) {
5325        return group.tabbableNodes.length > 0;
5326      });
5327      if (state.tabbableGroups.length <= 0 && !getNodeForOption("fallbackFocus")) {
5328        throw new Error("Your focus-trap must have at least one container with at least one tabbable node in it at all times");
5329      }
5330    };
5331    var tryFocus = function tryFocus2(node) {
5332      if (node === false) {
5333        return;
5334      }
5335      if (node === doc.activeElement) {
5336        return;
5337      }
5338      if (!node || !node.focus) {
5339        tryFocus2(getInitialFocusNode());
5340        return;
5341      }
5342      node.focus({
5343        preventScroll: !!config.preventScroll
5344      });
5345      state.mostRecentlyFocusedNode = node;
5346      if (isSelectableInput(node)) {
5347        node.select();
5348      }
5349    };
5350    var getReturnFocusNode = function getReturnFocusNode2(previousActiveElement) {
5351      var node = getNodeForOption("setReturnFocus", previousActiveElement);
5352      return node ? node : node === false ? false : previousActiveElement;
5353    };
5354    var checkPointerDown = function checkPointerDown2(e) {
5355      var target = getActualTarget(e);
5356      if (findContainerIndex(target) >= 0) {
5357        return;
5358      }
5359      if (valueOrHandler(config.clickOutsideDeactivates, e)) {
5360        trap.deactivate({
5361          returnFocus: config.returnFocusOnDeactivate && !isFocusable(target, config.tabbableOptions)
5362        });
5363        return;
5364      }
5365      if (valueOrHandler(config.allowOutsideClick, e)) {
5366        return;
5367      }
5368      e.preventDefault();
5369    };
5370    var checkFocusIn = function checkFocusIn2(e) {
5371      var target = getActualTarget(e);
5372      var targetContained = findContainerIndex(target) >= 0;
5373      if (targetContained || target instanceof Document) {
5374        if (targetContained) {
5375          state.mostRecentlyFocusedNode = target;
5376        }
5377      } else {
5378        e.stopImmediatePropagation();
5379        tryFocus(state.mostRecentlyFocusedNode || getInitialFocusNode());
5380      }
5381    };
5382    var checkTab = function checkTab2(e) {
5383      var target = getActualTarget(e);
5384      updateTabbableNodes();
5385      var destinationNode = null;
5386      if (state.tabbableGroups.length > 0) {
5387        var containerIndex = findContainerIndex(target);
5388        var containerGroup = containerIndex >= 0 ? state.containerGroups[containerIndex] : void 0;
5389        if (containerIndex < 0) {
5390          if (e.shiftKey) {
5391            destinationNode = state.tabbableGroups[state.tabbableGroups.length - 1].lastTabbableNode;
5392          } else {
5393            destinationNode = state.tabbableGroups[0].firstTabbableNode;
5394          }
5395        } else if (e.shiftKey) {
5396          var startOfGroupIndex = findIndex(state.tabbableGroups, function(_ref2) {
5397            var firstTabbableNode = _ref2.firstTabbableNode;
5398            return target === firstTabbableNode;
5399          });
5400          if (startOfGroupIndex < 0 && (containerGroup.container === target || isFocusable(target, config.tabbableOptions) && !isTabbable(target, config.tabbableOptions) && !containerGroup.nextTabbableNode(target, false))) {
5401            startOfGroupIndex = containerIndex;
5402          }
5403          if (startOfGroupIndex >= 0) {
5404            var destinationGroupIndex = startOfGroupIndex === 0 ? state.tabbableGroups.length - 1 : startOfGroupIndex - 1;
5405            var destinationGroup = state.tabbableGroups[destinationGroupIndex];
5406            destinationNode = destinationGroup.lastTabbableNode;
5407          }
5408        } else {
5409          var lastOfGroupIndex = findIndex(state.tabbableGroups, function(_ref3) {
5410            var lastTabbableNode = _ref3.lastTabbableNode;
5411            return target === lastTabbableNode;
5412          });
5413          if (lastOfGroupIndex < 0 && (containerGroup.container === target || isFocusable(target, config.tabbableOptions) && !isTabbable(target, config.tabbableOptions) && !containerGroup.nextTabbableNode(target))) {
5414            lastOfGroupIndex = containerIndex;
5415          }
5416          if (lastOfGroupIndex >= 0) {
5417            var _destinationGroupIndex = lastOfGroupIndex === state.tabbableGroups.length - 1 ? 0 : lastOfGroupIndex + 1;
5418            var _destinationGroup = state.tabbableGroups[_destinationGroupIndex];
5419            destinationNode = _destinationGroup.firstTabbableNode;
5420          }
5421        }
5422      } else {
5423        destinationNode = getNodeForOption("fallbackFocus");
5424      }
5425      if (destinationNode) {
5426        e.preventDefault();
5427        tryFocus(destinationNode);
5428      }
5429    };
5430    var checkKey = function checkKey2(e) {
5431      if (isEscapeEvent(e) && valueOrHandler(config.escapeDeactivates, e) !== false) {
5432        e.preventDefault();
5433        trap.deactivate();
5434        return;
5435      }
5436      if (isTabEvent(e)) {
5437        checkTab(e);
5438        return;
5439      }
5440    };
5441    var checkClick = function checkClick2(e) {
5442      var target = getActualTarget(e);
5443      if (findContainerIndex(target) >= 0) {
5444        return;
5445      }
5446      if (valueOrHandler(config.clickOutsideDeactivates, e)) {
5447        return;
5448      }
5449      if (valueOrHandler(config.allowOutsideClick, e)) {
5450        return;
5451      }
5452      e.preventDefault();
5453      e.stopImmediatePropagation();
5454    };
5455    var addListeners = function addListeners2() {
5456      if (!state.active) {
5457        return;
5458      }
5459      activeFocusTraps.activateTrap(trap);
5460      state.delayInitialFocusTimer = config.delayInitialFocus ? delay(function() {
5461        tryFocus(getInitialFocusNode());
5462      }) : tryFocus(getInitialFocusNode());
5463      doc.addEventListener("focusin", checkFocusIn, true);
5464      doc.addEventListener("mousedown", checkPointerDown, {

5465        capture: true,
5466        passive: false
5467      });
5468      doc.addEventListener("touchstart", checkPointerDown, {
5469        capture: true,
5470        passive: false
5471      });
5472      doc.addEventListener("click", checkClick, {
5473        capture: true,
5474        passive: false
5475      });
5476      doc.addEventListener("keydown", checkKey, {
5477        capture: true,
5478        passive: false
5479      });
5480      return trap;
5481    };
5482    var removeListeners = function removeListeners2() {
5483      if (!state.active) {
5484        return;
5485      }
5486      doc.removeEventListener("focusin", checkFocusIn, true);
5487      doc.removeEventListener("mousedown", checkPointerDown, true);
5488      doc.removeEventListener("touchstart", checkPointerDown, true);
5489      doc.removeEventListener("click", checkClick, true);
5490      doc.removeEventListener("keydown", checkKey, true);
5491      return trap;
5492    };
5493    trap = {
5494      get active() {
5495        return state.active;
5496      },
5497      get paused() {
5498        return state.paused;
5499      },
5500      activate: function activate(activateOptions) {
5501        if (state.active) {
5502          return this;
5503        }
5504        var onActivate = getOption(activateOptions, "onActivate");
5505        var onPostActivate = getOption(activateOptions, "onPostActivate");
5506        var checkCanFocusTrap = getOption(activateOptions, "checkCanFocusTrap");
5507        if (!checkCanFocusTrap) {
5508          updateTabbableNodes();
5509        }
5510        state.active = true;
5511        state.paused = false;
5512        state.nodeFocusedBeforeActivation = doc.activeElement;
5513        if (onActivate) {
5514          onActivate();
5515        }
5516        var finishActivation = function finishActivation2() {
5517          if (checkCanFocusTrap) {
5518            updateTabbableNodes();
5519          }
5520          addListeners();
5521          if (onPostActivate) {
5522            onPostActivate();
5523          }
5524        };
5525        if (checkCanFocusTrap) {
5526          checkCanFocusTrap(state.containers.concat()).then(finishActivation, finishActivation);
5527          return this;
5528        }
5529        finishActivation();
5530        return this;
5531      },
5532      deactivate: function deactivate(deactivateOptions) {
5533        if (!state.active) {
5534          return this;
5535        }
5536        var options = _objectSpread2({
5537          onDeactivate: config.onDeactivate,
5538          onPostDeactivate: config.onPostDeactivate,
5539          checkCanReturnFocus: config.checkCanReturnFocus
5540        }, deactivateOptions);
5541        clearTimeout(state.delayInitialFocusTimer);
5542        state.delayInitialFocusTimer = void 0;
5543        removeListeners();
5544        state.active = false;
5545        state.paused = false;
5546        activeFocusTraps.deactivateTrap(trap);
5547        var onDeactivate = getOption(options, "onDeactivate");
5548        var onPostDeactivate = getOption(options, "onPostDeactivate");
5549        var checkCanReturnFocus = getOption(options, "checkCanReturnFocus");
5550        var returnFocus = getOption(options, "returnFocus", "returnFocusOnDeactivate");
5551        if (onDeactivate) {
5552          onDeactivate();
5553        }
5554        var finishDeactivation = function finishDeactivation2() {
5555          delay(function() {
5556            if (returnFocus) {
5557              tryFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation));
5558            }
5559            if (onPostDeactivate) {
5560              onPostDeactivate();
5561            }
5562          });
5563        };
5564        if (returnFocus && checkCanReturnFocus) {
5565          checkCanReturnFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation)).then(finishDeactivation, finishDeactivation);
5566          return this;
5567        }
5568        finishDeactivation();
5569        return this;
5570      },
5571      pause: function pause() {
5572        if (state.paused || !state.active) {
5573          return this;
5574        }
5575        state.paused = true;
5576        removeListeners();
5577        return this;
5578      },
5579      unpause: function unpause() {
5580        if (!state.paused || !state.active) {
5581          return this;
5582        }
5583        state.paused = false;
5584        updateTabbableNodes();
5585        addListeners();
5586        return this;
5587      },
5588      updateContainerElements: function updateContainerElements(containerElements) {
5589        var elementsAsArray = [].concat(containerElements).filter(

vendor: 5,515 bytes, lines 5589-5781

5589Boolean);
5590        state.containers = elementsAsArray.map(function(element) {
5591          return typeof element === "string" ? doc.querySelector(element) : element;
5592        });
5593        if (state.active) {
5594          updateTabbableNodes();
5595        }
5596        return this;
5597      }
5598    };
5599    trap.updateContainerElements(elements);
5600    return trap;
5601  };
5602  function src_default3(Alpine3) {
5603    let lastFocused;
5604    let currentFocused;
5605    window.addEventListener("focusin", () => {
5606      lastFocused = currentFocused;
5607      currentFocused = document.activeElement;
5608    });
5609    Alpine3.magic("focus", (el) => {
5610      let within = el;
5611      return {
5612        __noscroll: false,
5613        __wrapAround: false,
5614        within(el2) {
5615          within = el2;
5616          return this;
5617        },
5618        withoutScrolling() {
5619          this.__noscroll = true;
5620          return this;
5621        },
5622        noscroll() {
5623          this.__noscroll = true;
5624          return this;
5625        },
5626        withWrapAround() {
5627          this.__wrapAround = true;
5628          return this;
5629        },
5630        wrap() {
5631          return this.withWrapAround();
5632        },
5633        focusable(el2) {
5634          return isFocusable(el2);
5635        },
5636        previouslyFocused() {
5637          return lastFocused;
5638        },
5639        lastFocused() {
5640          return lastFocused;
5641        },
5642        focused() {
5643          return currentFocused;
5644        },
5645        focusables() {
5646          if (Array.isArray(within))
5647            return within;
5648          return focusable(within, { displayCheck: "none" });
5649        },
5650        all() {
5651          return this.focusables();
5652        },
5653        isFirst(el2) {
5654          let els2 = this.all();
5655          return els2[0] && els2[0].isSameNode(el2);
5656        },
5657        isLast(el2) {
5658          let els2 = this.all();
5659          return els2.length && els2.slice(-1)[0].isSameNode(el2);
5660        },
5661        getFirst() {
5662          return this.all()[0];
5663        },
5664        getLast() {
5665          return this.all().slice(-1)[0];
5666        },
5667        getNext() {
5668          let list = this.all();
5669          let current = document.activeElement;
5670          if (list.indexOf(current) === -1)
5671            return;
5672          if (this.__wrapAround && list.indexOf(current) === list.length - 1) {
5673            return list[0];
5674          }
5675          return list[list.indexOf(current) + 1];
5676        },
5677        getPrevious() {
5678          let list = this.all();
5679          let current = document.activeElement;
5680          if (list.indexOf(current) === -1)
5681            return;
5682          if (this.__wrapAround && list.indexOf(current) === 0) {
5683            return list.slice(-1)[0];
5684          }
5685          return list[list.indexOf(current) - 1];
5686        },
5687        first() {
5688          this.focus(this.getFirst());
5689        },
5690        last() {
5691          this.focus(this.getLast());
5692        },
5693        next() {
5694          this.focus(this.getNext());
5695        },
5696        previous() {
5697          this.focus(this.getPrevious());
5698        },
5699        prev() {
5700          return this.previous();
5701        },
5702        focus(el2) {
5703          if (!el2)
5704            return;
5705          setTimeout(() => {
5706            if (!el2.hasAttribute("tabindex"))
5707              el2.setAttribute("tabindex", "0");
5708            el2.focus({ preventScroll: this.__noscroll });
5709          });
5710        }
5711      };
5712    });
5713    Alpine3.directive("trap", Alpine3.skipDuringClone((el, { expression, modifiers }, { effect: effect3, evaluateLater: evaluateLater2, cleanup: cleanup2 }) => {
5714      let evaluator = evaluateLater2(expression);
5715      let oldValue = false;
5716      let options = {
5717        escapeDeactivates: false,
5718        allowOutsideClick: true,
5719        fallbackFocus: () => el
5720      };
5721      if (modifiers.includes("noautofocus")) {
5722        options.initialFocus = false;
5723      } else {
5724        let autofocusEl = el.querySelector("[autofocus]");
5725        if (autofocusEl)
5726          options.initialFocus = autofocusEl;
5727      }
5728      let trap = createFocusTrap(el, options);
5729      let undoInert = () => {
5730      };
5731      let undoDisableScrolling = () => {
5732      };
5733      const releaseFocus = () => {
5734        undoInert();
5735        undoInert = () => {
5736        };
5737        undoDisableScrolling();
5738        undoDisableScrolling = () => {
5739        };
5740        trap.deactivate({
5741          returnFocus: !modifiers.includes("noreturn")
5742        });
5743      };
5744      effect3(() => evaluator((value) => {
5745        if (oldValue === value)
5746          return;
5747        if (value && !oldValue) {
5748          if (modifiers.includes("noscroll"))
5749            undoDisableScrolling = disableScrolling();
5750          if (modifiers.includes("inert"))
5751            undoInert = setInert(el);
5752          setTimeout(() => {
5753            trap.activate();
5754          }, 15);
5755        }
5756        if (!value && oldValue) {
5757          releaseFocus();
5758        }
5759        oldValue = !!value;
5760      }));
5761      cleanup2(releaseFocus);
5762    }, (el, { expression, modifiers }, { evaluate: evaluate3 }) => {
5763      if (modifiers.includes("inert") && evaluate3(expression))
5764        setInert(el);
5765    }));
5766  }
5767  function setInert(el) {
5768    let undos = [];
5769    crawlSiblingsUp(el, (sibling) => {
5770      let cache = sibling.hasAttribute("aria-hidden");
5771      sibling.setAttribute("aria-hidden", "true");
5772      undos.push(() => cache || sibling.removeAttribute("aria-hidden"));
5773    });
5774    return () => {
5775      while (undos.length)
5776        undos.pop()();
5777    };
5778  }
5779  function crawlSiblingsUp(el, callback) {
5780    if (el.isSameNode(document.body) || !el.parentNode)
5781      return;

5782    Array.from(el.parentNode.children).forEach((sibling) => {
5783      if (sibling.isSameNode(el)) {
5784        crawlSiblingsUp(el.parentNode, callback);
5785      } else {
5786        callback(sibling);
5787      }
5788    });
5789  }
5790  function disableScrolling() {
5791    let overflow = document.documentElement.style.overflow;
5792    let paddingRight = document.documentElement.style.paddingRight;
5793    let scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
5794    document.documentElement.style.overflow = "hidden";
5795    document.documentElement.style.paddingRight = `${scrollbarWidth}px`;
5796    return () => {
5797      document.documentElement.style.overflow = overflow;
5798      document.documentElement.style.paddingRight = paddingRight;
5799    };
5800  }
5801  var module_default3 = src_default3;
5802
5803

5803// ../alpine/packages/persist/dist/module.esm.js
5804  function src_default4(Alpine3) {
5805    let persist = () => {
5806      let alias;
5807      let storage;
5808      try {
5809        storage = localStorage;
5810      } catch (e) {
5811        console.error(e);
5812        console.warn("Alpine: $persist is using temporary storage since localStorage is unavailable.");
5813        let dummy = /* @__PURE__ */ new Map();
5814        storage = {
5815          getItem: dummy.get.bind(dummy),
5816          setItem: dummy.set.bind(dummy)
5817        };
5818      }
5819      return Alpine3.interceptor((initialValue, getter, setter, path, key) => {
5820        let lookup = alias || `_x_${path}`;
5821        let initial = storageHas(lookup, storage) ? storageGet(lookup, storage) : initialValue;
5822        setter(initial);
5823        Alpine3.effect(() => {
5824          let value = getter();
5825          storageSet(lookup, value, storage);
5826          setter(value);
5827        });
5828        return initial;
5829      }, (func) => {
5830        func.as = (key) => {
5831          alias = key;
5832          return func;
5833        }, func.using = (target) => {
5834          storage = target;
5835          return func;
5836        };
5837      });
5838    };
5839    Object.defineProperty(Alpine3, "$persist", { get: () => persist() });
5840    Alpine3.magic("persist", persist);
5841    Alpine3.persist = (key, { get: get3, set: set3 }, storage = localStorage) => {
5842      let initial = storageHas(key, storage) ? storageGet(key, storage) : get3();
5843      set3(initial);
5844      Alpine3.effect(() => {
5845        let value = get3();
5846        storageSet(key, value, storage);
5847        set3(value);
5848      });
5849    };
5850  }
5851  function storageHas(key, storage) {
5852    return storage.getItem(key) !== null;
5853  }
5854  function storageGet(key, storage) {
5855    let value = storage.getItem(key, storage);
5856    if (value === void 0)
5857      return;
5858    return JSON.parse(value);
5859  }
5860  function storageSet(key, value, storage) {
5861    storage.setItem(key, JSON.stringify(value));
5862  }
5863  var module_default4 = src_default4;
5864
5865

5865// ../alpine/packages/intersect/dist/module.esm.js
5866  function src_default5(Alpine3) {
5867    Alpine3.directive("intersect", Alpine3.skipDuringClone((el, { value, expression, modifiers }, { evaluateLater: evaluateLater2, cleanup: cleanup2 }) => {
5868      let evaluate3 = evaluateLater2(expression);
5869      let options = {
5870        rootMargin: getRootMargin(modifiers),
5871        threshold: getThreshold(modifiers)
5872      };
5873      let observer2 = new IntersectionObserver((entries) => {
5874        entries.forEach((entry) => {
5875          if (entry.isIntersecting === (value === "leave"))
5876            return;
5877          evaluate3();
5878          modifiers.includes("once") && observer2.disconnect();
5879        });
5880      }, options);
5881      observer2.observe(el);
5882      cleanup2(() => {
5883        observer2.disconnect();
5884      });
5885    }));
5886  }
5887  function getThreshold(modifiers) {
5888    if (modifiers.includes("full"))
5889      return 0.99;
5890    if (modifiers.includes("half"))
5891      return 0.5;
5892    if (!modifiers.includes("threshold"))
5893      return 0;
5894    let threshold = modifiers[modifiers.indexOf("threshold") + 1];
5895    if (threshold === "100")
5896      return 1;
5897    if (threshold === "0")
5898      return 0;
5899    return Number(`.${threshold}`);
5900  }
5901  function getLengthValue(rawValue) {
5902    let match = rawValue.match(/^(-?[0-9]+)(px|%)?$/);
5903    return match ? match[1] + (match[2] || "px") : void 0;
5904  }
5905  function getRootMargin(modifiers) {
5906    const key = "margin";
5907    const fallback2 = "0px 0px 0px 0px";
5908    const index = modifiers.indexOf(key);
5909    if (index === -1)
5910      return fallback2;
5911    let values = [];
5912    for (let i = 1; i < 5; i++) {
5913      values.push(getLengthValue(modifiers[index + i] || ""));
5914    }
5915    values = values.filter((v) => v !== void 0);
5916    return values.length ? values.join(" ").trim() : fallback2;
5917  }
5918  var module_default5 = src_default5;
5919
5920

vendor: 22,871 bytes, lines 5920-6615

5920// ../alpine/packages/anchor/dist/module.esm.js
5921  var min = Math.min;
5922  var max = Math.max;
5923  var round = Math.round;
5924  var floor = Math.floor;
5925  var createCoords = (v) => ({
5926    x: v,
5927    y: v
5928  });
5929  var oppositeSideMap = {
5930    left: "right",
5931    right: "left",
5932    bottom: "top",
5933    top: "bottom"
5934  };
5935  var oppositeAlignmentMap = {
5936    start: "end",
5937    end: "start"
5938  };
5939  function clamp(start3, value, end) {
5940    return max(start3, min(value, end));
5941  }
5942  function evaluate2(value, param) {
5943    return typeof value === "function" ? value(param) : value;
5944  }
5945  function getSide(placement) {
5946    return placement.split("-")[0];
5947  }
5948  function getAlignment(placement) {
5949    return placement.split("-")[1];
5950  }
5951  function getOppositeAxis(axis) {
5952    return axis === "x" ? "y" : "x";
5953  }
5954  function getAxisLength(axis) {
5955    return axis === "y" ? "height" : "width";
5956  }
5957  function getSideAxis(placement) {
5958    return ["top", "bottom"].includes(getSide(placement)) ? "y" : "x";
5959  }
5960  function getAlignmentAxis(placement) {
5961    return getOppositeAxis(getSideAxis(placement));
5962  }
5963  function getAlignmentSides(placement, rects, rtl) {
5964    if (rtl === void 0) {
5965      rtl = false;
5966    }
5967    const alignment = getAlignment(placement);
5968    const alignmentAxis = getAlignmentAxis(placement);
5969    const length = getAxisLength(alignmentAxis);
5970    let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
5971    if (rects.reference[length] > rects.floating[length]) {
5972      mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
5973    }
5974    return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
5975  }
5976  function getExpandedPlacements(placement) {
5977    const oppositePlacement = getOppositePlacement(placement);
5978    return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
5979  }
5980  function getOppositeAlignmentPlacement(placement) {
5981    return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
5982  }
5983  function getSideList(side, isStart, rtl) {
5984    const lr = ["left", "right"];
5985    const rl = ["right", "left"];
5986    const tb = ["top", "bottom"];
5987    const bt = ["bottom", "top"];
5988    switch (side) {
5989      case "top":
5990      case "bottom":
5991        if (rtl)
5992          return isStart ? rl : lr;
5993        return isStart ? lr : rl;
5994      case "left":
5995      case "right":
5996        return isStart ? tb : bt;
5997      default:
5998        return [];
5999    }
6000  }
6001  function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
6002    const alignment = getAlignment(placement);
6003    let list = getSideList(getSide(placement), direction === "start", rtl);
6004    if (alignment) {
6005      list = list.map((side) => side + "-" + alignment);
6006      if (flipAlignment) {
6007        list = list.concat(list.map(getOppositeAlignmentPlacement));
6008      }
6009    }
6010    return list;
6011  }
6012  function getOppositePlacement(placement) {
6013    return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
6014  }
6015  function expandPaddingObject(padding) {
6016    return {
6017      top: 0,
6018      right: 0,
6019      bottom: 0,
6020      left: 0,
6021      ...padding
6022    };
6023  }
6024  function getPaddingObject(padding) {
6025    return typeof padding !== "number" ? expandPaddingObject(padding) : {
6026      top: padding,
6027      right: padding,
6028      bottom: padding,
6029      left: padding
6030    };
6031  }
6032  function rectToClientRect(rect) {
6033    return {
6034      ...rect,
6035      top: rect.y,
6036      left: rect.x,
6037      right: rect.x + rect.width,
6038      bottom: rect.y + rect.height
6039    };
6040  }
6041  function computeCoordsFromPlacement(_ref, placement, rtl) {
6042    let {
6043      reference,
6044      floating
6045    } = _ref;
6046    const sideAxis = getSideAxis(placement);
6047    const alignmentAxis = getAlignmentAxis(placement);
6048    const alignLength = getAxisLength(alignmentAxis);
6049    const side = getSide(placement);
6050    const isVertical = sideAxis === "y";
6051    const commonX = reference.x + reference.width / 2 - floating.width / 2;
6052    const commonY = reference.y + reference.height / 2 - floating.height / 2;
6053    const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
6054    let coords;
6055    switch (side) {
6056      case "top":
6057        coords = {
6058          x: commonX,
6059          y: reference.y - floating.height
6060        };
6061        break;
6062      case "bottom":
6063        coords = {
6064          x: commonX,
6065          y: reference.y + reference.height
6066        };
6067        break;
6068      case "right":
6069        coords = {
6070          x: reference.x + reference.width,
6071          y: commonY
6072        };
6073        break;
6074      case "left":
6075        coords = {
6076          x: reference.x - floating.width,
6077          y: commonY
6078        };
6079        break;
6080      default:
6081        coords = {
6082          x: reference.x,
6083          y: reference.y
6084        };
6085    }
6086    switch (getAlignment(placement)) {
6087      case "start":
6088        coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
6089        break;
6090      case "end":
6091        coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
6092        break;
6093    }
6094    return coords;
6095  }
6096  var computePosition = async (reference, floating, config) => {
6097    const {
6098      placement = "bottom",
6099      strategy = "absolute",
6100      middleware = [],
6101      platform: platform2
6102    } = config;
6103    const validMiddleware = middleware.filter(Boolean);
6104    const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
6105    let rects = await platform2.getElementRects({
6106      reference,
6107      floating,
6108      strategy
6109    });
6110    let {
6111      x,
6112      y
6113    } = computeCoordsFromPlacement(rects, placement, rtl);
6114    let statefulPlacement = placement;
6115    let middlewareData = {};
6116    let resetCount = 0;
6117    for (let i = 0; i < validMiddleware.length; i++) {
6118      const {
6119        name,
6120        fn
6121      } = validMiddleware[i];
6122      const {
6123        x: nextX,
6124        y: nextY,
6125        data: data2,
6126        reset
6127      } = await fn({
6128        x,
6129        y,
6130        initialPlacement: placement,
6131        placement: statefulPlacement,
6132        strategy,
6133        middlewareData,
6134        rects,
6135        platform: platform2,
6136        elements: {
6137          reference,
6138          floating
6139        }
6140      });
6141      x = nextX != null ? nextX : x;
6142      y = nextY != null ? nextY : y;
6143      middlewareData = {
6144        ...middlewareData,
6145        [name]: {
6146          ...middlewareData[name],
6147          ...data2
6148        }
6149      };
6150      if (reset && resetCount <= 50) {
6151        resetCount++;
6152        if (typeof reset === "object") {
6153          if (reset.placement) {
6154            statefulPlacement = reset.placement;
6155          }
6156          if (reset.rects) {
6157            rects = reset.rects === true ? await platform2.getElementRects({
6158              reference,
6159              floating,
6160              strategy
6161            }) : reset.rects;
6162          }
6163          ({
6164            x,
6165            y
6166          } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
6167        }
6168        i = -1;
6169        continue;
6170      }
6171    }
6172    return {
6173      x,
6174      y,
6175      placement: statefulPlacement,
6176      strategy,
6177      middlewareData
6178    };
6179  };
6180  async function detectOverflow(state, options) {
6181    var _await$platform$isEle;
6182    if (options === void 0) {
6183      options = {};
6184    }
6185    const {
6186      x,
6187      y,
6188      platform: platform2,
6189      rects,
6190      elements,
6191      strategy
6192    } = state;
6193    const {
6194      boundary = "clippingAncestors",
6195      rootBoundary = "viewport",
6196      elementContext = "floating",
6197      altBoundary = false,
6198      padding = 0
6199    } = evaluate2(options, state);
6200    const paddingObject = getPaddingObject(padding);
6201    const altContext = elementContext === "floating" ? "reference" : "floating";
6202    const element = elements[altBoundary ? altContext : elementContext];
6203    const clippingClientRect = rectToClientRect(await platform2.getClippingRect({
6204      element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
6205      boundary,
6206      rootBoundary,
6207      strategy
6208    }));
6209    const rect = elementContext === "floating" ? {
6210      ...rects.floating,
6211      x,
6212      y
6213    } : rects.reference;
6214    const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating));
6215    const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
6216      x: 1,
6217      y: 1
6218    } : {
6219      x: 1,
6220      y: 1
6221    };
6222    const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
6223      rect,
6224      offsetParent,
6225      strategy
6226    }) : rect);
6227    return {
6228      top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
6229      bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
6230      left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
6231      right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
6232    };
6233  }
6234  var flip = function(options) {
6235    if (options === void 0) {
6236      options = {};
6237    }
6238    return {
6239      name: "flip",
6240      options,
6241      async fn(state) {
6242        var _middlewareData$arrow, _middlewareData$flip;
6243        const {
6244          placement,
6245          middlewareData,
6246          rects,
6247          initialPlacement,
6248          platform: platform2,
6249          elements
6250        } = state;
6251        const {
6252          mainAxis: checkMainAxis = true,
6253          crossAxis: checkCrossAxis = true,
6254          fallbackPlacements: specifiedFallbackPlacements,
6255          fallbackStrategy = "bestFit",
6256          fallbackAxisSideDirection = "none",
6257          flipAlignment = true,
6258          ...detectOverflowOptions
6259        } = evaluate2(options, state);
6260        if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
6261          return {};
6262        }
6263        const side = getSide(placement);
6264        const isBasePlacement = getSide(initialPlacement) === initialPlacement;
6265        const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
6266        const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
6267        if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== "none") {
6268          fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
6269        }
6270        const placements2 = [initialPlacement, ...fallbackPlacements];
6271        const overflow = await detectOverflow(state, detectOverflowOptions);
6272        const overflows = [];
6273        let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
6274        if (checkMainAxis) {
6275          overflows.push(overflow[side]);
6276        }
6277        if (checkCrossAxis) {
6278          const sides2 = getAlignmentSides(placement, rects, rtl);
6279          overflows.push(overflow[sides2[0]], overflow[sides2[1]]);
6280        }
6281        overflowsData = [...overflowsData, {
6282          placement,
6283          overflows
6284        }];
6285        if (!overflows.every((side2) => side2 <= 0)) {
6286          var _middlewareData$flip2, _overflowsData$filter;
6287          const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
6288          const nextPlacement = placements2[nextIndex];
6289          if (nextPlacement) {
6290            return {
6291              data: {
6292                index: nextIndex,
6293                overflows: overflowsData
6294              },
6295              reset: {
6296                placement: nextPlacement
6297              }
6298            };
6299          }
6300          let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
6301          if (!resetPlacement) {
6302            switch (fallbackStrategy) {
6303              case "bestFit": {
6304                var _overflowsData$map$so;
6305                const placement2 = (_overflowsData$map$so = overflowsData.map((d) => [d.placement, d.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0];
6306                if (placement2) {
6307                  resetPlacement = placement2;
6308                }
6309                break;
6310              }
6311              case "initialPlacement":
6312                resetPlacement = initialPlacement;
6313                break;
6314            }
6315          }
6316          if (placement !== resetPlacement) {
6317            return {
6318              reset: {
6319                placement: resetPlacement
6320              }
6321            };
6322          }
6323        }
6324        return {};
6325      }
6326    };
6327  };
6328  async function convertValueToCoords(state, options) {
6329    const {
6330      placement,
6331      platform: platform2,
6332      elements
6333    } = state;
6334    const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
6335    const side = getSide(placement);
6336    const alignment = getAlignment(placement);
6337    const isVertical = getSideAxis(placement) === "y";
6338    const mainAxisMulti = ["left", "top"].includes(side) ? -1 : 1;
6339    const crossAxisMulti = rtl && isVertical ? -1 : 1;
6340    const rawValue = evaluate2(options, state);
6341    let {
6342      mainAxis,
6343      crossAxis,
6344      alignmentAxis
6345    } = typeof rawValue === "number" ? {
6346      mainAxis: rawValue,
6347      crossAxis: 0,
6348      alignmentAxis: null
6349    } : {
6350      mainAxis: 0,
6351      crossAxis: 0,
6352      alignmentAxis: null,
6353      ...rawValue
6354    };
6355    if (alignment && typeof alignmentAxis === "number") {
6356      crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
6357    }
6358    return isVertical ? {
6359      x: crossAxis * crossAxisMulti,
6360      y: mainAxis * mainAxisMulti
6361    } : {
6362      x: mainAxis * mainAxisMulti,
6363      y: crossAxis * crossAxisMulti
6364    };
6365  }
6366  var offset = function(options) {
6367    if (options === void 0) {
6368      options = 0;
6369    }
6370    return {
6371      name: "offset",
6372      options,
6373      async fn(state) {
6374        const {
6375          x,
6376          y
6377        } = state;
6378        const diffCoords = await convertValueToCoords(state, options);
6379        return {
6380          x: x + diffCoords.x,
6381          y: y + diffCoords.y,
6382          data: diffCoords
6383        };
6384      }
6385    };
6386  };
6387  var shift = function(options) {
6388    if (options === void 0) {
6389      options = {};
6390    }
6391    return {
6392      name: "shift",
6393      options,
6394      async fn(state) {
6395        const {
6396          x,
6397          y,
6398          placement
6399        } = state;
6400        const {
6401          mainAxis: checkMainAxis = true,
6402          crossAxis: checkCrossAxis = false,
6403          limiter = {
6404            fn: (_ref) => {
6405              let {
6406                x: x2,
6407                y: y2
6408              } = _ref;
6409              return {
6410                x: x2,
6411                y: y2
6412              };
6413            }
6414          },
6415          ...detectOverflowOptions
6416        } = evaluate2(options, state);
6417        const coords = {
6418          x,
6419          y
6420        };
6421        const overflow = await detectOverflow(state, detectOverflowOptions);
6422        const crossAxis = getSideAxis(getSide(placement));
6423        const mainAxis = getOppositeAxis(crossAxis);
6424        let mainAxisCoord = coords[mainAxis];
6425        let crossAxisCoord = coords[crossAxis];
6426        if (checkMainAxis) {
6427          const minSide = mainAxis === "y" ? "top" : "left";
6428          const maxSide = mainAxis === "y" ? "bottom" : "right";
6429          const min2 = mainAxisCoord + overflow[minSide];
6430          const max2 = mainAxisCoord - overflow[maxSide];
6431          mainAxisCoord = clamp(min2, mainAxisCoord, max2);
6432        }
6433        if (checkCrossAxis) {
6434          const minSide = crossAxis === "y" ? "top" : "left";
6435          const maxSide = crossAxis === "y" ? "bottom" : "right";
6436          const min2 = crossAxisCoord + overflow[minSide];
6437          const max2 = crossAxisCoord - overflow[maxSide];
6438          crossAxisCoord = clamp(min2, crossAxisCoord, max2);
6439        }
6440        const limitedCoords = limiter.fn({
6441          ...state,
6442          [mainAxis]: mainAxisCoord,
6443          [crossAxis]: crossAxisCoord
6444        });
6445        return {
6446          ...limitedCoords,
6447          data: {
6448            x: limitedCoords.x - x,
6449            y: limitedCoords.y - y
6450          }
6451        };
6452      }
6453    };
6454  };
6455  function getNodeName(node) {
6456    if (isNode(node)) {
6457      return (node.nodeName || "").toLowerCase();
6458    }
6459    return "#document";
6460  }
6461  function getWindow(node) {
6462    var _node$ownerDocument;
6463    return (node == null ? void 0 : (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
6464  }
6465  function getDocumentElement(node) {
6466    var _ref;
6467    return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
6468  }
6469  function isNode(value) {
6470    return value instanceof Node || value instanceof getWindow(value).Node;
6471  }
6472  function isElement(value) {
6473    return value instanceof Element || value instanceof getWindow(value).Element;
6474  }
6475  function isHTMLElement(value) {
6476    return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
6477  }
6478  function isShadowRoot(value) {
6479    if (typeof ShadowRoot === "undefined") {
6480      return false;
6481    }
6482    return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
6483  }
6484  function isOverflowElement(element) {
6485    const {
6486      overflow,
6487      overflowX,
6488      overflowY,
6489      display
6490    } = getComputedStyle2(element);
6491    return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !["inline", "contents"].includes(display);
6492  }
6493  function isTableElement(element) {
6494    return ["table", "td", "th"].includes(getNodeName(element));
6495  }
6496  function isContainingBlock(element) {
6497    const webkit = isWebKit();
6498    const css = getComputedStyle2(element);
6499    return css.transform !== "none" || css.perspective !== "none" || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || ["transform", "perspective", "filter"].some((value) => (css.willChange || "").includes(value)) || ["paint", "layout", "strict", "content"].some((value) => (css.contain || "").includes(value));
6500  }
6501  function getContainingBlock(element) {
6502    let currentNode = getParentNode(element);
6503    while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {
6504      if (isContainingBlock(currentNode)) {
6505        return currentNode;
6506      } else {
6507        currentNode = getParentNode(currentNode);
6508      }
6509    }
6510    return null;
6511  }
6512  function isWebKit() {
6513    if (typeof CSS === "undefined" || !CSS.supports)
6514      return false;
6515    return CSS.supports("-webkit-backdrop-filter", "none");
6516  }
6517  function isLastTraversableNode(node) {
6518    return ["html", "body", "#document"].includes(getNodeName(node));
6519  }
6520  function getComputedStyle2(element) {
6521    return getWindow(element).getComputedStyle(element);
6522  }
6523  function getNodeScroll(element) {
6524    if (isElement(element)) {
6525      return {
6526        scrollLeft: element.scrollLeft,
6527        scrollTop: element.scrollTop
6528      };
6529    }
6530    return {
6531      scrollLeft: element.pageXOffset,
6532      scrollTop: element.pageYOffset
6533    };
6534  }
6535  function getParentNode(node) {
6536    if (getNodeName(node) === "html") {
6537      return node;
6538    }
6539    const result = node.assignedSlot || node.parentNode || isShadowRoot(node) && node.host || getDocumentElement(node);
6540    return isShadowRoot(result) ? result.host : result;
6541  }
6542  function getNearestOverflowAncestor(node) {
6543    const parentNode = getParentNode(node);
6544    if (isLastTraversableNode(parentNode)) {
6545      return node.ownerDocument ? node.ownerDocument.body : node.body;
6546    }
6547    if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
6548      return parentNode;
6549    }
6550    return getNearestOverflowAncestor(parentNode);
6551  }
6552  function getOverflowAncestors(node, list, traverseIframes) {
6553    var _node$ownerDocument2;
6554    if (list === void 0) {
6555      list = [];
6556    }
6557    if (traverseIframes === void 0) {
6558      traverseIframes = true;
6559    }
6560    const scrollableAncestor = getNearestOverflowAncestor(node);
6561    const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
6562    const win = getWindow(scrollableAncestor);
6563    if (isBody) {
6564      return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);
6565    }
6566    return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
6567  }
6568  function getCssDimensions(element) {
6569    const css = getComputedStyle2(element);
6570    let width = parseFloat(css.width) || 0;
6571    let height = parseFloat(css.height) || 0;
6572    const hasOffset = isHTMLElement(element);
6573    const offsetWidth = hasOffset ? element.offsetWidth : width;
6574    const offsetHeight = hasOffset ? element.offsetHeight : height;
6575    const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
6576    if (shouldFallback) {
6577      width = offsetWidth;
6578      height = offsetHeight;
6579    }
6580    return {
6581      width,
6582      height,
6583      $: shouldFallback
6584    };
6585  }
6586  function unwrapElement(element) {
6587    return !isElement(element) ? element.contextElement : element;
6588  }
6589  function getScale(element) {
6590    const domElement = unwrapElement(element);
6591    if (!isHTMLElement(domElement)) {
6592      return createCoords(1);
6593    }
6594    const rect = domElement.getBoundingClientRect();
6595    const {
6596      width,
6597      height,
6598      $
6599    } = getCssDimensions(domElement);
6600    let x = ($ ? round(rect.width) : rect.width) / width;
6601    let y = ($ ? round(rect.height) : rect.height) / height;
6602    if (!x || !Number.isFinite(x)) {
6603      x = 1;
6604    }
6605    if (!y || !Number.isFinite(y)) {
6606      y = 1;
6607    }
6608    return {
6609      x,
6610      y
6611    };
6612  }
6613  var noOffsets = /* @__PURE__ */ createCoords(0);
6614  function getVisualOffsets(element) {
6615    const win = getWindow(element);

vendor: 4,610 bytes, lines 6616-6744

6616    if (!isWebKit() || !win.visualViewport) {
6617      return noOffsets;
6618    }
6619    return {
6620      x: win.visualViewport.offsetLeft,
6621      y: win.visualViewport.offsetTop
6622    };
6623  }
6624  function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) {
6625    if (isFixed === void 0) {
6626      isFixed = false;
6627    }
6628    if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) {
6629      return false;
6630    }
6631    return isFixed;
6632  }
6633  function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {
6634    if (includeScale === void 0) {
6635      includeScale = false;
6636    }
6637    if (isFixedStrategy === void 0) {
6638      isFixedStrategy = false;
6639    }
6640    const clientRect = element.getBoundingClientRect();
6641    const domElement = unwrapElement(element);
6642    let scale = createCoords(1);
6643    if (includeScale) {
6644      if (offsetParent) {
6645        if (isElement(offsetParent)) {
6646          scale = getScale(offsetParent);
6647        }
6648      } else {
6649        scale = getScale(element);
6650      }
6651    }
6652    const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
6653    let x = (clientRect.left + visualOffsets.x) / scale.x;
6654    let y = (clientRect.top + visualOffsets.y) / scale.y;
6655    let width = clientRect.width / scale.x;
6656    let height = clientRect.height / scale.y;
6657    if (domElement) {
6658      const win = getWindow(domElement);
6659      const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;
6660      let currentIFrame = win.frameElement;
6661      while (currentIFrame && offsetParent && offsetWin !== win) {
6662        const iframeScale = getScale(currentIFrame);
6663        const iframeRect = currentIFrame.getBoundingClientRect();
6664        const css = getComputedStyle2(currentIFrame);
6665        const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
6666        const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
6667        x *= iframeScale.x;
6668        y *= iframeScale.y;
6669        width *= iframeScale.x;
6670        height *= iframeScale.y;
6671        x += left;
6672        y += top;
6673        currentIFrame = getWindow(currentIFrame).frameElement;
6674      }
6675    }
6676    return rectToClientRect({
6677      width,
6678      height,
6679      x,
6680      y
6681    });
6682  }
6683  function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
6684    let {
6685      rect,
6686      offsetParent,
6687      strategy
6688    } = _ref;
6689    const isOffsetParentAnElement = isHTMLElement(offsetParent);
6690    const documentElement = getDocumentElement(offsetParent);
6691    if (offsetParent === documentElement) {
6692      return rect;
6693    }
6694    let scroll = {
6695      scrollLeft: 0,
6696      scrollTop: 0
6697    };
6698    let scale = createCoords(1);
6699    const offsets = createCoords(0);
6700    if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== "fixed") {
6701      if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
6702        scroll = getNodeScroll(offsetParent);
6703      }
6704      if (isHTMLElement(offsetParent)) {
6705        const offsetRect = getBoundingClientRect(offsetParent);
6706        scale = getScale(offsetParent);
6707        offsets.x = offsetRect.x + offsetParent.clientLeft;
6708        offsets.y = offsetRect.y + offsetParent.clientTop;
6709      }
6710    }
6711    return {
6712      width: rect.width * scale.x,
6713      height: rect.height * scale.y,
6714      x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,
6715      y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y
6716    };
6717  }
6718  function getClientRects(element) {
6719    return Array.from(element.getClientRects());
6720  }
6721  function getWindowScrollBarX(element) {
6722    return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
6723  }
6724  function getDocumentRect(element) {
6725    const html = getDocumentElement(element);
6726    const scroll = getNodeScroll(element);
6727    const body = element.ownerDocument.body;
6728    const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
6729    const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
6730    let x = -scroll.scrollLeft + getWindowScrollBarX(element);
6731    const y = -scroll.scrollTop;
6732    if (getComputedStyle2(body).direction === "rtl") {
6733      x += max(html.clientWidth, body.clientWidth) - width;
6734    }
6735    return {
6736      width,
6737      height,
6738      x,
6739      y
6740    };
6741  }
6742  function getViewportRect(element, strategy) {
6743    const win = getWindow(element);
6744    const html = getDocumentElement(element);

vendor: 12,549 bytes, lines 6745-7096

6745    const visualViewport = win.visualViewport;
6746    let width = html.clientWidth;
6747    let height = html.clientHeight;
6748    let x = 0;
6749    let y = 0;
6750    if (visualViewport) {
6751      width = visualViewport.width;
6752      height = visualViewport.height;
6753      const visualViewportBased = isWebKit();
6754      if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
6755        x = visualViewport.offsetLeft;
6756        y = visualViewport.offsetTop;
6757      }
6758    }
6759    return {
6760      width,
6761      height,
6762      x,
6763      y
6764    };
6765  }
6766  function getInnerBoundingClientRect(element, strategy) {
6767    const clientRect = getBoundingClientRect(element, true, strategy === "fixed");
6768    const top = clientRect.top + element.clientTop;
6769    const left = clientRect.left + element.clientLeft;
6770    const scale = isHTMLElement(element) ? getScale(element) : createCoords(1);
6771    const width = element.clientWidth * scale.x;
6772    const height = element.clientHeight * scale.y;
6773    const x = left * scale.x;
6774    const y = top * scale.y;
6775    return {
6776      width,
6777      height,
6778      x,
6779      y
6780    };
6781  }
6782  function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {
6783    let rect;
6784    if (clippingAncestor === "viewport") {
6785      rect = getViewportRect(element, strategy);
6786    } else if (clippingAncestor === "document") {
6787      rect = getDocumentRect(getDocumentElement(element));
6788    } else if (isElement(clippingAncestor)) {
6789      rect = getInnerBoundingClientRect(clippingAncestor, strategy);
6790    } else {
6791      const visualOffsets = getVisualOffsets(element);
6792      rect = {
6793        ...clippingAncestor,
6794        x: clippingAncestor.x - visualOffsets.x,
6795        y: clippingAncestor.y - visualOffsets.y
6796      };
6797    }
6798    return rectToClientRect(rect);
6799  }
6800  function hasFixedPositionAncestor(element, stopNode) {
6801    const parentNode = getParentNode(element);
6802    if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {
6803      return false;
6804    }
6805    return getComputedStyle2(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
6806  }
6807  function getClippingElementAncestors(element, cache) {
6808    const cachedResult = cache.get(element);
6809    if (cachedResult) {
6810      return cachedResult;
6811    }
6812    let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body");
6813    let currentContainingBlockComputedStyle = null;
6814    const elementIsFixed = getComputedStyle2(element).position === "fixed";
6815    let currentNode = elementIsFixed ? getParentNode(element) : element;
6816    while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {
6817      const computedStyle = getComputedStyle2(currentNode);
6818      const currentNodeIsContaining = isContainingBlock(currentNode);
6819      if (!currentNodeIsContaining && computedStyle.position === "fixed") {
6820        currentContainingBlockComputedStyle = null;
6821      }
6822      const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && ["absolute", "fixed"].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);
6823      if (shouldDropCurrentNode) {
6824        result = result.filter((ancestor) => ancestor !== currentNode);
6825      } else {
6826        currentContainingBlockComputedStyle = computedStyle;
6827      }
6828      currentNode = getParentNode(currentNode);
6829    }
6830    cache.set(element, result);
6831    return result;
6832  }
6833  function getClippingRect(_ref) {
6834    let {
6835      element,
6836      boundary,
6837      rootBoundary,
6838      strategy
6839    } = _ref;
6840    const elementClippingAncestors = boundary === "clippingAncestors" ? getClippingElementAncestors(element, this._c) : [].concat(boundary);
6841    const clippingAncestors = [...elementClippingAncestors, rootBoundary];
6842    const firstClippingAncestor = clippingAncestors[0];
6843    const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
6844      const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
6845      accRect.top = max(rect.top, accRect.top);
6846      accRect.right = min(rect.right, accRect.right);
6847      accRect.bottom = min(rect.bottom, accRect.bottom);
6848      accRect.left = max(rect.left, accRect.left);
6849      return accRect;
6850    }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
6851    return {
6852      width: clippingRect.right - clippingRect.left,
6853      height: clippingRect.bottom - clippingRect.top,
6854      x: clippingRect.left,
6855      y: clippingRect.top
6856    };
6857  }
6858  function getDimensions(element) {
6859    return getCssDimensions(element);
6860  }
6861  function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
6862    const isOffsetParentAnElement = isHTMLElement(offsetParent);
6863    const documentElement = getDocumentElement(offsetParent);
6864    const isFixed = strategy === "fixed";
6865    const rect = getBoundingClientRect(element, true, isFixed, offsetParent);
6866    let scroll = {
6867      scrollLeft: 0,
6868      scrollTop: 0
6869    };
6870    const offsets = createCoords(0);
6871    if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
6872      if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
6873        scroll = getNodeScroll(offsetParent);
6874      }
6875      if (isOffsetParentAnElement) {
6876        const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
6877        offsets.x = offsetRect.x + offsetParent.clientLeft;
6878        offsets.y = offsetRect.y + offsetParent.clientTop;
6879      } else if (documentElement) {
6880        offsets.x = getWindowScrollBarX(documentElement);
6881      }
6882    }
6883    return {
6884      x: rect.left + scroll.scrollLeft - offsets.x,
6885      y: rect.top + scroll.scrollTop - offsets.y,
6886      width: rect.width,
6887      height: rect.height
6888    };
6889  }
6890  function getTrueOffsetParent(element, polyfill) {
6891    if (!isHTMLElement(element) || getComputedStyle2(element).position === "fixed") {
6892      return null;
6893    }
6894    if (polyfill) {
6895      return polyfill(element);
6896    }
6897    return element.offsetParent;
6898  }
6899  function getOffsetParent(element, polyfill) {
6900    const window2 = getWindow(element);
6901    if (!isHTMLElement(element)) {
6902      return window2;
6903    }
6904    let offsetParent = getTrueOffsetParent(element, polyfill);
6905    while (offsetParent && isTableElement(offsetParent) && getComputedStyle2(offsetParent).position === "static") {
6906      offsetParent = getTrueOffsetParent(offsetParent, polyfill);
6907    }
6908    if (offsetParent && (getNodeName(offsetParent) === "html" || getNodeName(offsetParent) === "body" && getComputedStyle2(offsetParent).position === "static" && !isContainingBlock(offsetParent))) {
6909      return window2;
6910    }
6911    return offsetParent || getContainingBlock(element) || window2;
6912  }
6913  var getElementRects = async function(_ref) {
6914    let {
6915      reference,
6916      floating,
6917      strategy
6918    } = _ref;
6919    const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
6920    const getDimensionsFn = this.getDimensions;
6921    return {
6922      reference: getRectRelativeToOffsetParent(reference, await getOffsetParentFn(floating), strategy),
6923      floating: {
6924        x: 0,
6925        y: 0,
6926        ...await getDimensionsFn(floating)
6927      }
6928    };
6929  };
6930  function isRTL(element) {
6931    return getComputedStyle2(element).direction === "rtl";
6932  }
6933  var platform = {
6934    convertOffsetParentRelativeRectToViewportRelativeRect,
6935    getDocumentElement,
6936    getClippingRect,
6937    getOffsetParent,
6938    getElementRects,
6939    getClientRects,
6940    getDimensions,
6941    getScale,
6942    isElement,
6943    isRTL
6944  };
6945  function observeMove(element, onMove) {
6946    let io = null;
6947    let timeoutId;
6948    const root = getDocumentElement(element);
6949    function cleanup2() {
6950      clearTimeout(timeoutId);
6951      io && io.disconnect();
6952      io = null;
6953    }
6954    function refresh(skip, threshold) {
6955      if (skip === void 0) {
6956        skip = false;
6957      }
6958      if (threshold === void 0) {
6959        threshold = 1;
6960      }
6961      cleanup2();
6962      const {
6963        left,
6964        top,
6965        width,
6966        height
6967      } = element.getBoundingClientRect();
6968      if (!skip) {
6969        onMove();
6970      }
6971      if (!width || !height) {
6972        return;
6973      }
6974      const insetTop = floor(top);
6975      const insetRight = floor(root.clientWidth - (left + width));
6976      const insetBottom = floor(root.clientHeight - (top + height));
6977      const insetLeft = floor(left);
6978      const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
6979      const options = {
6980        rootMargin,
6981        threshold: max(0, min(1, threshold)) || 1
6982      };
6983      let isFirstUpdate = true;
6984      function handleObserve(entries) {
6985        const ratio = entries[0].intersectionRatio;
6986        if (ratio !== threshold) {
6987          if (!isFirstUpdate) {
6988            return refresh();
6989          }
6990          if (!ratio) {
6991            timeoutId = setTimeout(() => {
6992              refresh(false, 1e-7);
6993            }, 100);
6994          } else {
6995            refresh(false, ratio);
6996          }
6997        }
6998        isFirstUpdate = false;
6999      }
7000      try {
7001        io = new IntersectionObserver(handleObserve, {
7002          ...options,
7003          root: root.ownerDocument
7004        });
7005      } catch (e) {
7006        io = new IntersectionObserver(handleObserve, options);
7007      }
7008      io.observe(element);
7009    }
7010    refresh(true);
7011    return cleanup2;
7012  }
7013  function autoUpdate(reference, floating, update, options) {
7014    if (options === void 0) {
7015      options = {};
7016    }
7017    const {
7018      ancestorScroll = true,
7019      ancestorResize = true,
7020      elementResize = typeof ResizeObserver === "function",
7021      layoutShift = typeof IntersectionObserver === "function",
7022      animationFrame = false
7023    } = options;
7024    const referenceEl = unwrapElement(reference);
7025    const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...getOverflowAncestors(floating)] : [];
7026    ancestors.forEach((ancestor) => {
7027      ancestorScroll && ancestor.addEventListener("scroll", update, {
7028        passive: true
7029      });
7030      ancestorResize && ancestor.addEventListener("resize", update);
7031    });
7032    const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
7033    let reobserveFrame = -1;
7034    let resizeObserver = null;
7035    if (elementResize) {
7036      resizeObserver = new ResizeObserver((_ref) => {
7037        let [firstEntry] = _ref;
7038        if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {
7039          resizeObserver.unobserve(floating);
7040          cancelAnimationFrame(reobserveFrame);
7041          reobserveFrame = requestAnimationFrame(() => {
7042            resizeObserver && resizeObserver.observe(floating);
7043          });
7044        }
7045        update();
7046      });
7047      if (referenceEl && !animationFrame) {
7048        resizeObserver.observe(referenceEl);
7049      }
7050      resizeObserver.observe(floating);
7051    }
7052    let frameId;
7053    let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
7054    if (animationFrame) {
7055      frameLoop();
7056    }
7057    function frameLoop() {
7058      const nextRefRect = getBoundingClientRect(reference);
7059      if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
7060        update();
7061      }
7062      prevRefRect = nextRefRect;
7063      frameId = requestAnimationFrame(frameLoop);
7064    }
7065    update();
7066    return () => {
7067      ancestors.forEach((ancestor) => {
7068        ancestorScroll && ancestor.removeEventListener("scroll", update);
7069        ancestorResize && ancestor.removeEventListener("resize", update);
7070      });
7071      cleanupIo && cleanupIo();
7072      resizeObserver && resizeObserver.disconnect();
7073      resizeObserver = null;
7074      if (animationFrame) {
7075        cancelAnimationFrame(frameId);
7076      }
7077    };
7078  }
7079  var computePosition2 = (reference, floating, options) => {
7080    const cache = /* @__PURE__ */ new Map();
7081    const mergedOptions = {
7082      platform,
7083      ...options
7084    };
7085    const platformWithCache = {
7086      ...mergedOptions.platform,
7087      _c: cache
7088    };
7089    return computePosition(reference, floating, {
7090      ...mergedOptions,
7091      platform: platformWithCache
7092    });
7093  };
7094  function src_default6(Alpine3) {
7095    Alpine3.magic("anchor", (el) => {
7096      if (!el._x_anchor)

7097        throw "Alpine: No x-anchor directive found on element using $anchor...";
7098      return el._x_anchor;
7099    });
7100    Alpine3.interceptClone((from, to) => {
7101      if (from && from._x_anchor && !to._x_anchor) {
7102        to._x_anchor = from._x_anchor;
7103      }
7104    });
7105    Alpine3.directive("anchor", Alpine3.skipDuringClone((el, { expression, modifiers, value }, { cleanup: cleanup2, evaluate: evaluate22 }) => {
7106      let { placement, offsetValue, unstyled } = getOptions(modifiers);
7107      el._x_anchor = Alpine3.reactive({ x: 0, y: 0 });
7108      let reference = evaluate22(expression);
7109      if (!reference)
7110        throw "Alpine: no element provided to x-anchor...";
7111      let compute = () => {
7112        let previousValue;
7113        computePosition2(reference, el, {
7114          placement,
7115          middleware: [flip(), shift({ padding: 5 }), offset(offsetValue)]
7116        }).then(({ x, y }) => {
7117          unstyled || setStyles2(el, x, y);
7118          if (JSON.stringify({ x, y }) !== previousValue) {
7119            el._x_anchor.x = x;
7120            el._x_anchor.y = y;
7121          }
7122          previousValue = JSON.stringify({ x, y });
7123        });
7124      };
7125      let release2 = autoUpdate(reference, el, () => compute());
7126      cleanup2(() => release2());
7127    }, (el, { expression, modifiers, value }, { cleanup: cleanup2, evaluate: evaluate22 }) => {
7128      let { placement, offsetValue, unstyled } = getOptions(modifiers);
7129      if (el._x_anchor) {
7130        unstyled || setStyles2(el, el._x_anchor.x, el._x_anchor.y);
7131      }
7132    }));
7133  }
7134  function setStyles2(el, x, y) {
7135    Object.assign(el.style, {
7136      left: x + "px",
7137      top: y + "px",
7138      position: "absolute"
7139    });
7140  }
7141  function getOptions(modifiers) {
7142    let positions = ["top", "top-start", "top-end", "right", "right-start", "right-end", "bottom", "bottom-start", "bottom-end", "left", "left-start", "left-end"];
7143    let placement = positions.find((i) => modifiers.includes(i));
7144    let offsetValue = 0;
7145    if (modifiers.includes("offset")) {
7146      let idx = modifiers.findIndex((i) => i === "offset");
7147      offsetValue = modifiers[idx + 1] !== void 0 ? Number(modifiers[idx + 1]) : offsetValue;
7148    }
7149    let unstyled = modifiers.includes("no-style");
7150    return { placement, offsetValue, unstyled };
7151  }
7152  var module_default6 = src_default6;
7153
7154

7154// js/plugins/navigate/history.js
7155  var Snapshot = class {
7156    constructor(url, html) {
7157      this.url = url;
7158      this.html = html;
7159    }
7160  };
7161  var snapshotCache = {
7162    currentKey: null,
7163    currentUrl: null,
7164    keys: [],
7165    lookup: {},
7166    limit: 10,
7167    has(location) {
7168      return this.lookup[location] !== void 0;
7169    },
7170    retrieve(location) {
7171      let snapshot = this.lookup[location];
7172      if (snapshot === void 0)
7173        throw "No back button cache found for current location: " + location;
7174      return snapshot;
7175    },
7176    replace(key, snapshot) {
7177      if (this.has(key)) {
7178        this.lookup[key] = snapshot;
7179      } else {
7180        this.push(key, snapshot);
7181      }
7182    },
7183    push(key, snapshot) {
7184      this.lookup[key] = snapshot;
7185      let index = this.keys.indexOf(key);
7186      if (index > -1)
7187        this.keys.splice(index, 1);
7188      this.keys.unshift(key);
7189      this.trim();
7190    },
7191    trim() {
7192      for (let key of this.keys.splice(this.limit)) {
7193        delete this.lookup[key];
7194      }
7195    }
7196  };
7197  function updateCurrentPageHtmlInHistoryStateForLaterBackButtonClicks() {
7198    let url = new URL(window.location.href, document.baseURI);
7199    replaceUrl(url, document.documentElement.outerHTML);
7200  }
7201  function updateCurrentPageHtmlInSnapshotCacheForLaterBackButtonClicks(key, url) {
7202    let html = document.documentElement.outerHTML;
7203    snapshotCache.replace(key, new Snapshot(url, html));
7204  }
7205  function whenTheBackOrForwardButtonIsClicked(registerFallback, handleHtml) {
7206    let fallback2;
7207    registerFallback((i) => fallback2 = i);
7208    window.addEventListener("popstate", (e) => {
7209      let state = e.state || {};
7210      let alpine = state.alpine || {};
7211      if (Object.keys(state).length === 0)
7212        return;
7213      if (!alpine.snapshotIdx)
7214        return;
7215      if (snapshotCache.has(alpine.snapshotIdx)) {
7216        let snapshot = snapshotCache.retrieve(alpine.snapshotIdx);
7217        handleHtml(snapshot.html, snapshot.url, snapshotCache.currentUrl, snapshotCache.currentKey);
7218      } else {
7219        fallback2(alpine.url);
7220      }
7221    });
7222  }
7223  function updateUrlAndStoreLatestHtmlForFutureBackButtons(html, destination) {
7224    pushUrl(destination, html);
7225  }
7226  function pushUrl(url, html) {
7227    updateUrl("pushState", url, html);
7228  }
7229  function replaceUrl(url, html) {
7230    updateUrl("replaceState", url, html);
7231  }
7232  function updateUrl(method, url, html) {
7233    let key = url.toString() + "-" + Math.random();
7234    method === "pushState" ? snapshotCache.push(key, new Snapshot(url, html)) : snapshotCache.replace(key = snapshotCache.currentKey ?? key, new Snapshot(url, html));
7235    let state = history.state || {};
7236    if (!state.alpine)
7237      state.alpine = {};
7238    state.alpine.snapshotIdx = key;
7239    state.alpine.url = url.toString();
7240    try {
7241      history[method](state, JSON.stringify(document.title), url);
7242      snapshotCache.currentKey = key;
7243      snapshotCache.currentUrl = url;
7244    } catch (error2) {
7245      if (error2 instanceof DOMException && error2.name === "SecurityError") {
7246        console.error("Livewire: You can't use wire:navigate with a link to a different root domain: " + url);
7247      }
7248      console.error(error2);
7249    }
7250  }
7251
7252

7252// js/plugins/navigate/links.js
7253  function whenThisLinkIsPressed(el, callback) {
7254    let isProgrammaticClick = (e) => !e.isTrusted;
7255    let isNotPlainLeftClick = (e) => e.which > 1 || e.altKey || e.ctrlKey || e.metaKey || e.shiftKey;
7256    let isNotPlainEnterKey = (e) => e.which !== 13 || e.altKey || e.ctrlKey || e.metaKey || e.shiftKey;
7257    el.addEventListener("click", (e) => {
7258      if (isProgrammaticClick(e)) {
7259        e.preventDefault();
7260        callback((whenReleased) => whenReleased());
7261        return;
7262      }
7263      if (isNotPlainLeftClick(e))
7264        return;
7265      e.preventDefault();
7266    });
7267    el.addEventListener("mousedown", (e) => {
7268      if (isNotPlainLeftClick(e))
7269        return;
7270      e.preventDefault();
7271      callback((whenReleased) => {
7272        let handler4 = (e2) => {
7273          e2.preventDefault();
7274          whenReleased();
7275          el.removeEventListener("mouseup", handler4);
7276        };
7277        el.addEventListener("mouseup", handler4);
7278      });
7279    });
7280    el.addEventListener("keydown", (e) => {
7281      if (isNotPlainEnterKey(e))
7282        return;
7283      e.preventDefault();
7284      callback((whenReleased) => whenReleased());
7285    });
7286  }
7287  function whenThisLinkIsHoveredFor(el, ms = 60, callback) {
7288    el.addEventListener("mouseenter", (e) => {
7289      let timeout = setTimeout(() => {
7290        callback(e);
7291      }, ms);
7292      let handler4 = () => {
7293        clearTimeout(timeout);
7294        el.removeEventListener("mouseleave", handler4);
7295      };
7296      el.addEventListener("mouseleave", handler4);
7297    });
7298  }
7299  function extractDestinationFromLink(linkEl) {
7300    return createUrlObjectFromString(linkEl.getAttribute("href"));
7301  }
7302  function createUrlObjectFromString(urlString) {
7303    return new URL(urlString, document.baseURI);
7304  }
7305  function getUriStringFromUrlObject(urlObject) {
7306    return urlObject.pathname + urlObject.search + urlObject.hash;
7307  }
7308
7309

7309// js/plugins/navigate/fetch.js
7310  function fetchHtml(destination, callback) {
7311    let uri = getUriStringFromUrlObject(destination);
7312    performFetch(uri, (html, finalDestination) => {
7313      callback(html, finalDestination);
7314    });
7315  }
7316  function performFetch(uri, callback) {
7317    let options = {
7318      headers: {
7319        "X-Livewire-Navigate": ""
7320      }
7321    };
7322    trigger2("navigate.request", {
7323      url: uri,
7324      options
7325    });
7326    let finalDestination;
7327    fetch(uri, options).then((response) => {
7328      let destination = createUrlObjectFromString(uri);
7329      finalDestination = createUrlObjectFromString(response.url);
7330      if (destination.pathname + destination.search === finalDestination.pathname + finalDestination.search) {
7331        finalDestination.hash = destination.hash;
7332      }
7333      return response.text();
7334    }).then((html) => {
7335      callback(html, finalDestination);
7336    });
7337  }
7338
7339

7339// js/plugins/navigate/prefetch.js
7340  var prefetches = {};
7341  function prefetchHtml(destination, callback) {
7342    let uri = getUriStringFromUrlObject(destination);
7343    if (prefetches[uri])
7344      return;
7345    prefetches[uri] = { finished: false, html: null, whenFinished: () => {
7346    } };
7347    performFetch(uri, (html, routedUri) => {
7348      callback(html, routedUri);
7349    });
7350  }
7351  function storeThePrefetchedHtmlForWhenALinkIsClicked(html, destination, finalDestination) {
7352    let state = prefetches[getUriStringFromUrlObject(destination)];
7353    state.html = html;
7354    state.finished = true;
7355    state.finalDestination = finalDestination;
7356    state.whenFinished();
7357  }
7358  function getPretchedHtmlOr(destination, receive, ifNoPrefetchExists) {
7359    let uri = getUriStringFromUrlObject(destination);
7360    if (!prefetches[uri])
7361      return ifNoPrefetchExists();
7362    if (prefetches[uri].finished) {
7363      let html = prefetches[uri].html;
7364      let finalDestination = prefetches[uri].finalDestination;
7365      delete prefetches[uri];
7366      return receive(html, finalDestination);
7367    } else {
7368      prefetches[uri].whenFinished = () => {
7369        let html = prefetches[uri].html;
7370        let finalDestination = prefetches[uri].finalDestination;
7371        delete prefetches[uri];
7372        receive(html, finalDestination);
7373      };
7374    }
7375  }
7376
7377

7377// js/plugins/navigate/teleport.js
7378  function packUpPersistedTeleports(persistedEl) {
7379    module_default.mutateDom(() => {
7380      persistedEl.querySelectorAll("[data-teleport-template]").forEach((i) => i._x_teleport.remove());
7381    });
7382  }
7383  function removeAnyLeftOverStaleTeleportTargets(body) {
7384    module_default.mutateDom(() => {
7385      body.querySelectorAll("[data-teleport-target]").forEach((i) => i.remove());
7386    });
7387  }
7388  function unPackPersistedTeleports(persistedEl) {
7389    module_default.walk(persistedEl, (el, skip) => {
7390      if (!el._x_teleport)
7391        return;
7392      el._x_teleportPutBack();
7393      skip();
7394    });
7395  }
7396  function isTeleportTarget(el) {
7397    return el.hasAttribute("data-teleport-target");
7398  }
7399
7400

7400// js/plugins/navigate/scroll.js
7401  function storeScrollInformationInHtmlBeforeNavigatingAway() {
7402    document.body.setAttribute("data-scroll-x", document.body.scrollLeft);
7403    document.body.setAttribute("data-scroll-y", document.body.scrollTop);
7404    document.querySelectorAll(["[x-navigate\\:scroll]", "[wire\\:scroll]"]).forEach((el) => {
7405      el.setAttribute("data-scroll-x", el.scrollLeft);
7406      el.setAttribute("data-scroll-y", el.scrollTop);
7407    });
7408  }
7409  function restoreScrollPositionOrScrollToTop() {
7410    let scroll = (el) => {
7411      if (!el.hasAttribute("data-scroll-x")) {
7412        window.scrollTo({ top: 0, left: 0, behavior: "instant" });
7413      } else {
7414        el.scrollTo({
7415          top: Number(el.getAttribute("data-scroll-y")),
7416          left: Number(el.getAttribute("data-scroll-x")),
7417          behavior: "instant"
7418        });
7419        el.removeAttribute("data-scroll-x");
7420        el.removeAttribute("data-scroll-y");
7421      }
7422    };
7423    queueMicrotask(() => {
7424      scroll(document.body);
7425      document.querySelectorAll(["[x-navigate\\:scroll]", "[wire\\:scroll]"]).forEach(scroll);
7426    });
7427  }
7428
7429

7429// js/plugins/navigate/persist.js
7430  var els = {};
7431  function storePersistantElementsForLater(callback) {
7432    els = {};
7433    document.querySelectorAll("[x-persist]").forEach((i) => {
7434      els[i.getAttribute("x-persist")] = i;
7435      callback(i);
7436      module_default.mutateDom(() => {
7437        i.remove();
7438      });
7439    });
7440  }
7441  function putPersistantElementsBack(callback) {
7442    let usedPersists = [];
7443    document.querySelectorAll("[x-persist]").forEach((i) => {
7444      let old = els[i.getAttribute("x-persist")];
7445      if (!old)
7446        return;
7447      usedPersists.push(i.getAttribute("x-persist"));
7448      old._x_wasPersisted = true;
7449      callback(old, i);
7450      module_default.mutateDom(() => {
7451        i.replaceWith(old);
7452      });
7453    });
7454    Object.entries(els).forEach(([key, el]) => {
7455      if (usedPersists.includes(key))
7456        return;
7457      module_default.destroyTree(el);
7458    });
7459    els = {};
7460  }
7461  function isPersistedElement(el) {
7462    return el.hasAttribute("x-persist");
7463  }
7464
7465

7465// js/plugins/navigate/bar.js
7466  var import_nprogress = __toESM(require_nprogress());
7467  import_nprogress.default.configure({
7468    minimum: 0.1,
7469    trickleSpeed: 200,
7470    showSpinner: false,
7471    parent: "body"
7472  });
7473  injectStyles();
7474  var inProgress = false;
7475  function showAndStartProgressBar() {
7476    inProgress = true;
7477    setTimeout(() => {
7478      if (!inProgress)
7479        return;
7480      import_nprogress.default.start();
7481    }, 150);
7482  }
7483  function finishAndHideProgressBar() {
7484    inProgress = false;
7485    import_nprogress.default.done();
7486  }
7487  function removeAnyLeftOverStaleProgressBars() {
7488    import_nprogress.default.remove();
7489  }
7490  function injectStyles() {
7491    let style = document.createElement("style");
7492    style.innerHTML = `/* Make clicks pass-through */
7493
7494    #nprogress {
7495      pointer-events: none;
7496    }
7497
7498    #nprogress .bar {
7499      background: var(--livewire-progress-bar-color, #29d);
7500
7501      position: fixed;
7502      z-index: 1031;
7503      top: 0;
7504      left: 0;
7505
7506      width: 100%;
7507      height: 2px;
7508    }
7509
7510    /* Fancy blur effect */
7511    #nprogress .peg {
7512      display: block;
7513      position: absolute;
7514      right: 0px;
7515      width: 100px;
7516      height: 100%;
7517      box-shadow: 0 0 10px var(--livewire-progress-bar-color, #29d), 0 0 5px var(--livewire-progress-bar-color, #29d);
7518      opacity: 1.0;
7519
7520      -webkit-transform: rotate(3deg) translate(0px, -4px);
7521          -ms-transform: rotate(3deg) translate(0px, -4px);
7522              transform: rotate(3deg) translate(0px, -4px);
7523    }
7524
7525    /* Remove these to get rid of the spinner */
7526    #nprogress .spinner {
7527      display: block;
7528      position: fixed;
7529      z-index: 1031;
7530      top: 15px;
7531      right: 15px;
7532    }
7533
7534    #nprogress .spinner-icon {
7535      width: 18px;
7536      height: 18px;
7537      box-sizing: border-box;
7538
7539      border: solid 2px transparent;
7540      border-top-color: var(--livewire-progress-bar-color, #29d);
7541      border-left-color: var(--livewire-progress-bar-color, #29d);
7542      border-radius: 50%;
7543
7544      -webkit-animation: nprogress-spinner 400ms linear infinite;
7545              animation: nprogress-spinner 400ms linear infinite;
7546    }
7547
7548    .nprogress-custom-parent {
7549      overflow: hidden;
7550      position: relative;
7551    }
7552
7553    .nprogress-custom-parent #nprogress .spinner,
7554    .nprogress-custom-parent #nprogress .bar {
7555      position: absolute;
7556    }
7557
7558    @-webkit-keyframes nprogress-spinner {
7559      0%   { -webkit-transform: rotate(0deg); }
7560      100% { -webkit-transform: rotate(360deg); }
7561    }
7562    @keyframes nprogress-spinner {
7563      0%   { transform: rotate(0deg); }
7564      100% { transform: rotate(360deg); }
7565    }
7566    `;
7567    let nonce2 = getNonce();
7568    if (nonce2)
7569      style.nonce = nonce2;
7570    document.head.appendChild(style);
7571  }
7572
7573

7573// js/plugins/navigate/page.js
7574  var oldBodyScriptTagHashes = [];
7575  var attributesExemptFromScriptTagHashing = [
7576    "data-csrf",
7577    "aria-hidden"
7578  ];
7579  function swapCurrentPageWithNewHtml(html, andThen) {
7580    let newDocument = new DOMParser().parseFromString(html, "text/html");
7581    let newBody = document.adoptNode(newDocument.body);
7582    let newHead = document.adoptNode(newDocument.head);
7583    oldBodyScriptTagHashes = oldBodyScriptTagHashes.concat(Array.from(document.body.querySelectorAll("script")).map((i) => {
7584      return simpleHash(ignoreAttributes(i.outerHTML, attributesExemptFromScriptTagHashing));
7585    }));
7586    let afterRemoteScriptsHaveLoaded = () => {
7587    };
7588    mergeNewHead(newHead).finally(() => {
7589      afterRemoteScriptsHaveLoaded();
7590    });
7591    prepNewBodyScriptTagsToRun(newBody, oldBodyScriptTagHashes);
7592    let oldBody = document.body;
7593    document.body.replaceWith(newBody);
7594    Alpine.destroyTree(oldBody);
7595    andThen((i) => afterRemoteScriptsHaveLoaded = i);
7596  }
7597  function prepNewBodyScriptTagsToRun(newBody, oldBodyScriptTagHashes2) {
7598    newBody.querySelectorAll("script").forEach((i) => {
7599      if (i.hasAttribute("data-navigate-once")) {
7600        let hash = simpleHash(ignoreAttributes(i.outerHTML, attributesExemptFromScriptTagHashing));
7601        if (oldBodyScriptTagHashes2.includes(hash))
7602          return;
7603      }
7604      i.replaceWith(cloneScriptTag(i));
7605    });
7606  }
7607  function mergeNewHead(newHead) {

7608    let children = Array.from(document.head.children);
7609    let headChildrenHtmlLookup = children.map((i) => i.outerHTML);
7610    let garbageCollector = document.createDocumentFragment();
7611    let touchedHeadElements = [];
7612    let remoteScriptsPromises = [];
7613    for (let child of Array.from(newHead.children)) {
7614      if (isAsset(child)) {
7615        if (!headChildrenHtmlLookup.includes(child.outerHTML)) {
7616          if (isTracked(child)) {
7617            if (ifTheQueryStringChangedSinceLastRequest(child, children)) {
7618              setTimeout(() => window.location.reload());
7619            }
7620          }
7621          if (isScript(child)) {
7622            try {
7623              remoteScriptsPromises.push(injectScriptTagAndWaitForItToFullyLoad(cloneScriptTag(child)));
7624            } catch (error2) {
7625            }
7626          } else {
7627            document.head.appendChild(child);
7628          }
7629        } else {
7630          garbageCollector.appendChild(child);
7631        }
7632        touchedHeadElements.push(child);
7633      }
7634    }
7635    for (let child of Array.from(document.head.children)) {
7636      if (!isAsset(child))
7637        child.remove();
7638    }
7639    for (let child of Array.from(newHead.children)) {
7640      document.head.appendChild(child);
7641    }
7642    return Promise.all(remoteScriptsPromises);
7643  }
7644  async function injectScriptTagAndWaitForItToFullyLoad(script) {
7645    return new Promise((resolve, reject) => {
7646      if (script.src) {
7647        script.onload = () => resolve();
7648        script.onerror = () => reject();
7649      } else {
7650        resolve();
7651      }
7652      document.head.appendChild(script);
7653    });
7654  }
7655  function cloneScriptTag(el) {
7656    let script = document.createElement("script");
7657    script.textContent = el.textContent;
7658    script.async = el.async;
7659    for (let attr of el.attributes) {
7660      script.setAttribute(attr.name, attr.value);
7661    }
7662    return script;
7663  }
7664  function isTracked(el) {
7665    return el.hasAttribute("data-navigate-track");
7666  }
7667  function ifTheQueryStringChangedSinceLastRequest(el, currentHeadChildren) {
7668    let [uri, queryString] = extractUriAndQueryString(el);
7669    return currentHeadChildren.some((child) => {
7670      if (!isTracked(child))
7671        return false;
7672      let [currentUri, currentQueryString] = extractUriAndQueryString(child);
7673      if (currentUri === uri && queryString !== currentQueryString)
7674        return true;
7675    });
7676  }
7677  function extractUriAndQueryString(el) {
7678    let url = isScript(el) ? el.src : el.href;
7679    return url.split("?");
7680  }
7681  function isAsset(el) {
7682    return el.tagName.toLowerCase() === "link" && el.getAttribute("rel").toLowerCase() === "stylesheet" || el.tagName.toLowerCase() === "style" || el.tagName.toLowerCase() === "script";
7683  }
7684  function isScript(el) {
7685    return el.tagName.toLowerCase() === "script";
7686  }
7687  function simpleHash(str) {
7688    return str.split("").reduce((a, b) => {
7689      a = (a << 5) - a + b.charCodeAt(0);
7690      return a & a;
7691    }, 0);
7692  }
7693  function ignoreAttributes(subject, attributesToRemove) {
7694    let result = subject;
7695    attributesToRemove.forEach((attr) => {
7696      const regex = new RegExp(`${attr}="[^"]*"|${attr}='[^']*'`, "g");
7697      result = result.replace(regex, "");
7698    });
7699    result = result.replaceAll(" ", "");
7700    return result.trim();
7701  }
7702
7703

7703// js/plugins/navigate/index.js
7704  var enablePersist = true;
7705  var showProgressBar = true;
7706  var restoreScroll = true;
7707  var autofocus = false;
7708  function navigate_default(Alpine3) {
7709    Alpine3.navigate = (url) => {
7710      let destination = createUrlObjectFromString(url);
7711      let prevented = fireEventForOtherLibariesToHookInto("alpine:navigate", {
7712        url: destination,
7713        history: false,
7714        cached: false
7715      });
7716      if (prevented)
7717        return;
7718      navigateTo(destination);
7719    };
7720    Alpine3.navigate.disableProgressBar = () => {
7721      showProgressBar = false;
7722    };
7723    Alpine3.addInitSelector(() => `[${Alpine3.prefixed("navigate")}]`);
7724    Alpine3.directive("navigate", (el, { modifiers }) => {
7725      let shouldPrefetchOnHover = modifiers.includes("hover");
7726      shouldPrefetchOnHover && whenThisLinkIsHoveredFor(el, 60, () => {
7727        let destination = extractDestinationFromLink(el);
7728        prefetchHtml(destination, (html, finalDestination) => {
7729          storeThePrefetchedHtmlForWhenALinkIsClicked(html, destination, finalDestination);
7730        });
7731      });
7732      whenThisLinkIsPressed(el, (whenItIsReleased) => {
7733        let destination = extractDestinationFromLink(el);
7734        prefetchHtml(destination, (html, finalDestination) => {
7735          storeThePrefetchedHtmlForWhenALinkIsClicked(html, destination, finalDestination);
7736        });
7737        whenItIsReleased(() => {
7738          let prevented = fireEventForOtherLibariesToHookInto("alpine:navigate", {
7739            url: destination,
7740            history: false,
7741            cached: false
7742          });
7743          if (prevented)
7744            return;
7745          navigateTo(destination);
7746        });
7747      });
7748    });
7749    function navigateTo(destination, shouldPushToHistoryState = true) {
7750      showProgressBar && showAndStartProgressBar();
7751      fetchHtmlOrUsePrefetchedHtml(destination, (html, finalDestination) => {
7752        fireEventForOtherLibariesToHookInto("alpine:navigating");
7753        restoreScroll && storeScrollInformationInHtmlBeforeNavigatingAway();
7754        showProgressBar && finishAndHideProgressBar();
7755        cleanupAlpineElementsOnThePageThatArentInsideAPersistedElement();
7756        updateCurrentPageHtmlInHistoryStateForLaterBackButtonClicks();
7757        preventAlpineFromPickingUpDomChanges(Alpine3, (andAfterAllThis) => {
7758          enablePersist && storePersistantElementsForLater((persistedEl) => {
7759            packUpPersistedTeleports(persistedEl);
7760          });
7761          if (shouldPushToHistoryState) {
7762            updateUrlAndStoreLatestHtmlForFutureBackButtons(html, finalDestination);
7763          } else {
7764            replaceUrl(finalDestination, html);
7765          }
7766          swapCurrentPageWithNewHtml(html, (afterNewScriptsAreDoneLoading) => {
7767            removeAnyLeftOverStaleTeleportTargets(document.body);
7768            enablePersist && putPersistantElementsBack((persistedEl, newStub) => {
7769              unPackPersistedTeleports(persistedEl);
7770            });
7771            restoreScrollPositionOrScrollToTop();
7772            afterNewScriptsAreDoneLoading(() => {
7773              andAfterAllThis(() => {
7774                setTimeout(() => {
7775                  autofocus && autofocusElementsWithTheAutofocusAttribute();
7776                });
7777                nowInitializeAlpineOnTheNewPage(Alpine3);
7778                fireEventForOtherLibariesToHookInto("alpine:navigated");
7779              });
7780            });
7781          });
7782        });
7783      });
7784    }
7785    whenTheBackOrForwardButtonIsClicked((ifThePageBeingVisitedHasntBeenCached) => {
7786      ifThePageBeingVisitedHasntBeenCached((url) => {
7787        let destination = createUrlObjectFromString(url);
7788        let prevented = fireEventForOtherLibariesToHookInto("alpine:navigate", {
7789          url: destination,
7790          history: true,
7791          cached: false
7792        });
7793        if (prevented)
7794          return;
7795        let shouldPushToHistoryState = false;
7796        navigateTo(destination, shouldPushToHistoryState);
7797      });
7798    }, (html, url, currentPageUrl, currentPageKey) => {
7799      let destination = createUrlObjectFromString(url);
7800      let prevented = fireEventForOtherLibariesToHookInto("alpine:navigate", {
7801        url: destination,
7802        history: true,
7803        cached: true
7804      });
7805      if (prevented)
7806        return;
7807      storeScrollInformationInHtmlBeforeNavigatingAway();
7808      fireEventForOtherLibariesToHookInto("alpine:navigating");
7809      updateCurrentPageHtmlInSnapshotCacheForLaterBackButtonClicks(currentPageUrl, currentPageKey);
7810      preventAlpineFromPickingUpDomChanges(Alpine3, (andAfterAllThis) => {
7811        enablePersist && storePersistantElementsForLater((persistedEl) => {
7812          packUpPersistedTeleports(persistedEl);
7813        });
7814        swapCurrentPageWithNewHtml(html, () => {
7815          removeAnyLeftOverStaleProgressBars();
7816          removeAnyLeftOverStaleTeleportTargets(document.body);
7817          enablePersist && putPersistantElementsBack((persistedEl, newStub) => {
7818            unPackPersistedTeleports(persistedEl);
7819          });
7820          restoreScrollPositionOrScrollToTop();
7821          andAfterAllThis(() => {
7822            autofocus && autofocusElementsWithTheAutofocusAttribute();
7823            nowInitializeAlpineOnTheNewPage(Alpine3);
7824            fireEventForOtherLibariesToHookInto("alpine:navigated");
7825          });
7826        });
7827      });
7828    });
7829    setTimeout(() => {
7830      fireEventForOtherLibariesToHookInto("alpine:navigated");
7831    });
7832  }
7833  function fetchHtmlOrUsePrefetchedHtml(fromDestination, callback) {
7834    getPretchedHtmlOr(fromDestination, callback, () => {
7835      fetchHtml(fromDestination, callback);
7836    });
7837  }
7838  function preventAlpineFromPickingUpDomChanges(Alpine3, callback) {
7839    Alpine3.stopObservingMutations();
7840    callback((afterAllThis) => {
7841      Alpine3.startObservingMutations();
7842      queueMicrotask(() => {
7843        afterAllThis();
7844      });
7845    });
7846  }
7847  function fireEventForOtherLibariesToHookInto(name, detail) {
7848    let event = new CustomEvent(name, {
7849      cancelable: true,
7850      bubbles: true,
7851      detail
7852    });
7853    document.dispatchEvent(event);
7854    return event.defaultPrevented;
7855  }
7856  function nowInitializeAlpineOnTheNewPage(Alpine3) {
7857    Alpine3.initTree(document.body, void 0, (el, skip) => {
7858      if (el._x_wasPersisted)
7859        skip();
7860    });
7861  }
7862  function autofocusElementsWithTheAutofocusAttribute() {
7863    document.querySelector("[autofocus]") && document.querySelector("[autofocus]").focus();
7864  }
7865  function cleanupAlpineElementsOnThePageThatArentInsideAPersistedElement() {
7866    let walker = function(root, callback) {
7867      Alpine.walk(root, (el, skip) => {
7868        if (isPersistedElement(el))
7869          skip();
7870        if (isTeleportTarget(el))
7871          skip();
7872        else
7873          callback(el, skip);
7874      });
7875    };
7876    Alpine.destroyTree(document.body, walker);
7877  }
7878
7879

7879// js/plugins/history/index.js
7880  function history2(Alpine3) {
7881    Alpine3.magic("queryString", (el, { interceptor: interceptor2 }) => {
7882      let alias;
7883      let alwaysShow = false;
7884      let usePush = false;
7885      return interceptor2((initialSeedValue, getter, setter, path, key) => {
7886        let queryKey = alias || path;
7887        let { initial, replace: replace2, push: push2, pop } = track2(queryKey, initialSeedValue, alwaysShow);
7888        setter(initial);
7889        if (!usePush) {
7890          Alpine3.effect(() => replace2(getter()));
7891        } else {
7892          Alpine3.effect(() => push2(getter()));
7893          pop(async (newValue) => {
7894            setter(newValue);
7895            let tillTheEndOfTheMicrotaskQueue = () => Promise.resolve();
7896            await tillTheEndOfTheMicrotaskQueue();
7897          });
7898        }
7899        return initial;
7900      }, (func) => {
7901        func.alwaysShow = () => {
7902          alwaysShow = true;
7903          return func;
7904        };
7905        func.usePush = () => {
7906          usePush = true;
7907          return func;
7908        };
7909        func.as = (key) => {
7910          alias = key;
7911          return func;
7912        };
7913      });
7914    });
7915    Alpine3.history = { track: track2 };
7916  }
7917  function track2(name, initialSeedValue, alwaysShow = false) {
7918    let { has: has2, get: get3, set: set3, remove } = queryStringUtils();
7919    let url = new URL(window.location.href);
7920    let isInitiallyPresentInUrl = has2(url, name);
7921    let initialValue = isInitiallyPresentInUrl ? get3(url, name) : initialSeedValue;
7922    let initialValueMemo = JSON.stringify(initialValue);
7923    let hasReturnedToInitialValue = (newValue) => JSON.stringify(newValue) === initialValueMemo;
7924    if (alwaysShow)
7925      url = set3(url, name, initialValue);
7926    replace(url, name, { value: initialValue });
7927    let lock = false;
7928    let update = (strategy, newValue) => {
7929      if (lock)
7930        return;
7931      let url2 = new URL(window.location.href);
7932      if (!alwaysShow && !isInitiallyPresentInUrl && hasReturnedToInitialValue(newValue)) {
7933        url2 = remove(url2, name);
7934      } else if (newValue === void 0) {
7935        url2 = remove(url2, name);
7936      } else {
7937        url2 = set3(url2, name, newValue);
7938      }
7939      strategy(url2, name, { value: newValue });
7940    };
7941    return {
7942      initial: initialValue,
7943      replace(newValue) {
7944        update(replace, newValue);
7945      },
7946      push(newValue) {
7947        update(push, newValue);
7948      },
7949      pop(receiver) {
7950        let handler4 = (e) => {
7951          if (!e.state || !e.state.alpine)
7952            return;
7953          Object.entries(e.state.alpine).forEach(([iName, { value: newValue }]) => {
7954            if (iName !== name)
7955              return;
7956            lock = true;
7957            let result = receiver(newValue);
7958            if (result instanceof Promise) {
7959              result.finally(() => lock = false);
7960            } else {
7961              lock = false;
7962            }
7963          });
7964        };
7965        window.addEventListener("popstate", handler4);
7966        return () => window.removeEventListener("popstate", handler4);
7967      }
7968    };
7969  }
7970  function replace(url, key, object) {
7971    let state = window.history.state || {};
7972    if (!state.alpine)
7973      state.alpine = {};
7974    state.alpine[key] = unwrap(object);
7975    window.history.replaceState(state, "", url.toString());
7976  }
7977  function push(url, key, object) {
7978    let state = window.history.state || {};
7979    if (!state.alpine)
7980      state.alpine = {};
7981    state = { alpine: { ...state.alpine, ...{ [key]: unwrap(object) } } };
7982    window.history.pushState(state, "", url.toString());
7983  }
7984  function unwrap(object) {
7985    if (object === void 0)
7986      return void 0;
7987    return JSON.parse(JSON.stringify(object));
7988  }
7989  function queryStringUtils() {
7990    return {
7991      has(url, key) {
7992        let search = url.search;
7993        if (!search)
7994          return false;
7995        let data2 = fromQueryString(search);
7996        return Object.keys(data2).includes(key);
7997      },
7998      get(url, key) {
7999        let search = url.search;
8000        if (!search)
8001          return false;
8002        let data2 = fromQueryString(search);
8003        return data2[key];
8004      },
8005      set(url, key, value) {
8006        let data2 = fromQueryString(url.search);
8007        data2[key] = stripNulls(unwrap(value));
8008        url.search = toQueryString(data2);
8009        return url;
8010      },
8011      remove(url, key) {
8012        let data2 = fromQueryString(url.search);
8013        delete data2[key];
8014        url.search = toQueryString(data2);
8015        return url;
8016      }
8017    };
8018  }
8019  function stripNulls(value) {
8020    if (!isObjecty(value))
8021      return value;
8022    for (let key in value) {
8023      if (value[key] === null)
8024        delete value[key];
8025      else
8026        value[key] = stripNulls(value[key]);
8027    }
8028    return value;
8029  }
8030  function toQueryString(data2) {
8031    let isObjecty2 = (subject) => typeof subject === "object" && subject !== null;
8032    let buildQueryStringEntries = (data3, entries2 = {}, baseKey = "") => {
8033      Object.entries(data3).forEach(([iKey, iValue]) => {
8034        let key = baseKey === "" ? iKey : `${baseKey}[${iKey}]`;
8035        if (iValue === null) {

8036          entries2[key] = "";
8037        } else if (!isObjecty2(iValue)) {
8038          entries2[key] = encodeURIComponent(iValue).replaceAll("%20", "+").replaceAll("%2C", ",");
8039        } else {
8040          entries2 = { ...entries2, ...buildQueryStringEntries(iValue, entries2, key) };
8041        }
8042      });
8043      return entries2;
8044    };
8045    let entries = buildQueryStringEntries(data2);
8046    return Object.entries(entries).map(([key, value]) => `${key}=${value}`).join("&");
8047  }
8048  function fromQueryString(search) {
8049    search = search.replace("?", "");
8050    if (search === "")
8051      return {};
8052    let insertDotNotatedValueIntoData = (key, value, data3) => {
8053      let [first2, second, ...rest] = key.split(".");
8054      if (!second)
8055        return data3[key] = value;
8056      if (data3[first2] === void 0) {
8057        data3[first2] = isNaN(second) ? {} : [];
8058      }
8059      insertDotNotatedValueIntoData([second, ...rest].join("."), value, data3[first2]);
8060    };
8061    let entries = search.split("&").map((i) => i.split("="));
8062    let data2 = /* @__PURE__ */ Object.create(null);
8063    entries.forEach(([key, value]) => {
8064      if (typeof value == "undefined")
8065        return;
8066      value = decodeURIComponent(value.replaceAll("+", "%20"));
8067      if (!key.includes("[")) {
8068        data2[key] = value;
8069      } else {
8070        let dotNotatedKey = key.replaceAll("[", ".").replaceAll("]", "");
8071        insertDotNotatedValueIntoData(dotNotatedKey, value, data2);
8072      }
8073    });
8074    return data2;
8075  }
8076
8077

8077// ../alpine/packages/morph/dist/module.esm.js
8078  function morph(from, toHtml, options) {
8079    monkeyPatchDomSetAttributeToAllowAtSymbols();
8080    let fromEl;
8081    let toEl;
8082    let key, lookahead, updating, updated, removing, removed, adding, added;
8083    function assignOptions(options2 = {}) {
8084      let defaultGetKey = (el) => el.getAttribute("key");
8085      let noop = () => {
8086      };
8087      updating = options2.updating || noop;
8088      updated = options2.updated || noop;
8089      removing = options2.removing || noop;
8090      removed = options2.removed || noop;
8091      adding = options2.adding || noop;
8092      added = options2.added || noop;
8093      key = options2.key || defaultGetKey;
8094      lookahead = options2.lookahead || false;
8095    }
8096    function patch(from2, to) {
8097      if (differentElementNamesTypesOrKeys(from2, to)) {
8098        return swapElements(from2, to);
8099      }
8100      let updateChildrenOnly = false;
8101      if (shouldSkip(updating, from2, to, () => updateChildrenOnly = true))
8102        return;
8103      if (from2.nodeType === 1 && window.Alpine) {
8104        window.Alpine.cloneNode(from2, to);
8105        if (from2._x_teleport && to._x_teleport) {
8106          patch(from2._x_teleport, to._x_teleport);
8107        }
8108      }
8109      if (textOrComment(to)) {
8110        patchNodeValue(from2, to);
8111        updated(from2, to);
8112        return;
8113      }
8114      if (!updateChildrenOnly) {
8115        patchAttributes(from2, to);
8116      }
8117      updated(from2, to);
8118      patchChildren(from2, to);
8119    }
8120    function differentElementNamesTypesOrKeys(from2, to) {
8121      return from2.nodeType != to.nodeType || from2.nodeName != to.nodeName || getKey(from2) != getKey(to);
8122    }
8123    function swapElements(from2, to) {
8124      if (shouldSkip(removing, from2))
8125        return;
8126      let toCloned = to.cloneNode(true);
8127      if (shouldSkip(adding, toCloned))
8128        return;
8129      from2.replaceWith(toCloned);
8130      removed(from2);
8131      added(toCloned);
8132    }
8133    function patchNodeValue(from2, to) {
8134      let value = to.nodeValue;
8135      if (from2.nodeValue !== value) {
8136        from2.nodeValue = value;
8137      }
8138    }
8139    function patchAttributes(from2, to) {
8140      if (from2._x_transitioning)
8141        return;
8142      if (from2._x_isShown && !to._x_isShown) {
8143        return;
8144      }
8145      if (!from2._x_isShown && to._x_isShown) {
8146        return;
8147      }
8148      let domAttributes = Array.from(from2.attributes);
8149      let toAttributes = Array.from(to.attributes);
8150      for (let i = domAttributes.length - 1; i >= 0; i--) {
8151        let name = domAttributes[i].name;
8152        if (!to.hasAttribute(name)) {
8153          from2.removeAttribute(name);
8154        }
8155      }
8156      for (let i = toAttributes.length - 1; i >= 0; i--) {
8157        let name = toAttributes[i].name;
8158        let value = toAttributes[i].value;
8159        if (from2.getAttribute(name) !== value) {
8160          from2.setAttribute(name, value);
8161        }
8162      }
8163    }
8164    function patchChildren(from2, to) {
8165      let fromKeys = keyToMap(from2.children);
8166      let fromKeyHoldovers = {};
8167      let currentTo = getFirstNode(to);
8168      let currentFrom = getFirstNode(from2);
8169      while (currentTo) {
8170        seedingMatchingId(currentTo, currentFrom);
8171        let toKey = getKey(currentTo);
8172        let fromKey = getKey(currentFrom);
8173        if (!currentFrom) {
8174          if (toKey && fromKeyHoldovers[toKey]) {
8175            let holdover = fromKeyHoldovers[toKey];
8176            from2.appendChild(holdover);
8177            currentFrom = holdover;
8178          } else {
8179            if (!shouldSkip(adding, currentTo)) {
8180              let clone2 = currentTo.cloneNode(true);
8181              from2.appendChild(clone2);
8182              added(clone2);
8183            }
8184            currentTo = getNextSibling(to, currentTo);
8185            continue;
8186          }
8187        }
8188        let isIf = (node) => node && node.nodeType === 8 && node.textContent === "[if BLOCK]><![endif]";
8189        let isEnd = (node) => node && node.nodeType === 8 && node.textContent === "[if ENDBLOCK]><![endif]";
8190        if (isIf(currentTo) && isIf(currentFrom)) {
8191          let nestedIfCount = 0;
8192          let fromBlockStart = currentFrom;
8193          while (currentFrom) {
8194            let next = getNextSibling(from2, currentFrom);
8195            if (isIf(next)) {
8196              nestedIfCount++;
8197            } else if (isEnd(next) && nestedIfCount > 0) {
8198              nestedIfCount--;
8199            } else if (isEnd(next) && nestedIfCount === 0) {
8200              currentFrom = next;
8201              break;
8202            }
8203            currentFrom = next;
8204          }
8205          let fromBlockEnd = currentFrom;
8206          nestedIfCount = 0;
8207          let toBlockStart = currentTo;
8208          while (currentTo) {
8209            let next = getNextSibling(to, currentTo);
8210            if (isIf(next)) {
8211              nestedIfCount++;
8212            } else if (isEnd(next) && nestedIfCount > 0) {
8213              nestedIfCount--;
8214            } else if (isEnd(next) && nestedIfCount === 0) {
8215              currentTo = next;
8216              break;
8217            }
8218            currentTo = next;
8219          }
8220          let toBlockEnd = currentTo;
8221          let fromBlock = new Block(fromBlockStart, fromBlockEnd);
8222          let toBlock = new Block(toBlockStart, toBlockEnd);
8223          patchChildren(fromBlock, toBlock);
8224          continue;
8225        }
8226        if (currentFrom.nodeType === 1 && lookahead && !currentFrom.isEqualNode(currentTo)) {
8227          let nextToElementSibling = getNextSibling(to, currentTo);
8228          let found = false;

8229          while (!found && nextToElementSibling) {
8230            if (nextToElementSibling.nodeType === 1 && currentFrom.isEqualNode(nextToElementSibling)) {
8231              found = true;
8232              currentFrom = addNodeBefore(from2, currentTo, currentFrom);
8233              fromKey = getKey(currentFrom);
8234            }
8235            nextToElementSibling = getNextSibling(to, nextToElementSibling);
8236          }
8237        }
8238        if (toKey !== fromKey) {
8239          if (!toKey && fromKey) {
8240            fromKeyHoldovers[fromKey] = currentFrom;
8241            currentFrom = addNodeBefore(from2, currentTo, currentFrom);
8242            fromKeyHoldovers[fromKey].remove();
8243            currentFrom = getNextSibling(from2, currentFrom);
8244            currentTo = getNextSibling(to, currentTo);
8245            continue;
8246          }
8247          if (toKey && !fromKey) {
8248            if (fromKeys[toKey]) {
8249              currentFrom.replaceWith(fromKeys[toKey]);
8250              currentFrom = fromKeys[toKey];
8251            }
8252          }
8253          if (toKey && fromKey) {
8254            let fromKeyNode = fromKeys[toKey];
8255            if (fromKeyNode) {
8256              fromKeyHoldovers[fromKey] = currentFrom;
8257              currentFrom.replaceWith(fromKeyNode);
8258              currentFrom = fromKeyNode;
8259            } else {
8260              fromKeyHoldovers[fromKey] = currentFrom;
8261              currentFrom = addNodeBefore(from2, currentTo, currentFrom);
8262              fromKeyHoldovers[fromKey].remove();
8263              currentFrom = getNextSibling(from2, currentFrom);
8264              currentTo = getNextSibling(to, currentTo);
8265              continue;
8266            }
8267          }
8268        }
8269        let currentFromNext = currentFrom && getNextSibling(from2, currentFrom);
8270        patch(currentFrom, currentTo);
8271        currentTo = currentTo && getNextSibling(to, currentTo);
8272        currentFrom = currentFromNext;
8273      }
8274      let removals = [];
8275      while (currentFrom) {
8276        if (!shouldSkip(removing, currentFrom))
8277          removals.push(currentFrom);
8278        currentFrom = getNextSibling(from2, currentFrom);
8279      }
8280      while (removals.length) {
8281        let domForRemoval = removals.shift();
8282        domForRemoval.remove();
8283        removed(domForRemoval);
8284      }
8285    }
8286    function getKey(el) {
8287      return el && el.nodeType === 1 && key(el);
8288    }
8289    function keyToMap(els2) {
8290      let map = {};
8291      for (let el of els2) {
8292        let theKey = getKey(el);
8293        if (theKey) {
8294          map[theKey] = el;
8295        }
8296      }
8297      return map;
8298    }
8299    function addNodeBefore(parent, node, beforeMe) {
8300      if (!shouldSkip(adding, node)) {
8301        let clone2 = node.cloneNode(true);
8302        parent.insertBefore(clone2, beforeMe);
8303        added(clone2);
8304        return clone2;
8305      }
8306      return node;
8307    }
8308    assignOptions(options);
8309    fromEl = from;
8310    toEl = typeof toHtml === "string" ? createElement(toHtml) : toHtml;
8311    if (window.Alpine && window.Alpine.closestDataStack && !from._x_dataStack) {
8312      toEl._x_dataStack = window.Alpine.closestDataStack(from);
8313      toEl._x_dataStack && window.Alpine.cloneNode(from, toEl);
8314    }
8315    patch(from, toEl);
8316    fromEl = void 0;
8317    toEl = void 0;
8318    return from;
8319  }
8320  morph.step = () => {
8321  };
8322  morph.log = () => {
8323  };
8324  function shouldSkip(hook, ...args) {
8325    let skip = false;
8326    hook(...args, () => skip = true);
8327    return skip;
8328  }
8329  var patched = false;
8330  function createElement(html) {
8331    const template = document.createElement("template");
8332    template.innerHTML = html;
8333    return template.content.firstElementChild;
8334  }
8335  function textOrComment(el) {
8336    return el.nodeType === 3 || el.nodeType === 8;
8337  }
8338  var Block = class {
8339    constructor(start3, end) {
8340      this.startComment = start3;
8341      this.endComment = end;
8342    }
8343    get children() {
8344      let children = [];
8345      let currentNode = this.startComment.nextSibling;
8346      while (currentNode && currentNode !== this.endComment) {
8347        children.push(currentNode);
8348        currentNode = currentNode.nextSibling;
8349      }
8350      return children;
8351    }
8352    appendChild(child) {
8353      this.endComment.before(child);
8354    }
8355    get firstChild() {

8356      let first2 = this.startComment.nextSibling;
8357      if (first2 === this.endComment)
8358        return;
8359      return first2;
8360    }
8361    nextNode(reference) {
8362      let next = reference.nextSibling;
8363      if (next === this.endComment)
8364        return;
8365      return next;
8366    }
8367    insertBefore(newNode, reference) {
8368      reference.before(newNode);
8369      return newNode;
8370    }
8371  };
8372  function getFirstNode(parent) {
8373    return parent.firstChild;
8374  }
8375  function getNextSibling(parent, reference) {
8376    let next;
8377    if (parent instanceof Block) {
8378      next = parent.nextNode(reference);
8379    } else {
8380      next = reference.nextSibling;
8381    }
8382    return next;
8383  }
8384  function monkeyPatchDomSetAttributeToAllowAtSymbols() {
8385    if (patched)
8386      return;
8387    patched = true;
8388    let original = Element.prototype.setAttribute;
8389    let hostDiv = document.createElement("div");
8390    Element.prototype.setAttribute = function newSetAttribute(name, value) {
8391      if (!name.includes("@")) {
8392        return original.call(this, name, value);
8393      }
8394      hostDiv.innerHTML = `<span ${name}="${value}"></span>`;
8395      let attr = hostDiv.firstElementChild.getAttributeNode(name);
8396      hostDiv.firstElementChild.removeAttributeNode(attr);
8397      this.setAttributeNode(attr);
8398    };
8399  }
8400  function seedingMatchingId(to, from) {
8401    let fromId = from && from._x_bindings && from._x_bindings.id;
8402    if (!fromId)
8403      return;
8404    to.setAttribute("id", fromId);
8405    to.id = fromId;
8406  }
8407  function src_default7(Alpine3) {
8408    Alpine3.morph = morph;
8409  }
8410  var module_default7 = src_default7;
8411
8412

8412// ../alpine/packages/mask/dist/module.esm.js
8413  function src_default8(Alpine3) {
8414    Alpine3.directive("mask", (el, { value, expression }, { effect: effect3, evaluateLater: evaluateLater2, cleanup: cleanup2 }) => {
8415      let templateFn = () => expression;
8416      let lastInputValue = "";
8417      queueMicrotask(() => {
8418        if (["function", "dynamic"].includes(value)) {
8419          let evaluator = evaluateLater2(expression);
8420          effect3(() => {
8421            templateFn = (input) => {
8422              let result;
8423              Alpine3.dontAutoEvaluateFunctions(() => {
8424                evaluator((value2) => {
8425                  result = typeof value2 === "function" ? value2(input) : value2;
8426                }, { scope: {
8427                  "$input": input,
8428                  "$money": formatMoney.bind({ el })
8429                } });
8430              });
8431              return result;
8432            };
8433            processInputValue(el, false);
8434          });
8435        } else {
8436          processInputValue(el, false);
8437        }
8438        if (el._x_model)
8439          el._x_model.set(el.value);
8440      });
8441      const controller = new AbortController();
8442      cleanup2(() => {
8443        controller.abort();
8444      });
8445      el.addEventListener("input", () => processInputValue(el), {
8446        signal: controller.signal,
8447        capture: true
8448      });
8449      el.addEventListener("blur", () => processInputValue(el, false), { signal: controller.signal });
8450      function processInputValue(el2, shouldRestoreCursor = true) {
8451        let input = el2.value;
8452        let template = templateFn(input);
8453        if (!template || template === "false")
8454          return false;
8455        if (lastInputValue.length - el2.value.length === 1) {
8456          return lastInputValue = el2.value;
8457        }
8458        let setInput = () => {
8459          lastInputValue = el2.value = formatInput(input, template);
8460        };
8461        if (shouldRestoreCursor) {
8462          restoreCursorPosition(el2, template, () => {
8463            setInput();
8464          });
8465        } else {
8466          setInput();
8467        }
8468      }
8469      function formatInput(input, template) {
8470        if (input === "")
8471          return "";
8472        let strippedDownInput = stripDown(template, input);
8473        let rebuiltInput = buildUp(template, strippedDownInput);
8474        return rebuiltInput;
8475      }
8476    }).before("model");
8477  }
8478  function restoreCursorPosition(el, template, callback) {

8479    let cursorPosition = el.selectionStart;
8480    let unformattedValue = el.value;
8481    callback();
8482    let beforeLeftOfCursorBeforeFormatting = unformattedValue.slice(0, cursorPosition);
8483    let newPosition = buildUp(template, stripDown(template, beforeLeftOfCursorBeforeFormatting)).length;
8484    el.setSelectionRange(newPosition, newPosition);
8485  }
8486  function stripDown(template, input) {
8487    let inputToBeStripped = input;
8488    let output = "";
8489    let regexes = {
8490      "9": /[0-9]/,
8491      "a": /[a-zA-Z]/,
8492      "*": /[a-zA-Z0-9]/
8493    };
8494    let wildcardTemplate = "";
8495    for (let i = 0; i < template.length; i++) {
8496      if (["9", "a", "*"].includes(template[i])) {
8497        wildcardTemplate += template[i];
8498        continue;
8499      }
8500      for (let j = 0; j < inputToBeStripped.length; j++) {
8501        if (inputToBeStripped[j] === template[i]) {
8502          inputToBeStripped = inputToBeStripped.slice(0, j) + inputToBeStripped.slice(j + 1);
8503          break;
8504        }
8505      }
8506    }
8507    for (let i = 0; i < wildcardTemplate.length; i++) {
8508      let found = false;
8509      for (let j = 0; j < inputToBeStripped.length; j++) {
8510        if (regexes[wildcardTemplate[i]].test(inputToBeStripped[j])) {
8511          output += inputToBeStripped[j];
8512          inputToBeStripped = inputToBeStripped.slice(0, j) + inputToBeStripped.slice(j + 1);
8513          found = true;
8514          break;
8515        }
8516      }
8517      if (!found)
8518        break;
8519    }
8520    return output;
8521  }
8522  function buildUp(template, input) {
8523    let clean = Array.from(input);
8524    let output = "";
8525    for (let i = 0; i < template.length; i++) {
8526      if (!["9", "a", "*"].includes(template[i])) {
8527        output += template[i];
8528        continue;
8529      }
8530      if (clean.length === 0)
8531        break;
8532      output += clean.shift();
8533    }
8534    return output;
8535  }
8536  function formatMoney(input, delimiter = ".", thousands, precision = 2) {
8537    if (input === "-")
8538      return "-";
8539    if (/^\D+$/.test(input))
8540      return "9";
8541    if (thousands === null || thousands === void 0) {
8542      thousands = delimiter === "," ? "." : ",";
8543    }
8544    let addThousands = (input2, thousands2) => {
8545      let output = "";
8546      let counter = 0;
8547      for (let i = input2.length - 1; i >= 0; i--) {
8548        if (input2[i] === thousands2)
8549          continue;
8550        if (counter === 3) {
8551          output = input2[i] + thousands2 + output;
8552          counter = 0;
8553        } else {
8554          output = input2[i] + output;
8555        }
8556        counter++;
8557      }
8558      return output;
8559    };
8560    let minus = input.startsWith("-") ? "-" : "";
8561    let strippedInput = input.replaceAll(new RegExp(`[^0-9\\${delimiter}]`, "g"), "");
8562    let template = Array.from({ length: strippedInput.split(delimiter)[0].length }).fill("9").join("");
8563    template = `${minus}${addThousands(template, thousands)}`;
8564    if (precision > 0 && input.includes(delimiter))
8565      template += `${delimiter}` + "9".repeat(precision);
8566    queueMicrotask(() => {
8567      if (this.el.value.endsWith(delimiter))
8568        return;
8569      if (this.el.value[this.el.selectionStart - 1] === delimiter) {
8570        this.el.setSelectionRange(this.el.selectionStart - 1, this.el.selectionStart - 1);
8571      }
8572    });
8573    return template;
8574  }
8575  var module_default8 = src_default8;
8576
8577

8577// js/lifecycle.js
8578  function start2() {
8579    setTimeout(() => ensureLivewireScriptIsntMisplaced());
8580    dispatch(document, "livewire:init");
8581    dispatch(document, "livewire:initializing");
8582    module_default.plugin(module_default7);
8583    module_default.plugin(history2);
8584    module_default.plugin(module_default5);
8585    module_default.plugin(module_default2);
8586    module_default.plugin(module_default6);
8587    module_default.plugin(module_default3);
8588    module_default.plugin(module_default4);
8589    module_default.plugin(navigate_default);
8590    module_default.plugin(module_default8);
8591    module_default.addRootSelector(() => "[wire\\:id]");
8592    module_default.onAttributesAdded((el, attributes) => {
8593      if (!Array.from(attributes).some((attribute) => matchesForLivewireDirective(attribute.name)))
8594        return;
8595      let component = closestComponent(el, false);
8596      if (!component)
8597        return;
8598      attributes.forEach((attribute) => {
8599        if (!matchesForLivewireDirective(attribute.name))
8600          return;
8601        let directive3 = extractDirective(el, attribute.name);
8602        trigger2("directive.init", { el, component, directive: directive3, cleanup: (callback) => {
8603          module_default.onAttributeRemoved(el, directive3.raw, callback);
8604        } });
8605      });
8606    });
8607    module_default.interceptInit(module_default.skipDuringClone((el) => {
8608      if (!Array.from(el.attributes).some((attribute) => matchesForLivewireDirective(attribute.name)))
8609        return;
8610      if (el.hasAttribute("wire:id")) {
8611        let component2 = initComponent(el);
8612        module_default.onAttributeRemoved(el, "wire:id", () => {
8613          destroyComponent(component2.id);
8614        });
8615      }
8616      let component = closestComponent(el, false);
8617      if (component) {
8618        trigger2("element.init", { el, component });
8619        let directives2 = Array.from(el.getAttributeNames()).filter((name) => matchesForLivewireDirective(name)).map((name) => extractDirective(el, name));
8620        directives2.forEach((directive3) => {
8621          trigger2("directive.init", { el, component, directive: directive3, cleanup: (callback) => {
8622            module_default.onAttributeRemoved(el, directive3.raw, callback);
8623          } });
8624        });
8625      }
8626    }));
8627    module_default.start();
8628    setTimeout(() => window.Livewire.initialRenderIsFinished = true);
8629    dispatch(document, "livewire:initialized");
8630  }
8631  function ensureLivewireScriptIsntMisplaced() {
8632    let el = document.querySelector("script[data-update-uri][data-csrf]");
8633    if (!el)
8634      return;
8635    let livewireEl = el.closest("[wire\\:id]");
8636    if (livewireEl) {
8637      console.warn("Livewire: missing closing tags found. Ensure your template elements contain matching closing tags.", livewireEl);
8638    }
8639  }
8640
8641

8641// js/features/supportListeners.js
8642  on2("effect", ({ component, effects }) => {
8643    registerListeners(component, effects.listeners || []);
8644  });
8645  function registerListeners(component, listeners2) {
8646    listeners2.forEach((name) => {
8647      let handler4 = (e) => {
8648        if (e.__livewire)
8649          e.__livewire.receivedBy.push(component);
8650        component.$wire.call("__dispatch", name, e.detail || {});
8651      };
8652      window.addEventListener(name, handler4);
8653      component.addCleanup(() => window.removeEventListener(name, handler4));
8654      component.el.addEventListener(name, (e) => {
8655        if (!e.__livewire)
8656          return;
8657        if (e.bubbles)
8658          return;
8659        if (e.__livewire)
8660          e.__livewire.receivedBy.push(component.id);
8661        component.$wire.call("__dispatch", name, e.detail || {});
8662      });
8663    });
8664  }
8665
8666

8666// js/features/supportScriptsAndAssets.js
8667  var executedScripts = /* @__PURE__ */ new WeakMap();
8668  var executedAssets = /* @__PURE__ */ new Set();
8669  on2("payload.intercept", async ({ assets }) => {
8670    if (!assets)
8671      return;
8672    for (let [key, asset] of Object.entries(assets)) {
8673      await onlyIfAssetsHaventBeenLoadedAlreadyOnThisPage(key, async () => {
8674        await addAssetsToHeadTagOfPage(asset);
8675      });
8676    }
8677  });
8678  on2("component.init", ({ component }) => {
8679    let assets = component.snapshot.memo.assets;
8680    if (assets) {
8681      assets.forEach((key) => {
8682        if (executedAssets.has(key))
8683          return;
8684        executedAssets.add(key);
8685      });
8686    }
8687  });
8688  on2("effect", ({ component, effects }) => {
8689    let scripts = effects.scripts;
8690    if (scripts) {
8691      Object.entries(scripts).forEach(([key, content]) => {
8692        onlyIfScriptHasntBeenRunAlreadyForThisComponent(component, key, () => {
8693          let scriptContent = extractScriptTagContent(content);
8694          module_default.dontAutoEvaluateFunctions(() => {
8695            module_default.evaluate(component.el, scriptContent, { "$wire": component.$wire });
8696          });
8697        });
8698      });
8699    }
8700  });
8701  function onlyIfScriptHasntBeenRunAlreadyForThisComponent(component, key, callback) {
8702    if (executedScripts.has(component)) {
8703      let alreadyRunKeys2 = executedScripts.get(component);
8704      if (alreadyRunKeys2.includes(key))
8705        return;
8706    }
8707    callback();
8708    if (!executedScripts.has(component))
8709      executedScripts.set(component, []);
8710    let alreadyRunKeys = executedScripts.get(component);
8711    alreadyRunKeys.push(key);
8712    executedScripts.set(component, alreadyRunKeys);
8713  }
8714  function extractScriptTagContent(rawHtml) {
8715    let scriptRegex = /<script\b[^>]*>([\s\S]*?)<\/script>/gm;
8716    let matches2 = scriptRegex.exec(rawHtml);
8717    let innards = matches2 && matches2[1] ? matches2[1].trim() : "";
8718    return innards;
8719  }
8720  async function onlyIfAssetsHaventBeenLoadedAlreadyOnThisPage(key, callback) {
8721    if (executedAssets.has(key))
8722      return;
8723    await callback();
8724    executedAssets.add(key);
8725  }
8726  async function addAssetsToHeadTagOfPage(rawHtml) {
8727    let newDocument = new DOMParser().parseFromString(rawHtml, "text/html");
8728    let newHead = document.adoptNode(newDocument.head);
8729    for (let child of newHead.children) {
8730      try {
8731        await runAssetSynchronously(child);
8732      } catch (error2) {
8733      }
8734    }
8735  }
8736  async function runAssetSynchronously(child) {
8737    return new Promise((resolve, reject) => {
8738      if (isScript2(child)) {
8739        let script = cloneScriptTag2(child);
8740        if (script.src) {
8741          script.onload = () => resolve();
8742          script.onerror = () => reject();
8743        } else {
8744          resolve();
8745        }
8746        document.head.appendChild(script);
8747      } else {
8748        document.head.appendChild(child);
8749        resolve();
8750      }
8751    });
8752  }
8753  function isScript2(el) {
8754    return el.tagName.toLowerCase() === "script";
8755  }
8756  function cloneScriptTag2(el) {
8757    let script = document.createElement("script");
8758    script.textContent = el.textContent;
8759    script.async = el.async;
8760    for (let attr of el.attributes) {
8761      script.setAttribute(attr.name, attr.value);
8762    }
8763    return script;
8764  }
8765
8766

8766// js/features/supportJsEvaluation.js
8767  on2("effect", ({ component, effects }) => {
8768    let js = effects.js;
8769    let xjs = effects.xjs;
8770    if (js) {
8771      Object.entries(js).forEach(([method, body]) => {
8772        overrideMethod(component, method, () => {
8773          module_default.evaluate(component.el, body);
8774        });
8775      });
8776    }
8777    if (xjs) {
8778      xjs.forEach((expression) => {
8779        module_default.evaluate(component.el, expression);
8780      });
8781    }
8782  });
8783
8784

8784// js/morph.js
8785  function morph2(component, el, html) {
8786    let wrapperTag = el.parentElement ? el.parentElement.tagName.toLowerCase() : "div";
8787    let wrapper = document.createElement(wrapperTag);
8788    wrapper.innerHTML = html;
8789    let parentComponent;
8790    try {
8791      parentComponent = closestComponent(el.parentElement);
8792    } catch (e) {
8793    }
8794    parentComponent && (wrapper.__livewire = parentComponent);
8795    let to = wrapper.firstElementChild;
8796    to.__livewire = component;
8797    trigger2("morph", { el, toEl: to, component });
8798    module_default.morph(el, to, {
8799      updating: (el2, toEl, childrenOnly, skip) => {
8800        if (isntElement(el2))
8801          return;
8802        trigger2("morph.updating", { el: el2, toEl, component, skip, childrenOnly });
8803        if (el2.__livewire_replace === true)
8804          el2.innerHTML = toEl.innerHTML;
8805        if (el2.__livewire_replace_self === true) {
8806          el2.outerHTML = toEl.outerHTML;
8807          return skip();
8808        }
8809        if (el2.__livewire_ignore === true)
8810          return skip();
8811        if (el2.__livewire_ignore_self === true)
8812          childrenOnly();
8813        if (isComponentRootEl(el2) && el2.getAttribute("wire:id") !== component.id)
8814          return skip();
8815        if (isComponentRootEl(el2))
8816          toEl.__livewire = component;
8817      },
8818      updated: (el2) => {
8819        if (isntElement(el2))
8820          return;
8821        trigger2("morph.updated", { el: el2, component });
8822      },
8823      removing: (el2, skip) => {
8824        if (isntElement(el2))
8825          return;
8826        trigger2("morph.removing", { el: el2, component, skip });
8827      },
8828      removed: (el2) => {
8829        if (isntElement(el2))
8830          return;
8831        trigger2("morph.removed", { el: el2, component });
8832      },
8833      adding: (el2) => {
8834        trigger2("morph.adding", { el: el2, component });
8835      },
8836      added: (el2) => {
8837        if (isntElement(el2))
8838          return;
8839        const closestComponentId = closestComponent(el2).id;
8840        trigger2("morph.added", { el: el2 });
8841      },
8842      key: (el2) => {
8843        if (isntElement(el2))
8844          return;
8845        return el2.hasAttribute(`wire:key`) ? el2.getAttribute(`wire:key`) : el2.hasAttribute(`wire:id`) ? el2.getAttribute(`wire:id`) : el2.id;
8846      },
8847      lookahead: false
8848    });
8849  }
8850  function isntElement(el) {
8851    return typeof el.hasAttribute !== "function";
8852  }
8853  function isComponentRootEl(el) {
8854    return el.hasAttribute("wire:id");
8855  }
8856
8857

8857// js/features/supportMorphDom.js
8858  on2("effect", ({ component, effects }) => {
8859    let html = effects.html;
8860    if (!html)
8861      return;
8862    queueMicrotask(() => {
8863      queueMicrotask(() => {
8864        morph2(component, component.el, html);
8865      });
8866    });
8867  });
8868
8869

8869// js/features/supportDispatches.js
8870  on2("effect", ({ component, effects }) => {
8871    dispatchEvents(component, effects.dispatches || []);
8872  });
8873  function dispatchEvents(component, dispatches) {
8874    dispatches.forEach(({ name, params = {}, self = false, to }) => {
8875      if (self)
8876        dispatchSelf(component, name, params);
8877      else if (to)
8878        dispatchTo(to, name, params);
8879      else
8880        dispatch3(component, name, params);
8881    });
8882  }
8883
8884

8884// js/features/supportDisablingFormsDuringRequest.js
8885  var cleanups = new Bag();
8886  on2("directive.init", ({ el, directive: directive3, cleanup: cleanup2, component }) => setTimeout(() => {
8887    if (directive3.value !== "submit")
8888      return;
8889    el.addEventListener("submit", () => {
8890      let componentId = directive3.expression.startsWith("$parent") ? component.parent.id : component.id;
8891      let cleanup3 = disableForm(el);
8892      cleanups.add(componentId, cleanup3);
8893    });
8894  }));
8895  on2("commit", ({ component, respond }) => {
8896    respond(() => {
8897      cleanups.each(component.id, (i) => i());
8898      cleanups.remove(component.id);
8899    });
8900  });
8901  function disableForm(formEl) {
8902    let undos = [];
8903    module_default.walk(formEl, (el, skip) => {
8904      if (!formEl.contains(el))
8905        return;
8906      if (el.hasAttribute("wire:ignore"))
8907        return skip();
8908      if (shouldMarkDisabled(el)) {
8909        undos.push(markDisabled(el));
8910      } else if (shouldMarkReadOnly(el)) {
8911        undos.push(markReadOnly(el));
8912      }
8913    });
8914    return () => {
8915      while (undos.length > 0)
8916        undos.shift()();
8917    };
8918  }
8919  function shouldMarkDisabled(el) {
8920    let tag = el.tagName.toLowerCase();
8921    if (tag === "select")
8922      return true;
8923    if (tag === "button" && el.type === "submit")
8924      return true;
8925    if (tag === "input" && (el.type === "checkbox" || el.type === "radio"))
8926      return true;
8927    return false;
8928  }
8929  function shouldMarkReadOnly(el) {
8930    return ["input", "textarea"].includes(el.tagName.toLowerCase());
8931  }
8932  function markDisabled(el) {
8933    let undo = el.disabled ? () => {
8934    } : () => el.disabled = false;
8935    el.disabled = true;
8936    return undo;
8937  }
8938  function markReadOnly(el) {
8939    let undo = el.readOnly ? () => {
8940    } : () => el.readOnly = false;
8941    el.readOnly = true;
8942    return undo;
8943  }
8944
8945

8945// js/features/supportPropsAndModelables.js
8946  on2("commit.pooling", ({ commits }) => {
8947    commits.forEach((commit) => {
8948      let component = commit.component;
8949      getDeepChildrenWithBindings(component, (child) => {
8950        child.$wire.$commit();
8951      });
8952    });
8953  });
8954  on2("commit.pooled", ({ pools }) => {
8955    let commits = getPooledCommits(pools);
8956    commits.forEach((commit) => {
8957      let component = commit.component;
8958      getDeepChildrenWithBindings(component, (child) => {
8959        colocateCommitsByComponent(pools, component, child);
8960      });
8961    });
8962  });
8963  function getPooledCommits(pools) {
8964    let commits = [];
8965    pools.forEach((pool) => {
8966      pool.commits.forEach((commit) => {
8967        commits.push(commit);
8968      });
8969    });
8970    return commits;
8971  }
8972  function colocateCommitsByComponent(pools, component, foreignComponent) {
8973    let pool = findPoolWithComponent(pools, component);
8974    let foreignPool = findPoolWithComponent(pools, foreignComponent);
8975    let foreignCommit = foreignPool.findCommitByComponent(foreignComponent);
8976    foreignPool.delete(foreignCommit);
8977    pool.add(foreignCommit);
8978    pools.forEach((pool2) => {
8979      if (pool2.empty())
8980        pools.delete(pool2);
8981    });
8982  }
8983  function findPoolWithComponent(pools, component) {
8984    for (let [idx, pool] of pools.entries()) {
8985      if (pool.hasCommitFor(component))
8986        return pool;
8987    }
8988  }
8989  function getDeepChildrenWithBindings(component, callback) {
8990    getDeepChildren(component, (child) => {
8991      if (hasReactiveProps(child) || hasWireModelableBindings(child)) {
8992        callback(child);
8993      }
8994    });
8995  }
8996  function hasReactiveProps(component) {
8997    let meta = component.snapshot.memo;
8998    let props = meta.props;
8999    return !!props;
9000  }
9001  function hasWireModelableBindings(component) {
9002    let meta = component.snapshot.memo;
9003    let bindings = meta.bindings;
9004    return !!bindings;
9005  }
9006  function getDeepChildren(component, callback) {
9007    component.children.forEach((child) => {
9008      callback(child);
9009      getDeepChildren(child, callback);
9010    });
9011  }
9012
9013

9013// js/features/supportFileDownloads.js
9014  on2("commit", ({ succeed }) => {
9015    succeed(({ effects }) => {
9016      let download = effects.download;
9017      if (!download)
9018        return;
9019      let urlObject = window.webkitURL || window.URL;
9020      let url = urlObject.createObjectURL(base64toBlob(download.content, download.contentType));
9021      let invisibleLink = document.createElement("a");
9022      invisibleLink.style.display = "none";
9023      invisibleLink.href = url;
9024      invisibleLink.download = download.name;
9025      document.body.appendChild(invisibleLink);
9026      invisibleLink.click();
9027      setTimeout(function() {
9028        urlObject.revokeObjectURL(url);
9029      }, 0);
9030    });
9031  });
9032  function base64toBlob(b64Data, contentType = "", sliceSize = 512) {
9033    const byteCharacters = atob(b64Data);
9034    const byteArrays = [];
9035    if (contentType === null)
9036      contentType = "";
9037    for (let offset2 = 0; offset2 < byteCharacters.length; offset2 += sliceSize) {
9038      let slice = byteCharacters.slice(offset2, offset2 + sliceSize);
9039      let byteNumbers = new Array(slice.length);
9040      for (let i = 0; i < slice.length; i++) {
9041        byteNumbers[i] = slice.charCodeAt(i);
9042      }
9043      let byteArray = new Uint8Array(byteNumbers);
9044      byteArrays.push(byteArray);
9045    }
9046    return new Blob(byteArrays, { type: contentType });
9047  }
9048
9049

9049// js/features/supportLazyLoading.js
9050  var componentsThatWantToBeBundled = /* @__PURE__ */ new WeakSet();
9051  var componentsThatAreLazy = /* @__PURE__ */ new WeakSet();
9052  on2("component.init", ({ component }) => {
9053    let memo = component.snapshot.memo;
9054    if (memo.lazyLoaded === void 0)
9055      return;
9056    componentsThatAreLazy.add(component);
9057    if (memo.lazyIsolated !== void 0 && memo.lazyIsolated === false) {
9058      componentsThatWantToBeBundled.add(component);
9059    }
9060  });
9061  on2("commit.pooling", ({ commits }) => {
9062    commits.forEach((commit) => {
9063      if (!componentsThatAreLazy.has(commit.component))
9064        return;
9065      if (componentsThatWantToBeBundled.has(commit.component)) {
9066        commit.isolate = false;
9067        componentsThatWantToBeBundled.delete(commit.component);
9068      } else {
9069        commit.isolate = true;
9070      }
9071      componentsThatAreLazy.delete(commit.component);
9072    });
9073  });
9074
9075

9075// js/features/supportQueryString.js
9076  on2("effect", ({ component, effects, cleanup: cleanup2 }) => {
9077    let queryString = effects["url"];
9078    if (!queryString)
9079      return;
9080    Object.entries(queryString).forEach(([key, value]) => {
9081      let { name, as, use, alwaysShow, except } = normalizeQueryStringEntry(key, value);
9082      if (!as)
9083        as = name;
9084      let initialValue = [false, null, void 0].includes(except) ? dataGet(component.ephemeral, name) : except;
9085      let { replace: replace2, push: push2, pop } = track2(as, initialValue, alwaysShow);
9086      if (use === "replace") {
9087        let effectReference = module_default.effect(() => {
9088          replace2(dataGet(component.reactive, name));
9089        });
9090        cleanup2(() => module_default.release(effectReference));
9091      } else if (use === "push") {
9092        let forgetCommitHandler = on2("commit", ({ component: commitComponent, succeed }) => {
9093          if (component !== commitComponent)
9094            return;
9095          let beforeValue = dataGet(component.canonical, name);
9096          succeed(() => {
9097            let afterValue = dataGet(component.canonical, name);
9098            if (JSON.stringify(beforeValue) === JSON.stringify(afterValue))
9099              return;
9100            push2(afterValue);
9101          });
9102        });
9103        let forgetPopHandler = pop(async (newValue) => {
9104          await component.$wire.set(name, newValue);
9105          document.querySelectorAll("input").forEach((el) => {
9106            el._x_forceModelUpdate && el._x_forceModelUpdate(el._x_model.get());
9107          });
9108        });
9109        cleanup2(() => {
9110          forgetCommitHandler();
9111          forgetPopHandler();
9112        });
9113      }
9114    });
9115  });
9116  function normalizeQueryStringEntry(key, value) {
9117    let defaults = { use: "replace", alwaysShow: false };
9118    if (typeof value === "string") {
9119      return { ...defaults, name: value, as: value };
9120    } else {
9121      let fullerDefaults = { ...defaults, name: key, as: key };
9122      return { ...fullerDefaults, ...value };
9123    }
9124  }
9125
9126

9126// js/features/supportLaravelEcho.js
9127  on2("request", ({ options }) => {
9128    if (window.Echo) {
9129      options.headers["X-Socket-ID"] = window.Echo.socketId();
9130    }
9131  });
9132  on2("effect", ({ component, effects }) => {
9133    let listeners2 = effects.listeners || [];
9134    listeners2.forEach((event) => {
9135      if (event.startsWith("echo")) {
9136        if (typeof window.Echo === "undefined") {
9137          console.warn("Laravel Echo cannot be found");
9138          return;
9139        }
9140        let event_parts = event.split(/(echo:|echo-)|:|,/);
9141        if (event_parts[1] == "echo:") {
9142          event_parts.splice(2, 0, "channel", void 0);
9143        }
9144        if (event_parts[2] == "notification") {
9145          event_parts.push(void 0, void 0);
9146        }
9147        let [
9148          s1,
9149          signature,
9150          channel_type,
9151          s2,
9152          channel,
9153          s3,
9154          event_name
9155        ] = event_parts;
9156        if (["channel", "private", "encryptedPrivate"].includes(channel_type)) {
9157          let handler4 = (e) => dispatchSelf(component, event, [e]);
9158          window.Echo[channel_type](channel).listen(event_name, handler4);
9159          component.addCleanup(() => {
9160            window.Echo[channel_type](channel).stopListening(event_name, handler4);
9161          });
9162        } else if (channel_type == "presence") {
9163          if (["here", "joining", "leaving"].includes(event_name)) {
9164            window.Echo.join(channel)[event_name]((e) => {
9165              dispatchSelf(component, event, [e]);
9166            });
9167          } else {
9168            let handler4 = (e) => dispatchSelf(component, event, [e]);
9169            window.Echo.join(channel).listen(event_name, handler4);
9170            component.addCleanup(() => {
9171              window.Echo.leaveChannel(channel);
9172            });
9173          }
9174        } else if (channel_type == "notification") {
9175          window.Echo.private(channel).notification((notification) => {
9176            dispatchSelf(component, event, [notification]);
9177          });
9178        } else {
9179          console.warn("Echo channel type not yet supported");
9180        }
9181      }
9182    });
9183  });
9184
9185

9185// js/features/supportIsolating.js
9186  var componentsThatAreIsolated = /* @__PURE__ */ new WeakSet();
9187  on2("component.init", ({ component }) => {
9188    let memo = component.snapshot.memo;
9189    if (memo.isolate !== true)
9190      return;
9191    componentsThatAreIsolated.add(component);
9192  });
9193  on2("commit.pooling", ({ commits }) => {
9194    commits.forEach((commit) => {
9195      if (!componentsThatAreIsolated.has(commit.component))
9196        return;
9197      commit.isolate = true;
9198    });
9199  });
9200
9201

9201// js/features/supportNavigate.js
9202  shouldHideProgressBar() && Alpine.navigate.disableProgressBar();
9203  document.addEventListener("alpine:navigate", (e) => forwardEvent("livewire:navigate", e));
9204  document.addEventListener("alpine:navigating", (e) => forwardEvent("livewire:navigating", e));
9205  document.addEventListener("alpine:navigated", (e) => forwardEvent("livewire:navigated", e));
9206  function forwardEvent(name, original) {
9207    let event = new CustomEvent(name, { cancelable: true, bubbles: true, detail: original.detail });
9208    document.dispatchEvent(event);
9209    if (event.defaultPrevented) {
9210      original.preventDefault();
9211    }
9212  }
9213  function shouldRedirectUsingNavigateOr(effects, url, or) {
9214    let forceNavigate = effects.redirectUsingNavigate;
9215    if (forceNavigate) {
9216      Alpine.navigate(url);
9217    } else {
9218      or();
9219    }
9220  }
9221  function shouldHideProgressBar() {
9222    if (!!document.querySelector("[data-no-progress-bar]"))
9223      return true;
9224    if (window.livewireScriptConfig && window.livewireScriptConfig.progressBar === false)
9225      return true;
9226    return false;
9227  }
9228
9229

9229// js/features/supportRedirects.js
9230  on2("effect", ({ effects }) => {
9231    if (!effects["redirect"])
9232      return;
9233    let url = effects["redirect"];
9234    shouldRedirectUsingNavigateOr(effects, url, () => {
9235      window.location.href = url;
9236    });
9237  });
9238
9239

9239// js/directives/wire-transition.js
9240  on2("morph.added", ({ el }) => {
9241    el.__addedByMorph = true;
9242  });
9243  directive2("transition", ({ el, directive: directive3, component, cleanup: cleanup2 }) => {
9244    let visibility = module_default.reactive({ state: el.__addedByMorph ? false : true });
9245    module_default.bind(el, {
9246      [directive3.rawName.replace("wire:", "x-")]: "",
9247      "x-show"() {
9248        return visibility.state;
9249      }
9250    });
9251    el.__addedByMorph && setTimeout(() => visibility.state = true);
9252    let cleanups2 = [];
9253    cleanups2.push(on2("morph.removing", ({ el: el2, skip }) => {
9254      skip();
9255      el2.addEventListener("transitionend", () => {
9256        el2.remove();
9257      });
9258      visibility.state = false;
9259      cleanups2.push(on2("morph", ({ component: morphComponent }) => {
9260        if (morphComponent !== component)
9261          return;
9262        el2.remove();
9263        cleanups2.forEach((i) => i());
9264      }));
9265    }));
9266    cleanup2(() => cleanups2.forEach((i) => i()));
9267  });
9268
9269

9269// js/debounce.js
9270  var callbacksByComponent = new WeakBag();
9271  function callAndClearComponentDebounces(component, callback) {
9272    callbacksByComponent.each(component, (callbackRegister) => {
9273      callbackRegister.callback();
9274      callbackRegister.callback = () => {
9275      };
9276    });
9277    callback();
9278  }
9279
9280

9280// js/directives/wire-wildcard.js
9281  on2("directive.init", ({ el, directive: directive3, cleanup: cleanup2, component }) => {
9282    if (["snapshot", "effects", "model", "init", "loading", "poll", "ignore", "id", "data", "key", "target", "dirty"].includes(directive3.value))
9283      return;
9284    if (customDirectiveHasBeenRegistered(directive3.value))
9285      return;
9286    let attribute = directive3.rawName.replace("wire:", "x-on:");
9287    if (directive3.value === "submit" && !directive3.modifiers.includes("prevent")) {
9288      attribute = attribute + ".prevent";
9289    }
9290    let cleanupBinding = module_default.bind(el, {
9291      [attribute](e) {
9292        let execute = () => {
9293          callAndClearComponentDebounces(component, () => {
9294            module_default.evaluate(el, "$wire." + directive3.expression, { scope: { $event: e } });
9295          });
9296        };
9297        if (el.__livewire_confirm) {
9298          el.__livewire_confirm(() => {
9299            execute();
9300          }, () => {
9301            e.stopImmediatePropagation();
9302          });
9303        } else {
9304          execute();
9305        }
9306      }
9307    });
9308    cleanup2(cleanupBinding);
9309  });
9310
9311

9311// js/directives/wire-navigate.js
9312  module_default.addInitSelector(() => `[wire\\:navigate]`);
9313  module_default.addInitSelector(() => `[wire\\:navigate\\.hover]`);
9314  module_default.interceptInit(module_default.skipDuringClone((el) => {
9315    if (el.hasAttribute("wire:navigate")) {
9316      module_default.bind(el, { ["x-navigate"]: true });
9317    } else if (el.hasAttribute("wire:navigate.hover")) {
9318      module_default.bind(el, { ["x-navigate.hover"]: true });
9319    }
9320  }));
9321  document.addEventListener("alpine:navigating", () => {
9322    Livewire.all().forEach((component) => {
9323      component.inscribeSnapshotAndEffectsOnElement();
9324    });
9325  });
9326
9327

9327// js/directives/wire-confirm.js
9328  directive2("confirm", ({ el, directive: directive3 }) => {
9329    let message = directive3.expression;
9330    let shouldPrompt = directive3.modifiers.includes("prompt");
9331    message = message.replaceAll("\\n", "\n");
9332    if (message === "")
9333      message = "Are you sure?";
9334    el.__livewire_confirm = (action, instead) => {
9335      if (shouldPrompt) {
9336        let [question, expected] = message.split("|");
9337        if (!expected) {
9338          console.warn("Livewire: Must provide expectation with wire:confirm.prompt");
9339        } else {
9340          let input = prompt(question);
9341          if (input === expected) {
9342            action();
9343          } else {
9344            instead();
9345          }
9346        }
9347      } else {
9348        if (confirm(message))
9349          action();
9350        else
9351          instead();
9352      }
9353    };
9354  });
9355
9356

9356// js/directives/shared.js
9357  function toggleBooleanStateDirective(el, directive3, isTruthy, cachedDisplay = null) {
9358    isTruthy = directive3.modifiers.includes("remove") ? !isTruthy : isTruthy;
9359    if (directive3.modifiers.includes("class")) {
9360      let classes = directive3.expression.split(" ").filter(String);
9361      if (isTruthy) {
9362        el.classList.add(...classes);
9363      } else {
9364        el.classList.remove(...classes);
9365      }
9366    } else if (directive3.modifiers.includes("attr")) {
9367      if (isTruthy) {
9368        el.setAttribute(directive3.expression, true);
9369      } else {
9370        el.removeAttribute(directive3.expression);
9371      }
9372    } else {
9373      let cache = cachedDisplay ?? window.getComputedStyle(el, null).getPropertyValue("display");
9374      let display = ["inline", "block", "table", "flex", "grid", "inline-flex"].filter((i) => directive3.modifiers.includes(i))[0] || "inline-block";
9375      display = directive3.modifiers.includes("remove") && !isTruthy ? cache : display;
9376      el.style.display = isTruthy ? display : "none";
9377    }
9378  }
9379
9380

9380// js/directives/wire-offline.js
9381  var offlineHandlers = /* @__PURE__ */ new Set();
9382  var onlineHandlers = /* @__PURE__ */ new Set();
9383  window.addEventListener("offline", () => offlineHandlers.forEach((i) => i()));
9384  window.addEventListener("online", () => onlineHandlers.forEach((i) => i()));
9385  directive2("offline", ({ el, directive: directive3, cleanup: cleanup2 }) => {
9386    let setOffline = () => toggleBooleanStateDirective(el, directive3, true);
9387    let setOnline = () => toggleBooleanStateDirective(el, directive3, false);
9388    offlineHandlers.add(setOffline);
9389    onlineHandlers.add(setOnline);
9390    cleanup2(() => {
9391      offlineHandlers.delete(setOffline);
9392      onlineHandlers.delete(setOnline);
9393    });
9394  });
9395
9396

9396// js/directives/wire-loading.js
9397  directive2("loading", ({ el, directive: directive3, component, cleanup: cleanup2 }) => {
9398    let { targets, inverted } = getTargets(el);
9399    let [delay3, abortDelay] = applyDelay(directive3);
9400    let cleanupA = whenTargetsArePartOfRequest(component, targets, inverted, [
9401      () => delay3(() => toggleBooleanStateDirective(el, directive3, true)),
9402      () => abortDelay(() => toggleBooleanStateDirective(el, directive3, false))
9403    ]);
9404    let cleanupB = whenTargetsArePartOfFileUpload(component, targets, [
9405      () => delay3(() => toggleBooleanStateDirective(el, directive3, true)),
9406      () => abortDelay(() => toggleBooleanStateDirective(el, directive3, false))
9407    ]);
9408    cleanup2(() => {
9409      cleanupA();
9410      cleanupB();
9411    });
9412  });
9413  function applyDelay(directive3) {
9414    if (!directive3.modifiers.includes("delay") || directive3.modifiers.includes("none"))
9415      return [(i) => i(), (i) => i()];
9416    let duration = 200;
9417    let delayModifiers = {
9418      "shortest": 50,
9419      "shorter": 100,
9420      "short": 150,
9421      "default": 200,
9422      "long": 300,
9423      "longer": 500,
9424      "longest": 1e3
9425    };
9426    Object.keys(delayModifiers).some((key) => {
9427      if (directive3.modifiers.includes(key)) {
9428        duration = delayModifiers[key];
9429        return true;
9430      }
9431    });
9432    let timeout;
9433    let started2 = false;
9434    return [
9435      (callback) => {
9436        timeout = setTimeout(() => {
9437          callback();
9438          started2 = true;
9439        }, duration);
9440      },
9441      async (callback) => {
9442        if (started2) {
9443          await callback();
9444          started2 = false;
9445        } else {
9446          clearTimeout(timeout);
9447        }
9448      }
9449    ];
9450  }
9451  function whenTargetsArePartOfRequest(component, targets, inverted, [startLoading, endLoading]) {
9452    return on2("commit", ({ component: iComponent, commit: payload, respond }) => {
9453      if (iComponent !== component)
9454        return;
9455      if (targets.length > 0 && containsTargets(payload, targets) === inverted)
9456        return;
9457      startLoading();
9458      respond(() => {
9459        endLoading();
9460      });
9461    });
9462  }
9463  function whenTargetsArePartOfFileUpload(component, targets, [startLoading, endLoading]) {
9464    let eventMismatch = (e) => {
9465      let { id, property } = e.detail;
9466      if (id !== component.id)
9467        return true;
9468      if (targets.length > 0 && !targets.map((i) => i.target).includes(property))
9469        return true;
9470      return false;
9471    };
9472    let cleanupA = listen(window, "livewire-upload-start", (e) => {
9473      if (eventMismatch(e))
9474        return;
9475      startLoading();
9476    });
9477    let cleanupB = listen(window, "livewire-upload-finish", (e) => {
9478      if (eventMismatch(e))
9479        return;
9480      endLoading();
9481    });
9482    let cleanupC = listen(window, "livewire-upload-error", (e) => {
9483      if (eventMismatch(e))
9484        return;
9485      endLoading();
9486    });
9487    return () => {
9488      cleanupA();
9489      cleanupB();
9490      cleanupC();
9491    };
9492  }
9493  function containsTargets(payload, targets) {
9494    let { updates, calls } = payload;
9495    return targets.some(({ target, params }) => {
9496      if (params) {
9497        return calls.some(({ method, params: methodParams }) => {
9498          return target === method && params === quickHash(JSON.stringify(methodParams));
9499        });
9500      }
9501      let hasMatchingUpdate = Object.keys(updates).some((property) => {
9502        if (property.includes(".")) {
9503          let propertyRoot = property.split(".")[0];
9504          if (propertyRoot === target)
9505            return true;
9506        }
9507        return property === target;
9508      });
9509      if (hasMatchingUpdate)
9510        return true;
9511      if (calls.map((i) => i.method).includes(target))
9512        return true;
9513    });
9514  }
9515  function getTargets(el) {
9516    let directives2 = getDirectives(el);
9517    let targets = [];
9518    let inverted = false;
9519    if (directives2.has("target")) {
9520      let directive3 = directives2.get("target");
9521      let raw2 = directive3.expression;
9522      if (directive3.modifiers.includes("except"))
9523        inverted = true;
9524      if (raw2.includes("(") && raw2.includes(")")) {
9525        targets.push({ target: directive3.method, params: quickHash(JSON.stringify(directive3.params)) });
9526      } else if (raw2.includes(",")) {
9527        raw2.split(",").map((i) =>

9527 i.trim()).forEach((target) => {
9528          targets.push({ target });
9529        });
9530      } else {
9531        targets.push({ target: raw2 });
9532      }
9533    } else {
9534      let nonActionOrModelLivewireDirectives = ["init", "dirty", "offline", "target", "loading", "poll", "ignore", "key", "id"];
9535      directives2.all().filter((i) => !nonActionOrModelLivewireDirectives.includes(i.value)).map((i) => i.expression.split("(")[0]).forEach((target) => targets.push({ target }));
9536    }
9537    return { targets, inverted };
9538  }
9539  function quickHash(subject) {
9540    return btoa(encodeURIComponent(subject));
9541  }
9542
9543

9543// js/directives/wire-stream.js
9544  directive2("stream", ({ el, directive: directive3, cleanup: cleanup2 }) => {
9545    let { expression, modifiers } = directive3;
9546    let off = on2("stream", ({ name, content, replace: replace2 }) => {
9547      if (name !== expression)
9548        return;
9549      if (modifiers.includes("replace") || replace2) {
9550        el.innerHTML = content;
9551      } else {
9552        el.innerHTML = el.innerHTML + content;
9553      }
9554    });
9555    cleanup2(off);
9556  });
9557  on2("request", ({ respond }) => {
9558    respond((mutableObject) => {
9559      let response = mutableObject.response;
9560      if (!response.headers.has("X-Livewire-Stream"))
9561        return;
9562      mutableObject.response = {
9563        ok: true,
9564        redirected: false,
9565        status: 200,
9566        async text() {
9567          let finalResponse = await interceptStreamAndReturnFinalResponse(response, (streamed) => {
9568            trigger2("stream", streamed);
9569          });
9570          if (contentIsFromDump(finalResponse)) {
9571            this.ok = false;
9572          }
9573          return finalResponse;
9574        }
9575      };
9576    });
9577  });
9578  async function interceptStreamAndReturnFinalResponse(response, callback) {
9579    let reader = response.body.getReader();
9580    let remainingResponse = "";
9581    while (true) {
9582      let { done, value: chunk } = await reader.read();
9583      let decoder = new TextDecoder();
9584      let output = decoder.decode(chunk);
9585      let [streams, remaining] = extractStreamObjects(remainingResponse + output);
9586      streams.forEach((stream) => {
9587        callback(stream);
9588      });
9589      remainingResponse = remaining;
9590      if (done)
9591        return remainingResponse;
9592    }
9593  }
9594  function extractStreamObjects(raw2) {
9595    let regex = /({"stream":true.*?"endStream":true})/g;
9596    let matches2 = raw2.match(regex);
9597    let parsed = [];
9598    if (matches2) {
9599      for (let i = 0; i < matches2.length; i++) {
9600        parsed.push(JSON.parse(matches2[i]).body);
9601      }
9602    }
9603    let remaining = raw2.replace(regex, "");
9604    return [parsed, remaining];
9605  }
9606
9607

9607// js/directives/wire-replace.js
9608  directive2("replace", ({ el, directive: directive3 }) => {
9609    if (directive3.modifiers.includes("self")) {
9610      el.__livewire_replace_self = true;
9611    } else {
9612      el.__livewire_replace = true;
9613    }
9614  });
9615
9616

9616// js/directives/wire-ignore.js
9617  directive2("ignore", ({ el, directive: directive3 }) => {
9618    if (directive3.modifiers.includes("self")) {
9619      el.__livewire_ignore_self = true;
9620    } else {
9621      el.__livewire_ignore = true;
9622    }
9623  });
9624
9625

9625// js/directives/wire-dirty.js
9626  var refreshDirtyStatesByComponent = new WeakBag();
9627  on2("commit", ({ component, respond }) => {
9628    respond(() => {
9629      setTimeout(() => {
9630        refreshDirtyStatesByComponent.each(component, (i) => i(false));
9631      });
9632    });
9633  });
9634  directive2("dirty", ({ el, directive: directive3, component }) => {
9635    let targets = dirtyTargets(el);
9636    let dirty = Alpine.reactive({ state: false });
9637    let oldIsDirty = false;
9638    let initialDisplay = el.style.display;
9639    let refreshDirtyState = (isDirty) => {
9640      toggleBooleanStateDirective(el, directive3, isDirty, initialDisplay);
9641      oldIsDirty = isDirty;
9642    };
9643    refreshDirtyStatesByComponent.add(component, refreshDirtyState);
9644    Alpine.effect(() => {
9645      let isDirty = false;
9646      if (targets.length === 0) {
9647        isDirty = JSON.stringify(component.canonical) !== JSON.stringify(component.reactive);
9648      } else {
9649        for (let i = 0; i < targets.length; i++) {
9650          if (isDirty)
9651            break;
9652          let target = targets[i];
9653          isDirty = JSON.stringify(dataGet(component.canonical, target)) !== JSON.stringify(dataGet(component.reactive, target));
9654        }
9655      }
9656      if (oldIsDirty !== isDirty) {
9657        refreshDirtyState(isDirty);
9658      }
9659      oldIsDirty = isDirty;
9660    });
9661  });
9662  function dirtyTargets(el) {
9663    let directives2 = getDirectives(el);
9664    let targets = [];
9665    if (directives2.has("model")) {
9666      targets.push(directives2.get("model").expression);
9667    }
9668    if (directives2.has("target")) {
9669      targets = targets.concat(directives2.get("target").expression.split(",").map((s) => s.trim()));
9670    }
9671    return targets;
9672  }
9673
9674

9674// js/directives/wire-model.js
9675  directive2("model", ({ el, directive: directive3, component, cleanup: cleanup2 }) => {
9676    let { expression, modifiers } = directive3;
9677    if (!expression) {
9678      return console.warn("Livewire: [wire:model] is missing a value.", el);
9679    }
9680    if (componentIsMissingProperty(component, expression)) {
9681      return console.warn('Livewire: [wire:model="' + expression + '"] property does not exist on component: [' + component.name + "]", el);
9682    }
9683    if (el.type && el.type.toLowerCase() === "file") {
9684      return handleFileUpload(el, expression, component, cleanup2);
9685    }
9686    let isLive = modifiers.includes("live");
9687    let isLazy = modifiers.includes("lazy") || modifiers.includes("change");
9688    let onBlur = modifiers.includes("blur");
9689    let isDebounced = modifiers.includes("debounce");
9690    let update = expression.startsWith("$parent") ? () => component.$wire.$parent.$commit() : () => component.$wire.$commit();
9691    let debouncedUpdate = isTextInput(el) && !isDebounced && isLive ? debounce2(update, 150) : update;
9692    module_default.bind(el, {
9693      ["@change"]() {
9694        isLazy && update();
9695      },
9696      ["@blur"]() {
9697        onBlur && update();
9698      },
9699      ["x-model" + getModifierTail(modifiers)]() {
9700        return {
9701          get() {
9702            return dataGet(component.$wire, expression);
9703          },
9704          set(value) {
9705            dataSet(component.$wire, expression, value);
9706            isLive && !isLazy && !onBlur && debouncedUpdate();
9707          }
9708        };
9709      }
9710    });
9711  });
9712  function getModifierTail(modifiers) {
9713    modifiers = modifiers.filter((i) => ![
9714      "lazy",
9715      "defer"
9716    ].includes(i));
9717    if (modifiers.length === 0)
9718      return "";
9719    return "." + modifiers.join(".");
9720  }
9721  function isTextInput(el) {
9722    return ["INPUT", "TEXTAREA"].includes(el.tagName.toUpperCase()) && !["checkbox", "radio"].includes(el.type);
9723  }
9724  function componentIsMissingProperty(component, property) {
9725    if (property.startsWith("$parent")) {
9726      let parent = closestComponent(component.el.parentElement, false);
9727      if (!parent)
9728        return true;
9729      return componentIsMissingProperty(parent, property.split("$parent.")[1]);
9730    }
9731    let baseProperty = property.split(".")[0];
9732    return !Object.keys(component.canonical).includes(baseProperty);
9733  }
9734  function debounce2(func, wait) {
9735    var timeout;
9736    return function() {
9737      var context = this, args = arguments;
9738      var later = function() {
9739        timeout = null;
9740        func.apply(context, args);
9741      };
9742      clearTimeout(timeout);
9743      timeout = setTimeout(later, wait);
9744    };
9745  }
9746
9747

9747// js/directives/wire-init.js
9748  directive2("init", ({ el, directive: directive3 }) => {
9749    let fullMethod = directive3.expression ?? "$refresh";
9750    module_default.evaluate(el, `$wire.${fullMethod}`);
9751  });
9752
9753

9753// js/directives/wire-poll.js
9754  directive2("poll", ({ el, directive: directive3 }) => {
9755    let interval = extractDurationFrom(directive3.modifiers, 2e3);
9756    let { start: start3, pauseWhile, throttleWhile, stopWhen } = poll(() => {
9757      triggerComponentRequest(el, directive3);
9758    }, interval);
9759    start3();
9760    throttleWhile(() => theTabIsInTheBackground() && theDirectiveIsMissingKeepAlive(directive3));
9761    pauseWhile(() => theDirectiveHasVisible(directive3) && theElementIsNotInTheViewport(el));
9762    pauseWhile(() => theDirectiveIsOffTheElement(el));
9763    pauseWhile(() => livewireIsOffline());
9764    stopWhen(() => theElementIsDisconnected(el));
9765  });
9766  function triggerComponentRequest(el, directive3) {
9767    module_default.evaluate(el, directive3.expression ? "$wire." + directive3.expression : "$wire.$commit()");
9768  }
9769  function poll(callback, interval = 2e3) {
9770    let pauseConditions = [];
9771    let throttleConditions = [];
9772    let stopConditions = [];
9773    return {
9774      start() {
9775        let clear2 = syncronizedInterval(interval, () => {
9776          if (stopConditions.some((i) => i()))
9777            return clear2();
9778          if (pauseConditions.some((i) => i()))
9779            return;
9780          if (throttleConditions.some((i) => i()) && Math.random() < 0.95)
9781            return;
9782          callback();
9783        });
9784      },
9785      pauseWhile(condition) {
9786        pauseConditions.push(condition);
9787      },
9788      throttleWhile(condition) {
9789        throttleConditions.push(condition);
9790      },
9791      stopWhen(condition) {
9792        stopConditions.push(condition);
9793      }
9794    };
9795  }
9796  var clocks = [];
9797  function syncronizedInterval(ms, callback) {
9798    if (!clocks[ms]) {
9799      let clock = {
9800        timer: setInterval(() => clock.callbacks.forEach((i) => i()), ms),
9801        callbacks: /* @__PURE__ */ new Set()
9802      };
9803      clocks[ms] = clock;
9804    }
9805    clocks[ms].callbacks.add(callback);
9806    return () => {
9807      clocks[ms].callbacks.delete(callback);
9808      if (clocks[ms].callbacks.size === 0) {
9809        clearInterval(clocks[ms].timer);
9810        delete clocks[ms];
9811      }
9812    };
9813  }
9814  var isOffline = false;
9815  window.addEventListener("offline", () => isOffline = true);
9816  window.addEventListener("online", () => isOffline = false);
9817  function livewireIsOffline() {
9818    return isOffline;
9819  }
9820  var inBackground = false;
9821  document.addEventListener("visibilitychange", () => {
9822    inBackground = document.hidden;
9823  }, false);
9824  function theTabIsInTheBackground() {
9825    return inBackground;
9826  }
9827  function theDirectiveIsOffTheElement(el) {
9828    return !getDirectives(el).has("poll");
9829  }
9830  function theDirectiveIsMissingKeepAlive(directive3) {
9831    return !directive3.modifiers.includes("keep-alive");
9832  }
9833  function theDirectiveHasVisible(directive3) {
9834    return directive3.modifiers.includes("visible");
9835  }
9836  function theElementIsNotInTheViewport(el) {
9837    let bounding = el.getBoundingClientRect();
9838    return !(bounding.top < (window.innerHeight || document.documentElement.clientHeight) && bounding.left < (window.innerWidth || document.documentElement.clientWidth) && bounding.bottom > 0 && bounding.right > 0);
9839  }
9840  function theElementIsDisconnected(el) {
9841    return el.isConnected === false;
9842  }
9843  function extractDurationFrom(modifiers, defaultDuration) {
9844    let durationInMilliSeconds;
9845    let durationInMilliSecondsString = modifiers.find((mod) => mod.match(/([0-9]+)ms/));
9846    let durationInSecondsString = modifiers.find((mod) => mod.match(/([0-9]+)s/));
9847    if (durationInMilliSecondsString) {
9848      durationInMilliSeconds = Number(durationInMilliSecondsString.replace("ms", ""));
9849    } else if (durationInSecondsString) {
9850      durationInMilliSeconds = Number(durationInSecondsString.replace("s", "")) * 1e3;
9851    }
9852    return durationInMilliSeconds || defaultDuration;
9853  }
9854
9855

9855// js/index.js
9856  var Livewire2 = {
9857    directive: directive2,
9858    dispatchTo,
9859    start: start2,
9860    first,
9861    find,
9862    getByName,
9863    all,
9864    hook: on2,
9865    trigger: trigger2,
9866    triggerAsync,
9867    dispatch: dispatchGlobal,
9868    on: on3,
9869    get navigate() {
9870      return module_default.navigate;
9871    }
9872  };
9873  var warnAboutMultipleInstancesOf = (entity) => console.warn(`Detected multiple instances of ${entity} running`);
9874  if (window.Livewire)
9875    warnAboutMultipleInstancesOf("Livewire");
9876  if (window.Alpine)
9877    warnAboutMultipleInstancesOf("Alpine");
9878  window.Livewire = Livewire2;
9879  window.Alpine = module_default;
9880  if (window.livewireScriptConfig === void 0) {
9881    window.Alpine.__fromLivewire = true;
9882    document.addEventListener("DOMContentLoaded", () => {
9883      if (window.Alpine.__fromLivewire === void 0) {
9884        warnAboutMultipleInstancesOf("Alpine");
9885      }
9886      Livewire2.start();
9887    });
9888  }
9889})();
9890/* NProgress, (c) 2013, 2014 Rico Sta. Cruz - http://ricostacruz.com/nprogress
9891 * @license MIT */
9892/*! Bundled license information:
9893
9894tabbable/dist/index.esm.js:
9895  (*!
9896  * tabbable 5.3.3
9897  * @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
9898  *)
9899
9900focus-trap/dist/focus-trap.esm.js:
9901  (*!
9902  * focus-trap 6.9.4
9903  * @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE
9904  *)
9905*/

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.