https://minsep.cm/livewire/livewire.js?id=5d8beb2e

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  

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

434// js/features/supportFileUploads.js
435  var uploadManagers = /* @__PURE__ */ new WeakMap();
436  function getUploadManager(component) {
437    if (!uploadManagers.has(component)) {
438      let manager = new UploadManager(component);
439      uploadManagers.set(component, manager);
440      manager.registerListeners();
441    }
442    return uploadManagers.get(component);
443  }
444  function handleFileUpload(el, property, component, cleanup3) {
445    let manager = getUploadManager(component);
446    let start3 = () => el.dispatchEvent(new CustomEvent("livewire-upload-start", { bubbles: true, detail: { id: component.id, property } }));
447    let finish = () => el.dispatchEvent(new CustomEvent("livewire-upload-finish", { bubbles: true, detail: { id: component.id, property } }));
448    let error2 = () => el.dispatchEvent(new CustomEvent("livewire-upload-error", { bubbles: true, detail: { id: component.id, property } }));
449    let cancel = () => el.dispatchEvent(new CustomEvent("livewire-upload-cancel", { bubbles: true, detail: { id: component.id, property } }));
450    let progress = (progressEvent) => {
451      var percentCompleted = Math.round(progressEvent.loaded * 100 / progressEvent.total);
452      el.dispatchEvent(new CustomEvent("livewire-upload-progress", {
453        bubbles: true,
454        detail: { progress: percentCompleted }
455      }));
456    };
457    let eventHandler = (e) => {
458      if (e.target.files.length === 0)
459        return;
460      start3();
461      if (e.target.multiple) {
462        manager.uploadMultiple(property, e.target.files, finish, error2, progress, cancel);
463      } else {
464        manager.upload(property, e.target.files[0], finish, error2, progress, cancel);
465      }
466    };
467    el.addEventListener("change", eventHandler);
468    let clearFileInputValue = () => {
469      el.value = null;
470    };
471    el.addEventListener("click", clearFileInputValue);
472    el.addEventListener("livewire-upload-cancel", clearFileInputValue);
473    cleanup3(() => {
474      el.removeEventListener("change", eventHandler);
475      el.removeEventListener("click", clearFileInputValue);
476    });
477  }
478  var UploadManager = class {
479    constructor(component) {
480      this.component = component;
481      this.uploadBag = new MessageBag();
482      this.removeBag = new MessageBag();
483    }
484    registerListeners() {
485      this.component.$wire.$on("upload:generatedSignedUrl", ({ name, url }) => {
486        setUploadLoading(this.component, name);
487        this.handleSignedUrl(name, url);
488      });
489      this.component.$wire.$on("upload:generatedSignedUrlForS3", ({ name, payload }) => {
490        setUploadLoading(this.component, name);
491        this.handleS3PreSignedUrl(name, payload);
492      });
493      this.component.$wire.$on("upload:finished", ({ name, tmpFilenames }) => this.markUploadFinished(name, tmpFilenames));
494      this.component.$wire.$on("upload:errored", ({ name }) => this.markUploadErrored(name));
495      this.component.$wire.$on("upload:removed", ({ name, tmpFilename }) => this.removeBag.shift(name).finishCallback(tmpFilename));
496    }
497    upload(name, file, finishCallback, errorCallback, progressCallback, cancelledCallback) {
498      this.setUpload(name, {
499        files: [file],
500        multiple: false,
501        finishCallback,
502        errorCallback,
503        progressCallback,
504        cancelledCallback
505      });
506    }
507    uploadMultiple(name, files, finishCallback, errorCallback, progressCallback, cancelledCallback) {
508      this.setUpload(name, {
509        files: Array.from(files),
510        multiple: true,
511        finishCallback,
512        errorCallback,
513        progressCallback,
514        cancelledCallback
515      });
516    }
517    removeUpload(name, tmpFilename, finishCallback) {
518      this.removeBag.push(name, {
519        tmpFilename,
520        finishCallback
521      });
522      this.component.$wire.call("_removeUpload", name, tmpFilename);
523    }
524    setUpload(name, uploadObject) {
525      this.uploadBag.add(name, uploadObject);
526      if (this.uploadBag.get(name).length === 1) {
527        this.startUpload(name, uploadObject);
528      }
529    }
530    handleSignedUrl(name, url) {
531      let formData = new FormData();

532      Array.from(this.uploadBag.first(name).files).forEach((file) => formData.append("files[]", file, file.name));
533      let headers = {
534        "Accept": "application/json"
535      };
536      let csrfToken = getCsrfToken();
537      if (csrfToken)
538        headers["X-CSRF-TOKEN"] = csrfToken;
539      this.makeRequest(name, formData, "post", url, headers, (response) => {
540        return response.paths;
541      });
542    }
543    handleS3PreSignedUrl(name, payload) {
544      let formData = this.uploadBag.first(name).files[0];
545      let headers = payload.headers;
546      if ("Host" in headers)
547        delete headers.Host;
548      let url = payload.url;
549      this.makeRequest(name, formData, "put", url, headers, (response) => {
550        return [payload.path];
551      });
552    }
553    makeRequest(name, formData, method, url, headers, retrievePaths) {
554      let request = new XMLHttpRequest();
555      request.open(method, url);
556      Object.entries(headers).forEach(([key, value]) => {
557        request.setRequestHeader(key, value);
558      });
559      request.upload.addEventListener("progress", (e) => {
560        e.detail = {};
561        e.detail.progress = Math.round(e.loaded * 100 / e.total);
562        this.uploadBag.first(name).progressCallback(e);
563      });
564      request.addEventListener("load", () => {
565        if ((request.status + "")[0] === "2") {
566          let paths = retrievePaths(request.response && JSON.parse(request.response));
567          this.component.$wire.call("_finishUpload", name, paths, this.uploadBag.first(name).multiple);
568          return;
569        }
570        let errors = null;
571        if (request.status === 422) {
572          errors = request.response;
573        }
574        this.component.$wire.call("_uploadErrored", name, errors, this.uploadBag.first(name).multiple);
575      });
576      this.uploadBag.first(name).request = request;
577      request.send(formData);
578    }
579    startUpload(name, uploadObject) {
580      let fileInfos = uploadObject.files.map((file) => {
581        return { name: file.name, size: file.size, type: file.type };
582      });
583      this.component.$wire.call("_startUpload", name, fileInfos, uploadObject.multiple);
584      setUploadLoading(this.component, name);
585    }
586    markUploadFinished(name, tmpFilenames) {
587      unsetUploadLoading(this.component);
588      let uploadObject = this.uploadBag.shift(name);
589      uploadObject.finishCallback(uploadObject.multiple ? tmpFilenames : tmpFilenames[0]);
590      if (this.uploadBag.get(name).length > 0)
591        this.startUpload(name, this.uploadBag.last(name));
592    }
593    markUploadErrored(name) {
594      unsetUploadLoading(this.component);
595      this.uploadBag.shift(name).errorCallback();
596      if (this.uploadBag.get(name).length > 0)
597        this.startUpload(name, this.uploadBag.last(name));
598    }
599    cancelUpload(name, cancelledCallback = null) {
600      unsetUploadLoading(this.component);
601      let uploadItem = this.uploadBag.first(name);
602      if (uploadItem) {
603        uploadItem.request.abort();
604        this.uploadBag.shift(name).cancelledCallback();
605        if (cancelledCallback)
606          cancelledCallback();
607      }
608    }
609  };
610  var MessageBag = class {
611    constructor() {
612      this.bag = {};
613    }
614    add(name, thing) {
615      if (!this.bag[name]) {
616        this.bag[name] = [];
617      }
618      this.bag[name].push(thing);
619    }
620    push(name, thing) {
621      this.add(name, thing);
622    }
623    first(name) {
624      if (!this.bag[name])
625        return null;
626      return this.bag[name][0];
627    }
628    last(name) {
629      return this.bag[name].slice(-1)[0];
630    }
631    get(name) {
632      return this.bag[name];
633    }
634    shift(name) {
635      return this.bag[name].shift();
636    }
637    call(name, ...params) {
638      (this.listeners[name] || []).forEach((callback) => {
639        callback(...params);
640      });
641    }
642    has(name) {
643      return Object.keys(this.listeners).includes(name);
644    }
645  };
646  function setUploadLoading() {
647  }
648  function unsetUploadLoading() {
649  }
650  function upload(component, name, file, finishCallback = () => {
651  }, errorCallback = () => {
652  }, progressCallback = () => {
653  }, cancelledCallback = () => {
654  }) {
655    let uploadManager = getUploadManager(component);
656    uploadManager.upload(name, file, finishCallback, errorCallback, progressCallback, cancelledCallback);
657  }
658  function uploadMultiple(component, name, files, finishCallback = () => {
659  }, errorCallback = () => {
660  }, progressCallback = () => {
661  }, cancelledCallback = () => {
662  }) {
663    let uploadManager = getUploadManager(component);
664    uploadManager.uploadMultiple(name, files, finishCallback, errorCallback, progressCallback, cancelledCallback);
665  }
666  function removeUpload(component, name, tmpFilename, finishCallback = () => {
667  }, errorCallback = () => {
668  }) {
669    let uploadManager = getUploadManager(component);
670    uploadManager.removeUpload(name, tmpFilename, finishCallback, errorCallback);
671  }
672  function cancelUpload(component, name, cancelledCallback = () => {
673  }) {
674    let uploadManager = getUploadManager(component);
675    uploadManager.cancelUpload(name, cancelledCallback);
676  }
677
678  

678// ../alpine/packages/alpinejs/dist/module.esm.js
679  var flushPending = false;
680  var flushing = false;
681  var queue = [];
682  var lastFlushedIndex = -1;
683  function scheduler(callback) {
684    queueJob(callback);
685  }
686  function queueJob(job) {
687    if (!queue.includes(job))
688      queue.push(job);
689    queueFlush();
690  }
691  function dequeueJob(job) {
692    let index = queue.indexOf(job);
693    if (index !== -1 && index > lastFlushedIndex)
694      queue.splice(index, 1);
695  }
696  function queueFlush() {
697    if (!flushing && !flushPending) {
698      flushPending = true;
699      queueMicrotask(flushJobs);
700    }
701  }
702  function flushJobs() {
703    flushPending = false;
704    flushing = true;
705    for (let i = 0; i < queue.length; i++) {
706      queue[i]();
707      lastFlushedIndex = i;
708    }
709    queue.length = 0;
710    lastFlushedIndex = -1;
711    flushing = false;
712  }
713  var reactive;
714  var effect;
715  var release;
716  var raw;
717  var shouldSchedule = true;
718  function disableEffectScheduling(callback) {
719    shouldSchedule = false;
720    callback();
721    shouldSchedule = true;
722  }
723  function setReactivityEngine(engine) {
724    reactive = engine.reactive;
725    release = engine.release;
726    effect = (callback) => engine.effect(callback, { scheduler: (task) => {
727      if (shouldSchedule) {
728        scheduler(task);
729      } else {
730        task();
731      }
732    } });
733    raw = engine.raw;
734  }
735  function overrideEffect(override) {
736    effect = override;
737  }
738  function elementBoundEffect(el) {
739    let cleanup22 = () => {
740    };
741    let wrappedEffect = (callback) => {
742      let effectReference = effect(callback);
743      if (!el._x_effects) {
744        el._x_effects = /* @__PURE__ */ new Set();
745        el._x_runEffects = () => {
746          el._x_effects.forEach((i) => i());
747        };
748      }
749      el._x_effects.add(effectReference);
750      cleanup22 = () => {
751        if (effectReference === void 0)
752          return;
753        el._x_effects.delete(effectReference);
754        release(effectReference);
755      };
756      return effectReference;
757    };
758    return [wrappedEffect, () => {
759      cleanup22();
760    }];
761  }
762  function watch(getter, callback) {
763    let firstTime = true;
764    let oldValue;
765    let effectReference = effect(() => {
766      let value = getter();
767      JSON.stringify(value);
768      if (!firstTime) {
769        queueMicrotask(() => {
770          callback(value, oldValue);
771          oldValue = value;
772        });
773      } else {
774        oldValue = value;
775      }
776      firstTime = false;
777    });
778    return () => release(effectReference);
779  }
780  function dispatch2(el, name, detail = {}) {
781    el.dispatchEvent(new CustomEvent(name, {
782      detail,
783      bubbles: true,
784      composed: true,
785      cancelable: true
786    }));
787  }
788  function walk(el, callback) {
789    if (typeof ShadowRoot === "function" && el instanceof ShadowRoot) {
790      Array.from(el.children).forEach((el2) => walk(el2, callback));
791      return;
792    }
793    let skip = false;
794    callback(el, () => skip = true);
795    if (skip)
796      return;
797    let node = el.firstElementChild;
798    while (node) {
799      walk(node, callback, false);
800      node = node.nextElementSibling;
801    }
802  }
803  function warn(message, ...args) {
804    console.warn(`Alpine Warning: ${message}`, ...args);
805  }
806  var started = false;
807  function start() {
808    if (started)
809      warn("Alpine has already been initialized on this page. Calling Alpine.start() more than once can cause problems.");
810    started = true;
811    if (!document.body)
812      warn("Unable to initialize. Trying to load Alpine before `<body>` is available. Did you forget to add `defer` in Alpine's `<script>` tag?");
813    dispatch2(document, "alpine:init");
814    dispatch2(document, "alpine:initializing");
815    startObservingMutations();
816    onElAdded((el) => initTree(el, walk));
817    onElRemoved((el) => destroyTree(el));
818    onAttributesAdded((el, attrs) => {
819      directives(el, attrs).forEach((handle) => handle());
820    });
821    let outNestedComponents = (el) => !closestRoot(el.parentElement, true);
822    Array.from(document.querySelectorAll(allSelectors().join(","))).filter(outNestedComponents).forEach((el) => {
823      initTree(el);
824    });
825    dispatch2(document, "alpine:initialized");
826  }
827  var rootSelectorCallbacks = [];
828  var initSelectorCallbacks = [];
829  function rootSelectors() {
830    return rootSelectorCallbacks.map((fn) => fn());
831  }
832  function allSelectors() {
833    return rootSelectorCallbacks.concat(initSelectorCallbacks).map((fn) => fn());
834  }
835  function addRootSelector(selectorCallback) {
836    rootSelectorCallbacks.push(selectorCallback);
837  }
838  function addInitSelector(selectorCallback) {
839    initSelectorCallbacks.push(selectorCallback);
840  }
841  function closestRoot(el, includeInitSelectors = false) {
842    return findClosest(el, (element) => {
843      const selectors = includeInitSelectors ? allSelectors() : rootSelectors();
844      if (selectors.some((selector) => element.matches(selector)))
845        return true;
846    });
847  }
848  function findClosest(el, callback) {
849    if (!el)
850      return;
851    if (callback(el))
852      return el;
853    if (el._x_teleportBack)
854      el = el._x_teleportBack;
855    if (!el.parentElement)
856      return;
857    return findClosest(el.parentElement, callback);
858  }
859  function isRoot(el) {
860    return rootSelectors().some((selector) => el.matches(selector));
861  }
862  var initInterceptors = [];
863  function interceptInit(callback) {
864    initInterceptors.push(callback);
865  }
866  function initTree(el, walker = walk, intercept = () => {
867  }) {
868    deferHandlingDirectives(() => {
869      walker(el, (el2, skip) => {
870        intercept(el2, skip);

871        initInterceptors.forEach((i) => i(el2, skip));
872        directives(el2, el2.attributes).forEach((handle) => handle());
873        el2._x_ignore && skip();
874      });
875    });
876  }
877  function destroyTree(root, walker = walk) {
878    walker(root, (el) => {
879      cleanupAttributes(el);
880      cleanupElement(el);
881    });
882  }
883  var onAttributeAddeds = [];
884  var onElRemoveds = [];
885  var onElAddeds = [];
886  function onElAdded(callback) {
887    onElAddeds.push(callback);
888  }
889  function onElRemoved(el, callback) {
890    if (typeof callback === "function") {
891      if (!el._x_cleanups)
892        el._x_cleanups = [];
893      el._x_cleanups.push(callback);
894    } else {
895      callback = el;
896      onElRemoveds.push(callback);
897    }
898  }
899  function onAttributesAdded(callback) {
900    onAttributeAddeds.push(callback);
901  }
902  function onAttributeRemoved(el, name, callback) {
903    if (!el._x_attributeCleanups)
904      el._x_attributeCleanups = {};
905    if (!el._x_attributeCleanups[name])
906      el._x_attributeCleanups[name] = [];
907    el._x_attributeCleanups[name].push(callback);
908  }
909  function cleanupAttributes(el, names) {
910    if (!el._x_attributeCleanups)
911      return;
912    Object.entries(el._x_attributeCleanups).forEach(([name, value]) => {
913      if (names === void 0 || names.includes(name)) {
914        value.forEach((i) => i());
915        delete el._x_attributeCleanups[name];
916      }
917    });
918  }
919  function cleanupElement(el) {
920    if (el._x_cleanups) {
921      while (el._x_cleanups.length)
922        el._x_cleanups.pop()();
923    }
924  }
925  var observer = new MutationObserver(onMutate);
926  var currentlyObserving = false;
927  function startObservingMutations() {
928    observer.observe(document, { subtree: true, childList: true, attributes: true, attributeOldValue: true });
929    currentlyObserving = true;
930  }
931  function stopObservingMutations() {
932    flushObserver();
933    observer.disconnect();
934    currentlyObserving = false;
935  }
936  var queuedMutations = [];
937  function flushObserver() {
938    let records = observer.takeRecords();
939    queuedMutations.push(() => records.length > 0 && onMutate(records));
940    let queueLengthWhenTriggered = queuedMutations.length;
941    queueMicrotask(() => {
942      if (queuedMutations.length === queueLengthWhenTriggered) {
943        while (queuedMutations.length > 0)
944          queuedMutations.shift()();
945      }
946    });
947  }
948  function mutateDom(callback) {
949    if (!currentlyObserving)
950      return callback();
951    stopObservingMutations();
952    let result = callback();
953    startObservingMutations();
954    return result;
955  }
956  var isCollecting = false;
957  var deferredMutations = [];
958  function deferMutations() {
959    isCollecting = true;
960  }
961  function flushAndStopDeferringMutations() {
962    isCollecting = false;
963    onMutate(deferredMutations);
964    deferredMutations = [];
965  }
966  function onMutate(mutations) {
967    if (isCollecting) {
968      deferredMutations = deferredMutations.concat(mutations);
969      return;
970    }
971    let addedNodes = /* @__PURE__ */ new Set();
972    let removedNodes = /* @__PURE__ */ new Set();
973    let addedAttributes = /* @__PURE__ */ new Map();
974    let removedAttributes = /* @__PURE__ */ new Map();
975    for (let i = 0; i < mutations.length; i++) {
976      if (mutations[i].target._x_ignoreMutationObserver)
977        continue;
978      if (mutations[i].type === "childList") {
979        mutations[i].addedNodes.forEach((node) => node.nodeType === 1 && addedNodes.add(node));
980        mutations[i].removedNodes.forEach((node) => node.nodeType === 1 && removedNodes.add(node));
981      }
982      if (mutations[i].type === "attributes") {
983        let el = mutations[i].target;
984        let name = mutations[i].attributeName;
985        let oldValue = mutations[i].oldValue;
986        let add2 = () => {
987          if (!addedAttributes.has(el))
988            addedAttributes.set(el, []);
989          addedAttributes.get(el).push({ name, value: el.getAttribute(name) });
990        };
991        let remove = () => {
992          if (!removedAttributes.has(el))
993            removedAttributes.set(el, []);
994          removedAttributes.get(el).push(name);
995        };
996        if (el.hasAttribute(name) && oldValue === null) {
997          add2();
998        } else if (el.hasAttribute(name)) {
999          remove();
1000          add2();
1001        } else {
1002          remove();
1003        }
1004      }
1005    }

1006    removedAttributes.forEach((attrs, el) => {
1007      cleanupAttributes(el, attrs);
1008    });
1009    addedAttributes.forEach((attrs, el) => {
1010      onAttributeAddeds.forEach((i) => i(el, attrs));
1011    });
1012    for (let node of removedNodes) {
1013      if (addedNodes.has(node))
1014        continue;
1015      onElRemoveds.forEach((i) => i(node));
1016      destroyTree(node);
1017    }
1018    addedNodes.forEach((node) => {
1019      node._x_ignoreSelf = true;
1020      node._x_ignore = true;
1021    });
1022    for (let node of addedNodes) {
1023      if (removedNodes.has(node))
1024        continue;
1025      if (!node.isConnected)
1026        continue;
1027      delete node._x_ignoreSelf;
1028      delete node._x_ignore;
1029      onElAddeds.forEach((i) => i(node));
1030      node._x_ignore = true;
1031      node._x_ignoreSelf = true;
1032    }
1033    addedNodes.forEach((node) => {
1034      delete node._x_ignoreSelf;
1035      delete node._x_ignore;
1036    });
1037    addedNodes = null;
1038    removedNodes = null;
1039    addedAttributes = null;
1040    removedAttributes = null;
1041  }
1042  function scope(node) {
1043    return mergeProxies(closestDataStack(node));
1044  }
1045  function addScopeToNode(node, data2, referenceNode) {
1046    node._x_dataStack = [data2, ...closestDataStack(referenceNode || node)];
1047    return () => {
1048      node._x_dataStack = node._x_dataStack.filter((i) => i !== data2);
1049    };
1050  }
1051  function closestDataStack(node) {
1052    if (node._x_dataStack)
1053      return node._x_dataStack;
1054    if (typeof ShadowRoot === "function" && node instanceof ShadowRoot) {
1055      return closestDataStack(node.host);
1056    }
1057    if (!node.parentNode) {
1058      return [];
1059    }
1060    return closestDataStack(node.parentNode);
1061  }
1062  function mergeProxies(objects) {
1063    return new Proxy({ objects }, mergeProxyTrap);
1064  }
1065  var mergeProxyTrap = {
1066    ownKeys({ objects }) {
1067      return Array.from(new Set(objects.flatMap((i) => Object.keys(i))));
1068    },
1069    has({ objects }, name) {
1070      if (name == Symbol.unscopables)
1071        return false;
1072      return objects.some((obj) => Object.prototype.hasOwnProperty.call(obj, name) || Reflect.has(obj, name));
1073    },
1074    get({ objects }, name, thisProxy) {
1075      if (name == "toJSON")
1076        return collapseProxies;
1077      return Reflect.get(objects.find((obj) => Reflect.has(obj, name)) || {}, name, thisProxy);
1078    },
1079    set({ objects }, name, value, thisProxy) {
1080      const target = objects.find((obj) => Object.prototype.hasOwnProperty.call(obj, name)) || objects[objects.length - 1];
1081      const descriptor = Object.getOwnPropertyDescriptor(target, name);
1082      if (descriptor?.set && descriptor?.get)
1083        return Reflect.set(target, name, value, thisProxy);
1084      return Reflect.set(target, name, value);
1085    }
1086  };
1087  function collapseProxies() {
1088    let keys = Reflect.ownKeys(this);
1089    return keys.reduce((acc, key) => {
1090      acc[key] = Reflect.get(this, key);
1091      return acc;
1092    }, {});
1093  }
1094  function initInterceptors2(data2) {
1095    let isObject22 = (val) => typeof val === "object" && !Array.isArray(val) && val !== null;
1096    let recurse = (obj, basePath = "") => {
1097      Object.entries(Object.getOwnPropertyDescriptors(obj)).forEach(([key, { value, enumerable }]) => {
1098        if (enumerable === false || value === void 0)
1099          return;
1100        if (typeof value === "object" && value !== null && value.__v_skip)
1101          return;
1102        let path = basePath === "" ? key : `${basePath}.${key}`;
1103        if (typeof value === "object" && value !== null && value._x_interceptor) {
1104          obj[key] = value.initialize(data2, path, key);
1105        } else {
1106          if (isObject22(value) && value !== obj && !(value instanceof Element)) {
1107            recurse(value, path);
1108          }
1109        }
1110      });
1111    };
1112    return recurse(data2);
1113  }
1114  function interceptor(callback, mutateObj = () => {
1115  }) {
1116    let obj = {
1117      initialValue: void 0,
1118      _x_interceptor: true,
1119      initialize(data2, path, key) {
1120        return callback(this.initialValue, () => get(data2, path), (value) => set(data2, path, value), path, key);
1121      }
1122    };
1123    mutateObj(obj);
1124    return (initialValue) => {
1125      if (typeof initialValue === "object" && initialValue !== null && initialValue._x_interceptor) {
1126        let initialize = obj.initialize.bind(obj);
1127        obj.initialize = (data2, path, key) => {
1128          let innerValue = initialValue.initialize(data2, path, key);
1129          obj.initialValue = innerValue;
1130          return initialize(data2, path, key);
1131        };
1132      } else {
1133        obj.initialValue = initialValue;
1134      }
1135      return obj;
1136    };
1137  }
1138  function get(obj, path) {
1139    return path.split(".").reduce((carry, segment) => carry[segment], obj);
1140  }
1141  function set(obj, path, value) {
1142    if (typeof path === "string")
1143      path = path.split(".");
1144    if (path.length === 1)
1145      obj[path[0]] = value;
1146    else if (path.length === 0)
1147      throw error;
1148    else {
1149      if (obj[path[0]])
1150        return set(obj[path[0]], path.slice(1), value);
1151      else {
1152        obj[path[0]] = {};
1153        return set(obj[path[0]], path.slice(1), value);
1154      }
1155    }
1156  }
1157  var magics = {};
1158  function magic(name, callback) {
1159    magics[name] = callback;
1160  }
1161  function injectMagics(obj, el) {

1162    Object.entries(magics).forEach(([name, callback]) => {
1163      let memoizedUtilities = null;
1164      function getUtilities() {
1165        if (memoizedUtilities) {
1166          return memoizedUtilities;
1167        } else {
1168          let [utilities, cleanup22] = getElementBoundUtilities(el);
1169          memoizedUtilities = { interceptor, ...utilities };
1170          onElRemoved(el, cleanup22);
1171          return memoizedUtilities;
1172        }
1173      }
1174      Object.defineProperty(obj, `$${name}`, {
1175        get() {
1176          return callback(el, getUtilities());
1177        },
1178        enumerable: false
1179      });
1180    });
1181    return obj;
1182  }
1183  function tryCatch(el, expression, callback, ...args) {
1184    try {
1185      return callback(...args);
1186    } catch (e) {
1187      handleError(e, el, expression);
1188    }
1189  }
1190  function handleError(error2, el, expression = void 0) {
1191    error2 = Object.assign(error2 ?? { message: "No error message given." }, { el, expression });
1192    console.warn(`Alpine Expression Error: ${error2.message}
1193
1194${expression ? 'Expression: "' + expression + '"\n\n' : ""}`, el);
1195    setTimeout(() => {
1196      throw error2;
1197    }, 0);
1198  }
1199  var shouldAutoEvaluateFunctions = true;
1200  function dontAutoEvaluateFunctions(callback) {

1201    let cache = shouldAutoEvaluateFunctions;
1202    shouldAutoEvaluateFunctions = false;
1203    let result = callback();
1204    shouldAutoEvaluateFunctions = cache;
1205    return result;
1206  }
1207  function evaluate(el, expression, extras = {}) {
1208    let result;
1209    evaluateLater(el, expression)((value) => result = value, extras);
1210    return result;
1211  }
1212  function evaluateLater(...args) {
1213    return theEvaluatorFunction(...args);
1214  }
1215  var theEvaluatorFunction = normalEvaluator;
1216  function setEvaluator(newEvaluator) {
1217    theEvaluatorFunction = newEvaluator;
1218  }
1219  function normalEvaluator(el, expression) {
1220    let overriddenMagics = {};
1221    injectMagics(overriddenMagics, el);
1222    let dataStack = [overriddenMagics, ...closestDataStack(el)];
1223    let evaluator = typeof expression === "function" ? generateEvaluatorFromFunction(dataStack, expression) : generateEvaluatorFromString(dataStack, expression, el);
1224    return tryCatch.bind(null, el, expression, evaluator);
1225  }
1226  function generateEvaluatorFromFunction(dataStack, func) {
1227    return (receiver = () => {
1228    }, { scope: scope2 = {}, params = [] } = {}) => {
1229      let result = func.apply(mergeProxies([scope2, ...dataStack]), params);
1230      runIfTypeOfFunction(receiver, result);
1231    };
1232  }
1233  var evaluatorMemo = {};
1234  function generateFunctionFromString(expression, el) {
1235    if (evaluatorMemo[expression]) {
1236      return evaluatorMemo[expression];
1237    }
1238    let AsyncFunction = Object.getPrototypeOf(async function() {
1239    }).constructor;
1240    let rightSideSafeExpression = /^[\n\s]*if.*\(.*\)/.test(expression.trim()) || /^(let|const)\s/.test(expression.trim()) ? `(async()=>{ ${expression} })()` : expression;
1241    const safeAsyncFunction = () => {
1242      try {
1243        let func2 = new AsyncFunction(["__self", "scope"], `with (scope) { __self.result = ${rightSideSafeExpression} }; __self.finished = true; return __self.result;`);
1244        Object.defineProperty(func2, "name", {
1245          value: `[Alpine] ${expression}`
1246        });
1247        return func2;
1248      } catch (error2) {
1249        handleError(error2, el, expression);
1250        return Promise.resolve();
1251      }
1252    };
1253    let func = safeAsyncFunction();
1254    evaluatorMemo[expression] = func;
1255    return func;
1256  }
1257  function generateEvaluatorFromString(dataStack, expression, el) {
1258    let func = generateFunctionFromString(expression, el);
1259    return (receiver = () => {
1260    }, { scope: scope2 = {}, params = [] } = {}) => {
1261      func.result = void 0;
1262      func.finished = false;
1263      let completeScope = mergeProxies([scope2, ...dataStack]);
1264      if (typeof func === "function") {
1265        let promise = func(func, completeScope).catch((error2) => handleError(error2, el, expression));
1266        if (func.finished) {
1267          runIfTypeOfFunction(receiver, func.result, completeScope, params, el);
1268          func.result = void 0;
1269        } else {
1270          promise.then((result) => {
1271            runIfTypeOfFunction(receiver, result, completeScope, params, el);
1272          }).catch((error2) => handleError(error2, el, expression)).finally(() => func.result = void 0);
1273        }
1274      }
1275    };
1276  }
1277  function runIfTypeOfFunction(receiver, value, scope2, params, el) {
1278    if (shouldAutoEvaluateFunctions && typeof value === "function") {
1279      let result = value.apply(scope2, params);
1280      if (result instanceof Promise) {
1281        result.then((i) => runIfTypeOfFunction(receiver, i, scope2, params)).catch((error2) => handleError(error2, el, value));
1282      } else {
1283        receiver(result);
1284      }
1285    } else if (typeof value === "object" && value instanceof Promise) {
1286      value.then((i) => receiver(i));
1287    } else {
1288      receiver(value);
1289    }
1290  }
1291  var prefixAsString = "x-";
1292  function prefix(subject = "") {
1293    return prefixAsString + subject;
1294  }
1295  function setPrefix(newPrefix) {
1296    prefixAsString = newPrefix;
1297  }
1298  var directiveHandlers = {};
1299  function directive(name, callback) {
1300    directiveHandlers[name] = callback;
1301    return {
1302      before(directive22) {
1303        if (!directiveHandlers[directive22]) {
1304          console.warn(String.raw`Cannot find directive \`${directive22}\`. \`${name}\` will use the default order of execution`);
1305          return;
1306        }
1307        const pos = directiveOrder.indexOf(directive22);
1308        directiveOrder.splice(pos >= 0 ? pos : directiveOrder.indexOf("DEFAULT"), 0, name);
1309      }
1310    };
1311  }
1312  function directives(el, attributes, originalAttributeOverride) {
1313    attributes = Array.from(attributes);
1314    if (el._x_virtualDirectives) {
1315      let vAttributes = Object.entries(el._x_virtualDirectives).map(([name, value]) => ({ name, value }));
1316      let staticAttributes = attributesOnly(vAttributes);
1317      vAttributes = vAttributes.map((attribute) => {
1318        if (staticAttributes.find((attr) => attr.name === attribute.name)) {
1319          return {
1320            name: `x-bind:${attribute.name}`,
1321            value: `"${attribute.value}"`
1322          };
1323        }
1324        return attribute;
1325      });
1326      attributes = attributes.concat(vAttributes);
1327    }
1328    let transformedAttributeMap = {};
1329    let directives2 = attributes.map(toTransformedAttributes((newName, oldName) => transformedAttributeMap[newName] = oldName)).filter(outNonAlpineAttributes).map(toParsedDirectives(transformedAttributeMap, originalAttributeOverride)).sort(byPriority);
1330    return directives2.map((directive22) => {
1331      return getDirectiveHandler(el, directive22);
1332    });
1333  }
1334  function attributesOnly(attributes) {
1335    return Array.from(attributes).map(toTransformedAttributes()).filter((attr) => !outNonAlpineAttributes(attr));
1336  }
1337  var isDeferringHandlers = false;
1338  var directiveHandlerStacks = /* @__PURE__ */ new Map();
1339  var currentHandlerStackKey = Symbol();
1340  function deferHandlingDirectives(callback) {
1341    isDeferringHandlers = true;
1342    let key = Symbol();
1343    currentHandlerStackKey = key;
1344    directiveHandlerStacks.set(key, []);
1345    let flushHandlers = () => {
1346      while (directiveHandlerStacks.get(key).length)
1347        directiveHandlerStacks.get(key).shift()();
1348      directiveHandlerStacks.delete(key);
1349    };
1350    let stopDeferring = () => {
1351      isDeferringHandlers = false;
1352      flushHandlers();
1353    };
1354    callback(flushHandlers);
1355    stopDeferring();
1356  }
1357  function getElementBoundUtilities(el) {
1358    let cleanups = [];
1359    let cleanup22 = (callback) => cleanups.push(callback);
1360    let [effect3, cleanupEffect] = elementBoundEffect(el);
1361    cleanups.push(cleanupEffect);
1362    let utilities = {
1363      Alpine: alpine_default,
1364      effect: effect3,
1365      cleanup: cleanup22,
1366      evaluateLater: evaluateLater.bind(evaluateLater, el),
1367      evaluate: evaluate.bind(evaluate, el)
1368    };
1369    let doCleanup = () => cleanups.forEach((i) => i());
1370    return [utilities, doCleanup];
1371  }
1372  function getDirectiveHandler(el, directive22) {
1373    let noop = () => {
1374    };
1375    let handler4 = directiveHandlers[directive22.type] || noop;
1376    let [utilities, cleanup22] = getElementBoundUtilities(el);
1377    onAttributeRemoved(el, directive22.original, cleanup22);
1378    let fullHandler = () => {
1379      if (el._x_ignore || el._x_ignoreSelf)
1380        return;
1381      handler4.inline && handler4.inline(el, directive22, utilities);
1382      handler4 = handler4.bind(handler4, el, directive22, utilities);
1383      isDeferringHandlers ? directiveHandlerStacks.get(currentHandlerStackKey).push(handler4) : handler4();
1384    };
1385    fullHandler.runCleanups = cleanup22;
1386    return fullHandler;
1387  }
1388  var startingWith = (subject, replacement) => ({ name, value }) => {
1389    if (name.startsWith(subject))
1390      name = name.replace(subject, replacement);
1391    return { name, value };
1392  };
1393  var into = (i) => i;
1394  function toTransformedAttributes(callback = () => {
1395  }) {
1396    return ({ name, value }) => {
1397      let { name: newName, value: newValue } = attributeTransformers.reduce((carry, transform) => {
1398        return transform(carry);
1399      }, { name, value });
1400      if (newName !== name)
1401        callback(newName, name);
1402      return { name: newName, value: newValue };
1403    };
1404  }
1405  var attributeTransformers = [];
1406  function mapAttributes(callback) {
1407    attributeTransformers.push(callback);
1408  }
1409  function outNonAlpineAttributes({ name }) {
1410    return alpineAttributeRegex().test(name);
1411  }
1412  var alpineAttributeRegex = () => new RegExp(`^${prefixAsString}([^:^.]+)\\b`);
1413  function toParsedDirectives(transformedAttributeMap, originalAttributeOverride) {
1414    return ({ name, value }) => {
1415      let typeMatch = name.match(alpineAttributeRegex());
1416      let valueMatch = name.match(/:([a-zA-Z0-9\-_:]+)/);
1417      let modifiers = name.match(/\.[^.\]]+(?=[^\]]*$)/g) || [];
1418      let original = originalAttributeOverride || transformedAttributeMap[name] || name;
1419      return {
1420        type: typeMatch ? typeMatch[1] : null,
1421        value: valueMatch ? valueMatch[1] : null,
1422        modifiers: modifiers.map((i) => i.replace(".", "")),
1423        expression: value,
1424        original
1425      };
1426    };
1427  }
1428  var DEFAULT = "DEFAULT";
1429  var directiveOrder = [
1430    "ignore",
1431    "ref",
1432    "data",
1433    "id",
1434    "anchor",
1435    "bind",
1436    "init",
1437    "for",
1438    "model",
1439    "modelable",
1440    "transition",
1441    "show",
1442    "if",
1443    DEFAULT,
1444    "teleport"
1445  ];
1446  function byPriority(a, b) {
1447    let typeA = directiveOrder.indexOf(a.type) === -1 ? DEFAULT : a.type;
1448    let typeB = directiveOrder.indexOf(b.type) === -1 ? DEFAULT : b.type;
1449    return directiveOrder.indexOf(typeA) - directiveOrder.indexOf(typeB);
1450  }
1451  var tickStack = [];
1452  var isHolding = false;
1453  function nextTick(callback = () => {
1454  }) {
1455    queueMicrotask(() => {
1456      isHolding || setTimeout(() => {
1457        releaseNextTicks();
1458      });
1459    });
1460    return new Promise((res) => {
1461      tickStack.push(() => {
1462        callback();
1463        res();
1464      });
1465    });
1466  }
1467  function releaseNextTicks() {
1468    isHolding = false;

1469    while (tickStack.length)
1470      tickStack.shift()();
1471  }
1472  function holdNextTicks() {
1473    isHolding = true;
1474  }
1475  function setClasses(el, value) {
1476    if (Array.isArray(value)) {
1477      return setClassesFromString(el, value.join(" "));
1478    } else if (typeof value === "object" && value !== null) {
1479      return setClassesFromObject(el, value);
1480    } else if (typeof value === "function") {
1481      return setClasses(el, value());
1482    }
1483    return setClassesFromString(el, value);
1484  }
1485  function setClassesFromString(el, classString) {
1486    let split = (classString2) => classString2.split(" ").filter(Boolean);
1487    let missingClasses = (classString2) => classString2.split(" ").filter((i) => !el.classList.contains(i)).filter(Boolean);
1488    let addClassesAndReturnUndo = (classes) => {
1489      el.classList.add(...classes);
1490      return () => {
1491        el.classList.remove(...classes);
1492      };
1493    };
1494    classString = classString === true ? classString = "" : classString || "";
1495    return addClassesAndReturnUndo(missingClasses(classString));
1496  }
1497  function setClassesFromObject(el, classObject) {
1498    let split = (classString) => classString.split(" ").filter(Boolean);
1499    let forAdd = Object.entries(classObject).flatMap(([classString, bool]) =>

1499 bool ? split(classString) : false).filter(Boolean);
1500    let forRemove = Object.entries(classObject).flatMap(([classString, bool]) => !bool ? split(classString) : false).filter(Boolean);
1501    let added = [];
1502    let removed = [];
1503    forRemove.forEach((i) => {
1504      if (el.classList.contains(i)) {
1505        el.classList.remove(i);
1506        removed.push(i);
1507      }
1508    });
1509    forAdd.forEach((i) => {
1510      if (!el.classList.contains(i)) {
1511        el.classList.add(i);
1512        added.push(i);
1513      }
1514    });
1515    return () => {
1516      removed.forEach((i) => el.classList.add(i));
1517      added.forEach((i) => el.classList.remove(i));
1518    };
1519  }
1520  function setStyles(el, value) {
1521    if (typeof value === "object" && value !== null) {
1522      return setStylesFromObject(el, value);
1523    }
1524    return setStylesFromString(el, value);
1525  }
1526  function setStylesFromObject(el, value) {
1527    let previousStyles = {};
1528    Object.entries(value).forEach(([key, value2]) => {
1529      previousStyles[key] = el.style[key];
1530      if (!key.startsWith("--")) {
1531        key = kebabCase(key);
1532      }
1533      el.style.setProperty(key, value2);
1534    });
1535    setTimeout(() => {
1536      if (el.style.length === 0) {
1537        el.removeAttribute("style");
1538      }
1539    });
1540    return () => {
1541      setStyles(el, previousStyles);
1542    };
1543  }
1544  function setStylesFromString(el, value) {
1545    let cache = el.getAttribute("style", value);
1546    el.setAttribute("style", value);
1547    return () => {
1548      el.setAttribute("style", cache || "");
1549    };
1550  }
1551  function kebabCase(subject) {
1552    return subject.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
1553  }
1554  function once(callback, fallback2 = () => {
1555  }) {
1556    let called = false;
1557    return function() {
1558      if (!called) {
1559        called = true;
1560        callback.apply(this, arguments);
1561      } else {
1562        fallback2.apply(this, arguments);
1563      }
1564    };
1565  }
1566  directive("transition", (el, { value, modifiers, expression }, { evaluate: evaluate22 }) => {
1567    if (typeof expression === "function")
1568      expression = evaluate22(expression);
1569    if (expression === false)
1570      return;
1571    if (!expression || typeof expression === "boolean") {
1572      registerTransitionsFromHelper(el, modifiers, value);
1573    } else {
1574      registerTransitionsFromClassString(el, expression, value);
1575    }
1576  });
1577  function registerTransitionsFromClassString(el, classString, stage) {
1578    registerTransitionObject(el, setClasses, "");
1579    let directiveStorageMap = {
1580      "enter": (classes) => {
1581        el._x_transition.enter.during = classes;
1582      },
1583      "enter-start": (classes) => {
1584        el._x_transition.enter.start = classes;
1585      },
1586      "enter-end": (classes) => {
1587        el._x_transition.enter.end = classes;
1588      },
1589      "leave": (classes) => {
1590        el._x_transition.leave.during = classes;
1591      },
1592      "leave-start": (classes) => {
1593        el._x_transition.leave.start = classes;
1594      },
1595      "leave-end": (classes) => {
1596        el._x_transition.leave.end = classes;
1597      }
1598    };
1599    directiveStorageMap[stage](classString);
1600  }
1601  function registerTransitionsFromHelper(el, modifiers, stage) {
1602    registerTransitionObject(el, setStyles);
1603    let doesntSpecify = !modifiers.includes("in") && !modifiers.includes("out") && !stage;
1604    let transitioningIn = doesntSpecify || modifiers.includes("in") || ["enter"].includes(stage);
1605    let transitioningOut = doesntSpecify || modifiers.includes("out") || ["leave"].includes(stage);
1606    if (modifiers.includes("in") && !doesntSpecify) {
1607      modifiers = modifiers.filter((i, index) => index < modifiers.indexOf("out"));
1608    }
1609    if (modifiers.includes("out") && !doesntSpecify) {
1610      modifiers = modifiers.filter((i, index) => index > modifiers.indexOf("out"));
1611    }
1612    let wantsAll = !modifiers.includes("opacity") && !modifiers.includes("scale");
1613    let wantsOpacity = wantsAll || modifiers.includes("opacity");
1614    let wantsScale = wantsAll || modifiers.includes("scale");
1615    let opacityValue = wantsOpacity ? 0 : 1;
1616    let scaleValue = wantsScale ? modifierValue(modifiers, "scale", 95) / 100 : 1;
1617    let delay3 = modifierValue(modifiers, "delay", 0) / 1e3;
1618    let origin = modifierValue(modifiers, "origin", "center");
1619    let property = "opacity, transform";
1620    let durationIn = modifierValue(modifiers, "duration", 150) / 1e3;
1621    let durationOut = modifierValue(modifiers, "duration", 75) / 1e3;
1622    let easing = `cubic-bezier(0.4, 0.0, 0.2, 1)`;
1623    if (transitioningIn) {
1624      el._x_transition.enter.during = {
1625        transformOrigin: origin,
1626        transitionDelay: `${delay3}s`,
1627        transitionProperty: property,
1628        transitionDuration: `${durationIn}s`,
1629        transitionTimingFunction: easing
1630      };
1631      el._x_transition.enter.start = {
1632        opacity: opacityValue,
1633        transform: `scale(${scaleValue})`
1634      };
1635      el._x_transition.enter.end = {
1636        opacity: 1,
1637        transform: `scale(1)`
1638      };
1639    }
1640    if (transitioningOut) {
1641      el._x_transition.leave.during = {
1642        transformOrigin: origin,
1643        transitionDelay: `${delay3}s`,
1644        transitionProperty: property,
1645        transitionDuration: `${durationOut}s`,
1646        transitionTimingFunction: easing
1647      };
1648      el._x_transition.leave.start = {
1649        opacity: 1,
1650        transform: `scale(1)`
1651      };
1652      el._x_transition.leave.end = {
1653        opacity: opacityValue,
1654        transform: `scale(${scaleValue})`
1655      };
1656    }
1657  }
1658  function registerTransitionObject(el, setFunction, defaultValue = {}) {
1659    if (!el._x_transition)
1660      el._x_transition = {
1661        enter: { during: defaultValue, start: defaultValue, end: defaultValue },
1662        leave: { during: defaultValue, start: defaultValue, end: defaultValue },
1663        in(before = () => {
1664        }, after = () => {
1665        }) {
1666          transition(el, setFunction, {
1667            during: this.enter.during,
1668            start: this.enter.start,
1669            end: this.enter.end
1670          }, before, after);
1671        },
1672        out(before = () => {
1673        }, after = () => {
1674        }) {
1675          transition(el, setFunction, {
1676            during: this.leave.during,
1677            start: this.leave.start,
1678            end: this.leave.end
1679          }, before, after);
1680        }
1681      };
1682  }
1683  window.Element.prototype._x_toggleAndCascadeWithTransitions = function(el, value, show, hide) {
1684    const nextTick2 = document.visibilityState === "visible" ? requestAnimationFrame : setTimeout;
1685    let clickAwayCompatibleShow = () => nextTick2(show);
1686    if (value) {
1687      if (el._x_transition && (el._x_transition.enter || el._x_transition.leave)) {
1688        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();
1689      } else {
1690        el._x_transition ? el._x_transition.in(show) : clickAwayCompatibleShow();
1691      }
1692      return;
1693    }
1694    el._x_hidePromise = el._x_transition ? new Promise((resolve, reject) => {
1695      el._x_transition.out(() => {
1696      }, () => resolve(hide));
1697      el._x_transitioning && el._x_transitioning.beforeCancel(() => reject({ isFromCancelledTransition: true }));
1698    }) : Promise.resolve(hide);
1699    queueMicrotask(() => {
1700      let closest = closestHide(el);
1701      if (closest) {
1702        if (!closest._x_hideChildren)
1703          closest._x_hideChildren = [];
1704        closest._x_hideChildren.push(el);
1705      } else {
1706        nextTick2(() => {
1707          let hideAfterChildren = (el2) => {
1708            let carry = Promise.all([
1709              el2._x_hidePromise,
1710              ...(el2._x_hideChildren || []).map(hideAfterChildren)
1711            ]).then(([i]) => i());
1712            delete el2._x_hidePromise;
1713            delete el2._x_hideChildren;
1714            return carry;
1715          };
1716          hideAfterChildren(el).catch((e) => {
1717            if (!e.isFromCancelledTransition)
1718              throw e;
1719          });
1720        });
1721      }
1722    });
1723  };
1724  function closestHide(el) {
1725    let parent = el.parentNode;
1726    if (!parent)
1727      return;
1728    return parent._x_hidePromise ? parent : closestHide(parent);
1729  }
1730  function transition(el, setFunction, { during, start: start22, end } = {}, before = () => {
1731  }, after = () => {
1732  }) {
1733    if (el._x_transitioning)
1734      el._x_transitioning.cancel();
1735    if (Object.keys(during).length === 0 && Object.keys(start22).length === 0 && Object.keys(end).length === 0) {
1736      before();
1737      after();
1738      return;
1739    }
1740    let undoStart, undoDuring, undoEnd;
1741    performTransition(el, {
1742      start() {
1743        undoStart = setFunction(el, start22);
1744      },
1745      during() {
1746        undoDuring = setFunction(el, during);
1747      },
1748      before,
1749      end() {
1750        undoStart();
1751        undoEnd = setFunction(el, end);
1752      },
1753      after,
1754      cleanup() {
1755        undoDuring();
1756        undoEnd();
1757      }
1758    });
1759  }
1760  function performTransition(el, stages) {
1761    let interrupted, reachedBefore, reachedEnd;
1762    let finish = once(() => {
1763      mutateDom(() => {
1764        interrupted = true;
1765        if (!reachedBefore)
1766          stages.before();
1767        if (!reachedEnd) {
1768          stages.end();
1769          releaseNextTicks();
1770        }
1771        stages.after();
1772        if (el.isConnected)
1773          stages.cleanup();
1774        delete el._x_transitioning;
1775      });
1776    });
1777    el._x_transitioning = {
1778      beforeCancels: [],
1779      beforeCancel(callback) {
1780        this.beforeCancels.push(callback);
1781      },
1782      cancel: once(function() {
1783        while (this.beforeCancels.length) {
1784          this.beforeCancels.shift()();
1785        }
1786        ;
1787        finish();
1788      }),
1789      finish
1790    };
1791    mutateDom(() => {
1792      stages.start();
1793      stages.during();
1794    });
1795    holdNextTicks();
1796    requestAnimationFrame(() => {
1797      if (interrupted)
1798        return;
1799      let duration = Number(getComputedStyle(el).transitionDuration.replace(/,.*/, "").replace("s", "")) * 1e3;
1800      let delay3 = Number(getComputedStyle(el).transitionDelay.replace(/,.*/, "").replace("s", "")) * 1e3;
1801      if (duration === 0)
1802        duration = Number(getComputedStyle(el).animationDuration.replace("s", "")) * 1e3;
1803      mutateDom(() => {
1804        stages.before();
1805      });
1806      reachedBefore = true;
1807      requestAnimationFrame(() => {
1808        if (interrupted)
1809          return;
1810        mutateDom(() => {
1811          stages.end();
1812        });
1813        releaseNextTicks();
1814        setTimeout(el._x_transitioning.finish, duration + delay3);
1815        reachedEnd = true;
1816      });
1817    });
1818  }
1819  function modifierValue(modifiers, key, fallback2) {
1820    if (modifiers.indexOf(key) === -1)
1821      return fallback2;
1822    const rawValue = modifiers[modifiers.indexOf(key) + 1];
1823    if (!rawValue)
1824      return fallback2;
1825    if (key === "scale") {
1826      if (isNaN(rawValue))
1827        return fallback2;
1828    }
1829    if (key === "duration" || key === "delay") {
1830      let match = rawValue.match(/([0-9]+)ms/);
1831      if (match)
1832        return match[1];
1833    }
1834    if (key === "origin") {
1835      if (["top", "right", "left", "center", "bottom"].includes(modifiers[modifiers.indexOf(key) + 2])) {
1836        return [rawValue, modifiers[modifiers.indexOf(key) + 2]].join(" ");
1837      }
1838    }
1839    return rawValue;
1840  }
1841  var isCloning = false;
1842  function skipDuringClone(callback, fallback2 = () => {
1843  }) {
1844    return (...args) => isCloning ? fallback2(...args) : callback(...args);
1845  }
1846  function onlyDuringClone(callback) {
1847    return (...args) => isCloning && callback(...args);
1848  }
1849  var interceptors = [];
1850  function interceptClone(callback) {
1851    interceptors.push(callback);
1852  }
1853  function cloneNode(from, to) {
1854    interceptors.forEach((i) => i(from, to));
1855    isCloning = true;
1856    dontRegisterReactiveSideEffects(() => {
1857      initTree(to, (el, callback) => {
1858        callback(el, () => {
1859        });
1860      });
1861    });
1862    isCloning = false;
1863  }
1864  var isCloningLegacy = false;
1865  function clone(oldEl, newEl) {
1866    if (!newEl._x_dataStack)
1867      newEl._x_dataStack = oldEl._x_dataStack;
1868    isCloning = true;
1869    isCloningLegacy = true;
1870    dontRegisterReactiveSideEffects(() => {
1871      cloneTree(newEl);
1872    });
1873    isCloning = false;
1874    isCloningLegacy = false;
1875  }
1876  function cloneTree(el) {
1877    let hasRunThroughFirstEl = false;
1878    let shallowWalker = (el2, callback) => {
1879      walk(el2, (el3, skip) => {
1880        if (hasRunThroughFirstEl && isRoot(el3))
1881          return skip();
1882        hasRunThroughFirstEl = true;
1883        callback(el3, skip);
1884      });
1885    };
1886    initTree(el, shallowWalker);
1887  }
1888  function dontRegisterReactiveSideEffects(callback) {

1889    let cache = effect;
1890    overrideEffect((callback2, el) => {
1891      let storedEffect = cache(callback2);
1892      release(storedEffect);
1893      return () => {
1894      };
1895    });
1896    callback();
1897    overrideEffect(cache);
1898  }
1899  function bind(el, name, value, modifiers = []) {
1900    if (!el._x_bindings)
1901      el._x_bindings = reactive({});
1902    el._x_bindings[name] = value;
1903    name = modifiers.includes("camel") ? camelCase(name) : name;
1904    switch (name) {
1905      case "value":
1906        bindInputValue(el, value);
1907        break;
1908      case "style":
1909        bindStyles(el, value);
1910        break;
1911      case "class":
1912        bindClasses(el, value);
1913        break;
1914      case "selected":
1915      case "checked":
1916        bindAttributeAndProperty(el, name, value);
1917        break;
1918      default:
1919        bindAttribute(el, name, value);
1920        break;
1921    }
1922  }
1923  function bindInputValue(el, value) {
1924    if (el.type === "radio") {
1925      if (el.attributes.value === void 0) {
1926        el.value = value;
1927      }
1928      if (window.fromModel) {
1929        if (typeof value === "boolean") {
1930          el.checked = safeParseBoolean(el.value) === value;
1931        } else {
1932          el.checked = checkedAttrLooseCompare(el.value, value);
1933        }
1934      }
1935    } else if (el.type === "checkbox") {
1936      if (Number.isInteger(value)) {
1937        el.value = value;
1938      } else if (!Array.isArray(value) && typeof value !== "boolean" && ![null, void 0].includes(value)) {

1939        el.value = String(value);
1940      } else {
1941        if (Array.isArray(value)) {
1942          el.checked = value.some((val) => checkedAttrLooseCompare(val, el.value));
1943        } else {
1944          el.checked = !!value;
1945        }
1946      }
1947    } else if (el.tagName === "SELECT") {
1948      updateSelect(el, value);
1949    } else {
1950      if (el.value === value)
1951        return;
1952      el.value = value === void 0 ? "" : value;
1953    }
1954  }
1955  function bindClasses(el, value) {
1956    if (el._x_undoAddedClasses)
1957      el._x_undoAddedClasses();
1958    el._x_undoAddedClasses = setClasses(el, value);
1959  }
1960  function bindStyles(el, value) {
1961    if (el._x_undoAddedStyles)
1962      el._x_undoAddedStyles();
1963    el._x_undoAddedStyles = setStyles(el, value);
1964  }
1965  function bindAttributeAndProperty(el, name, value) {
1966    bindAttribute(el, name, value);
1967    setPropertyIfChanged(el, name, value);
1968  }
1969  function bindAttribute(el, name, value) {
1970    if ([null, void 0, false].includes(value) && attributeShouldntBePreservedIfFalsy(name)) {
1971      el.removeAttribute(name);
1972    } else {
1973      if (isBooleanAttr(name))
1974        value = name;
1975      setIfChanged(el, name, value);
1976    }
1977  }
1978  function setIfChanged(el, attrName, value) {
1979    if (el.getAttribute(attrName) != value) {
1980      el.setAttribute(attrName, value);
1981    }
1982  }
1983  function setPropertyIfChanged(el, propName, value) {
1984    if (el[propName] !== value) {
1985      el[propName] = value;
1986    }
1987  }
1988  function updateSelect(el, value) {
1989    const arrayWrappedValue = [].concat(value).map((value2) => {
1990      return value2 + "";
1991    });
1992    Array.from(el.options).forEach((option) => {
1993      option.selected = arrayWrappedValue.includes(option.value);
1994    });
1995  }
1996  function camelCase(subject) {
1997    return subject.toLowerCase().replace(/-(\w)/g, (match, char) => char.toUpperCase());
1998  }
1999  function checkedAttrLooseCompare(valueA, valueB) {
2000    return valueA == valueB;
2001  }
2002  function safeParseBoolean(rawValue) {
2003    if ([1, "1", "true", "on", "yes", true].includes(rawValue)) {
2004      return true;
2005    }
2006    if ([0, "0", "false", "off", "no", false].includes(rawValue)) {
2007      return false;
2008    }
2009    return rawValue ? Boolean(rawValue) : null;
2010  }
2011  function isBooleanAttr(attrName) {
2012    const booleanAttributes = [
2013      "disabled",
2014      "checked",
2015      "required",
2016      "readonly",
2017      "hidden",
2018      "open",
2019      "selected",
2020      "autofocus",
2021      "itemscope",
2022      "multiple",
2023      "novalidate",
2024      "allowfullscreen",
2025      "allowpaymentrequest",
2026      "formnovalidate",
2027      "autoplay",
2028      "controls",
2029      "loop",
2030      "muted",
2031      "playsinline",
2032      "default",
2033      "ismap",
2034      "reversed",
2035      "async",
2036      "defer",
2037      "nomodule"
2038    ];
2039    return booleanAttributes.includes(attrName);
2040  }
2041  function attributeShouldntBePreservedIfFalsy(name) {
2042    return !["aria-pressed", "aria-checked", "aria-expanded", "aria-selected"].includes(name);
2043  }
2044  function getBinding(el, name, fallback2) {
2045    if (el._x_bindings && el._x_bindings[name] !== void 0)
2046      return el._x_bindings[name];
2047    return getAttributeBinding(el, name, fallback2);
2048  }
2049  function extractProp(el, name, fallback2, extract = true) {
2050    if (el._x_bindings && el._x_bindings[name] !== void 0)
2051      return el._x_bindings[name];
2052    if (el._x_inlineBindings && el._x_inlineBindings[name] !== void 0) {
2053      let binding = el._x_inlineBindings[name];
2054      binding.extract = extract;
2055      return dontAutoEvaluateFunctions(() => {
2056        return evaluate(el, binding.expression);
2057      });
2058    }
2059    return getAttributeBinding(el, name, fallback2);
2060  }
2061  function getAttributeBinding(el, name, fallback2) {
2062    let attr = el.getAttribute(name);
2063    if (attr === null)
2064      return typeof fallback2 === "function" ? fallback2() : fallback2;
2065    if (attr === "")
2066      return true;
2067    if (isBooleanAttr(name)) {
2068      return !![name, "true"].includes(attr);
2069    }
2070    return attr;
2071  }
2072  function debounce(func, wait) {
2073    var timeout;
2074    return function() {
2075      var context = this, args = arguments;
2076      var later = function() {
2077        timeout = null;

2078        func.apply(context, args);
2079      };
2080      clearTimeout(timeout);
2081      timeout = setTimeout(later, wait);
2082    };
2083  }
2084  function throttle(func, limit) {
2085    let inThrottle;
2086    return function() {
2087      let context = this, args = arguments;
2088      if (!inThrottle) {
2089        func.apply(context, args);
2090        inThrottle = true;
2091        setTimeout(() => inThrottle = false, limit);
2092      }
2093    };
2094  }
2095  function entangle({ get: outerGet, set: outerSet }, { get: innerGet, set: innerSet }) {
2096    let firstRun = true;
2097    let outerHash;
2098    let innerHash;
2099    let reference = effect(() => {
2100      let outer = outerGet();
2101      let inner = innerGet();
2102      if (firstRun) {
2103        innerSet(cloneIfObject(outer));
2104        firstRun = false;
2105      } else {
2106        let outerHashLatest = JSON.stringify(outer);
2107        let innerHashLatest = JSON.stringify(inner);
2108        if (outerHashLatest !== outerHash) {
2109          innerSet(cloneIfObject(outer));
2110        } else if (outerHashLatest !== innerHashLatest) {
2111          outerSet(cloneIfObject(inner));
2112        } else {
2113        }
2114      }
2115      outerHash = JSON.stringify(outerGet());
2116      innerHash = JSON.stringify(innerGet());
2117    });
2118    return () => {
2119      release(reference);
2120    };
2121  }
2122  function cloneIfObject(value) {
2123    return typeof value === "object" ? JSON.parse(JSON.stringify(value)) : value;
2124  }
2125  function plugin(callback) {

2126    let callbacks = Array.isArray(callback) ? callback : [callback];
2127    callbacks.forEach((i) => i(alpine_default));
2128  }
2129  var stores = {};
2130  var isReactive = false;
2131  function store(name, value) {
2132    if (!isReactive) {
2133      stores = reactive(stores);
2134      isReactive = true;
2135    }
2136    if (value === void 0) {
2137      return stores[name];
2138    }
2139    stores[name] = value;
2140    if (typeof value === "object" && value !== null && value.hasOwnProperty("init") && typeof value.init === "function") {
2141      stores[name].init();
2142    }
2143    initInterceptors2(stores[name]);
2144  }
2145  function getStores() {
2146    return stores;
2147  }
2148  var binds = {};
2149  function bind2(name, bindings) {
2150    let getBindings = typeof bindings !== "function" ? () => bindings : bindings;
2151    if (name instanceof Element) {
2152      return applyBindingsObject(name, getBindings());
2153    } else {
2154      binds[name] = getBindings;
2155    }
2156    return () => {
2157    };
2158  }
2159  function injectBindingProviders(obj) {
2160    Object.entries(binds).forEach(([name, callback]) => {
2161      Object.defineProperty(obj, name, {
2162        get() {
2163          return (...args) => {
2164            return callback(...args);
2165          };
2166        }
2167      });
2168    });
2169    return obj;
2170  }
2171  function applyBindingsObject(el, obj, original) {
2172    let cleanupRunners = [];
2173    while (cleanupRunners.length)
2174      cleanupRunners.pop()();
2175    let attributes = Object.entries(obj).map(([name, value]) => ({ name, value }));
2176    let staticAttributes = attributesOnly(attributes);
2177    attributes = attributes.map((attribute) => {
2178      if (staticAttributes.find((attr) => attr.name === attribute.name)) {
2179        return {
2180          name: `x-bind:${attribute.name}`,
2181          value: `"${attribute.value}"`
2182        };
2183      }
2184      return attribute;
2185    });
2186    directives(el, attributes, original).map((handle) => {
2187      cleanupRunners.push(handle.runCleanups);
2188      handle();
2189    });
2190    return () => {
2191      while (cleanupRunners.length)
2192        cleanupRunners.pop()();
2193    };
2194  }
2195  var datas = {};
2196  function data(name, callback) {
2197    datas[name] = callback;
2198  }
2199  function injectDataProviders(obj, context) {
2200    Object.entries(datas).forEach(([name, callback]) => {
2201      Object.defineProperty(obj, name, {
2202        get() {
2203          return (...args) => {
2204            return callback.bind(context)(...args);
2205          };
2206        },
2207        enumerable: false
2208      });
2209    });
2210    return obj;
2211  }
2212  var Alpine2 = {
2213    get reactive() {
2214      return reactive;
2215    },
2216    get release() {
2217      return release;
2218    },
2219    get effect() {
2220      return effect;
2221    },
2222    get raw() {
2223      return raw;
2224    },
2225    version: "3.13.7",
2226    flushAndStopDeferringMutations,
2227    dontAutoEvaluateFunctions,
2228    disableEffectScheduling,
2229    startObservingMutations,
2230    stopObservingMutations,
2231    setReactivityEngine,
2232    onAttributeRemoved,
2233    onAttributesAdded,
2234    closestDataStack,
2235    skipDuringClone,
2236    onlyDuringClone,
2237    addRootSelector,
2238    addInitSelector,
2239    interceptClone,
2240    addScopeToNode,
2241    deferMutations,
2242    mapAttributes,
2243    evaluateLater,
2244    interceptInit,
2245    setEvaluator,
2246    mergeProxies,
2247    extractProp,
2248    findClosest,
2249    onElRemoved,
2250    closestRoot,
2251    destroyTree,
2252    interceptor,
2253    transition,
2254    setStyles,
2255    mutateDom,
2256    directive,
2257    entangle,
2258    throttle,
2259    debounce,
2260    evaluate,
2261    initTree,
2262    nextTick,
2263    prefixed: prefix,
2264    prefix: setPrefix,
2265    plugin,
2266    magic,
2267    store,
2268    start,
2269    clone,
2270    cloneNode,
2271    bound: getBinding,
2272    $data: scope,
2273    watch,
2274    walk,
2275    data,
2276    bind: bind2
2277  };
2278  var alpine_default = Alpine2;
2279  function makeMap(str, expectsLowerCase) {
2280    const map = /* @__PURE__ */ Object.create(null);
2281    const list = str.split(",");
2282    for (let i = 0; i < list.length; i++) {
2283      map[list[i]] = true;
2284    }
2285    return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];
2286  }
2287  var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
2288  var isBooleanAttr2 = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,loop,open,required,reversed,scoped,seamless,

2288checked,muted,multiple,selected`);
2289  var EMPTY_OBJ = true ? Object.freeze({}) : {};
2290  var EMPTY_ARR = true ? Object.freeze([]) : [];
2291  var hasOwnProperty = Object.prototype.hasOwnProperty;
2292  var hasOwn = (val, key) => hasOwnProperty.call(val, key);
2293  var isArray2 = Array.isArray;
2294  var isMap = (val) => toTypeString(val) === "[object Map]";
2295  var isString = (val) => typeof val === "string";
2296  var isSymbol = (val) => typeof val === "symbol";
2297  var isObject2 = (val) => val !== null && typeof val === "object";
2298  var objectToString = Object.prototype.toString;
2299  var toTypeString = (value) => objectToString.call(value);
2300  var toRawType = (value) => {
2301    return toTypeString(value).slice(8, -1);
2302  };
2303  var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
2304  var cacheStringFunction = (fn) => {
2305    const cache = /* @__PURE__ */ Object.create(null);
2306    return (str) => {
2307      const hit = cache[str];
2308      return hit || (cache[str] = fn(str));
2309    };
2310  };
2311  var camelizeRE = /-(\w)/g;
2312  var camelize = cacheStringFunction((str) => {
2313    return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
2314  });
2315  var hyphenateRE = /\B([A-Z])/g;
2316  var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
2317  var capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
2318  var toHandlerKey = cacheStringFunction((str) => str ? `on${capitalize(str)}` : ``);
2319  var hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);
2320  var targetMap = /* @__PURE__ */ new WeakMap();
2321  var effectStack = [];
2322  var activeEffect;
2323  var ITERATE_KEY = Symbol(true ? "iterate" : "");
2324  var MAP_KEY_ITERATE_KEY = Symbol(true ? "Map key iterate" : "");
2325  function isEffect(fn) {
2326    return fn && fn._isEffect === true;
2327  }
2328  function effect2(fn, options = EMPTY_OBJ) {
2329    if (isEffect(fn)) {
2330      fn = fn.raw;
2331    }
2332    const effect3 = createReactiveEffect(fn, options);
2333    if (!options.lazy) {
2334      effect3();
2335    }
2336    return effect3;
2337  }
2338  function stop(effect3) {
2339    if (effect3.active) {
2340      cleanup(effect3);
2341      if (effect3.options.onStop) {
2342        effect3.options.onStop();
2343      }
2344      effect3.active = false;
2345    }
2346  }
2347  var uid = 0;
2348  function createReactiveEffect(fn, options) {
2349    const effect3 = function reactiveEffect() {
2350      if (!effect3.active) {
2351        return fn();
2352      }
2353      if (!effectStack.includes(effect3)) {
2354        cleanup(effect3);
2355        try {
2356          enableTracking();
2357          effectStack.push(effect3);
2358          activeEffect = effect3;
2359          return fn();
2360        } finally {
2361          effectStack.pop();
2362          resetTracking();
2363          activeEffect = effectStack[effectStack.length - 1];
2364        }
2365      }
2366    };
2367    effect3.id = uid++;
2368    effect3.allowRecurse = !!options.allowRecurse;
2369    effect3._isEffect = true;
2370    effect3.active = true;
2371    effect3.raw = fn;
2372    effect3.deps = [];
2373    effect3.options = options;
2374    return effect3;
2375  }
2376  function cleanup(effect3) {
2377    const { deps } = effect3;
2378    if (deps.length) {
2379      for (let i = 0; i < deps.length; i++) {
2380        deps[i].delete(effect3);
2381      }
2382      deps.length = 0;
2383    }
2384  }
2385  var shouldTrack = true;
2386  var trackStack = [];
2387  function pauseTracking() {
2388    trackStack.push(shouldTrack);
2389    shouldTrack = false;
2390  }
2391  function enableTracking() {
2392    trackStack.push(shouldTrack);
2393    shouldTrack = true;
2394  }
2395  function resetTracking() {
2396    const last = trackStack.pop();
2397    shouldTrack = last === void 0 ? true : last;
2398  }
2399  function track(target, type, key) {
2400    if (!shouldTrack || activeEffect === void 0) {
2401      return;
2402    }
2403    let depsMap = targetMap.get(target);
2404    if (!depsMap) {
2405      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
2406    }
2407    let dep = depsMap.get(key);
2408    if (!dep) {
2409      depsMap.set(key, dep = /* @__PURE__ */ new Set());
2410    }
2411    if (!dep.has(activeEffect)) {
2412      dep.add(activeEffect);
2413      activeEffect.deps.push(dep);
2414      if (activeEffect.options.onTrack) {
2415        activeEffect.options.onTrack({
2416          effect: activeEffect,
2417          target,
2418          type,
2419          key
2420        });
2421      }
2422    }
2423  }
2424  function trigger(target, type, key, newValue, oldValue, oldTarget) {
2425    const depsMap = targetMap.get(target);
2426    if (!depsMap) {
2427      return;
2428    }
2429    const effects = /* @__PURE__ */ new Set();
2430    const add2 = (effectsToAdd) => {
2431      if (effectsToAdd) {

2432        effectsToAdd.forEach((effect3) => {
2433          if (effect3 !== activeEffect || effect3.allowRecurse) {
2434            effects.add(effect3);
2435          }
2436        });
2437      }
2438    };
2439    if (type === "clear") {
2440      depsMap.forEach(add2);
2441    } else if (key === "length" && isArray2(target)) {
2442      depsMap.forEach((dep, key2) => {
2443        if (key2 === "length" || key2 >= newValue) {
2444          add2(dep);
2445        }
2446      });
2447    } else {
2448      if (key !== void 0) {
2449        add2(depsMap.get(key));
2450      }
2451      switch (type) {
2452        case "add":
2453          if (!isArray2(target)) {
2454            add2(depsMap.get(ITERATE_KEY));
2455            if (isMap(target)) {
2456              add2(depsMap.get(MAP_KEY_ITERATE_KEY));
2457            }
2458          } else if (isIntegerKey(key)) {
2459            add2(depsMap.get("length"));
2460          }
2461          break;
2462        case "delete":
2463          if (!isArray2(target)) {
2464            add2(depsMap.get(ITERATE_KEY));
2465            if (isMap(target)) {
2466              add2(depsMap.get(MAP_KEY_ITERATE_KEY));
2467            }
2468          }
2469          break;
2470        case "set":
2471          if (isMap(target)) {
2472            add2(depsMap.get(ITERATE_KEY));
2473          }
2474          break;
2475      }
2476    }
2477    const run = (effect3) => {
2478      if (effect3.options.onTrigger) {
2479        effect3.options.onTrigger({
2480          effect: effect3,
2481          target,
2482          key,
2483          type,
2484          newValue,
2485          oldValue,
2486          oldTarget
2487        });
2488      }
2489      if (effect3.options.scheduler) {
2490        effect3.options.scheduler(effect3);
2491      } else {
2492        effect3();
2493      }
2494    };
2495    effects.forEach(run);
2496  }
2497  var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
2498  var builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map((key) => Symbol[key]).filter(isSymbol));
2499  var get2 = /* @__PURE__ */ createGetter();
2500  var readonlyGet = /* @__PURE__ */ createGetter(true);
2501  var arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
2502  function createArrayInstrumentations() {
2503    const instrumentations = {};
2504    ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
2505      instrumentations[key] = function(...args) {
2506        const arr = toRaw(this);
2507        for (let i = 0, l = this.length; i < l; i++) {
2508          track(arr, "get", i + "");
2509        }
2510        const res = arr[key](...args);
2511        if (res === -1 || res === false) {
2512          return arr[key](...args.map(toRaw));
2513        } else {
2514          return res;
2515        }
2516      };
2517    });
2518    ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
2519      instrumentations[key] = function(...args) {
2520        pauseTracking();
2521        const res = toRaw(this)[key].apply(this, args);
2522        resetTracking();
2523        return res;
2524      };
2525    });
2526    return instrumentations;
2527  }
2528  function createGetter(isReadonly = false, shallow = false) {
2529    return function get3(target, key, receiver) {
2530      if (key === "__v_isReactive") {
2531        return !isReadonly;
2532      } else if (key === "__v_isReadonly") {
2533        return isReadonly;
2534      } else if (key === "__v_raw" && receiver === (isReadonly ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
2535        return target;
2536      }
2537      const targetIsArray = isArray2(target);
2538      if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
2539        return Reflect.get(arrayInstrumentations, key, receiver);
2540      }
2541      const res = Reflect.get(target, key, receiver);
2542      if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
2543        return res;
2544      }
2545      if (!isReadonly) {
2546        track(target, "get", key);
2547      }
2548      if (shallow) {
2549        return res;
2550      }
2551      if (isRef(res)) {
2552        const shouldUnwrap = !targetIsArray || !isIntegerKey(key);
2553        return shouldUnwrap ? res.value : res;
2554      }
2555      if (isObject2(res)) {
2556        return isReadonly ? readonly(res) : reactive2(res);
2557      }
2558      return res;
2559    };
2560  }
2561  var set2 = /* @__PURE__ */ createSetter();
2562  function createSetter(shallow = false) {
2563    return function set3(target, key, value, receiver) {
2564      let oldValue = target[key];
2565      if (!shallow) {
2566        value = toRaw(value);
2567        oldValue = toRaw(oldValue);
2568        if (!isArray2(target) && isRef(oldValue) && !isRef(value)) {
2569          oldValue.value = value;
2570          return true;
2571        }
2572      }
2573      const hadKey = isArray2(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
2574      const result = Reflect.set(target, key, value, receiver);
2575      if (target === toRaw(receiver)) {
2576        if (!hadKey) {
2577          trigger(target, "add", key, value);
2578        } else if (hasChanged(value, oldValue)) {
2579          trigger(target, "set", key, value, oldValue);
2580        }
2581      }
2582      return result;
2583    };
2584  }
2585  function deleteProperty(target, key) {
2586    const hadKey = hasOwn(target, key);
2587    const oldValue = target[key];
2588    const result = Reflect.deleteProperty(target, key);
2589    if (result && hadKey) {
2590      trigger(target, "delete", key, void 0, oldValue);
2591    }
2592    return result;
2593  }
2594  function has(target, key) {
2595    const result = Reflect.has(target, key);

2596    if (!isSymbol(key) || !builtInSymbols.has(key)) {
2597      track(target, "has", key);
2598    }
2599    return result;
2600  }
2601  function ownKeys(target) {
2602    track(target, "iterate", isArray2(target) ? "length" : ITERATE_KEY);
2603    return Reflect.ownKeys(target);
2604  }
2605  var mutableHandlers = {
2606    get: get2,
2607    set: set2,
2608    deleteProperty,
2609    has,
2610    ownKeys
2611  };
2612  var readonlyHandlers = {
2613    get: readonlyGet,
2614    set(target, key) {
2615      if (true) {
2616        console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
2617      }
2618      return true;
2619    },
2620    deleteProperty(target, key) {
2621      if (true) {
2622        console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
2623      }
2624      return true;
2625    }
2626  };
2627  var toReactive = (value) => isObject2(value) ? reactive2(value) : value;
2628  var toReadonly = (value) => isObject2(value) ? readonly(value) : value;
2629  var toShallow = (value) => value;
2630  var getProto = (v) => Reflect.getPrototypeOf(v);
2631  function get$1(target, key, isReadonly = false, isShallow = false) {
2632    target = target["__v_raw"];
2633    const rawTarget = toRaw(target);
2634    const rawKey = toRaw(key);
2635    if (key !== rawKey) {
2636      !isReadonly && track(rawTarget, "get", key);
2637    }
2638    !isReadonly && track(rawTarget, "get", rawKey);
2639    const { has: has2 } = getProto(rawTarget);
2640    const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
2641    if (has2.call(rawTarget, key)) {
2642      return wrap(target.get(key));
2643    } else if (has2.call(rawTarget, rawKey)) {
2644      return wrap(target.get(rawKey));
2645    } else if (target !== rawTarget) {
2646      target.get(key);
2647    }
2648  }
2649  function has$1(key, isReadonly = false) {
2650    const target = this["__v_raw"];
2651    const rawTarget = toRaw(target);
2652    const rawKey = toRaw(key);
2653    if (key !== rawKey) {
2654      !isReadonly && track(rawTarget, "has", key);
2655    }
2656    !isReadonly && track(rawTarget, "has", rawKey);
2657    return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
2658  }
2659  function size(target, isReadonly = false) {
2660    target = target["__v_raw"];
2661    !isReadonly && track(toRaw(target), "iterate", ITERATE_KEY);
2662    return Reflect.get(target, "size", target);
2663  }
2664  function add(value) {
2665    value = toRaw(value);
2666    const target = toRaw(this);
2667    const proto = getProto(target);
2668    const hadKey = proto.has.call(target, value);
2669    if (!hadKey) {
2670      target.add(value);
2671      trigger(target, "add", value, value);
2672    }
2673    return this;
2674  }
2675  function set$1(key, value) {
2676    value = toRaw(value);
2677    const target = toRaw(this);
2678    const { has: has2, get: get3 } = getProto(target);
2679    let hadKey = has2.call(target, key);
2680    if (!hadKey) {
2681      key = toRaw(key);
2682      hadKey = has2.call(target, key);
2683    } else if (true) {
2684      checkIdentityKeys(target, has2, key);
2685    }
2686    const oldValue = get3.call(target, key);
2687    target.set(key, value);
2688    if (!hadKey) {
2689      trigger(target, "add", key, value);
2690    } else if (hasChanged(value, oldValue)) {
2691      trigger(target, "set", key, value, oldValue);
2692    }
2693    return this;
2694  }
2695  function deleteEntry(key) {
2696    const target = toRaw(this);
2697    const { has: has2, get: get3 } = getProto(target);
2698    let hadKey = has2.call(target, key);
2699    if (!hadKey) {
2700      key = toRaw(key);
2701      hadKey = has2.call(target, key);
2702    } else if (true) {
2703      checkIdentityKeys(target, has2, key);
2704    }
2705    const oldValue = get3 ? get3.call(target, key) : void 0;
2706    const result = target.delete(key);
2707    if (hadKey) {
2708      trigger(target, "delete", key, void 0, oldValue);
2709    }
2710    return result;
2711  }
2712  function clear() {
2713    const target = toRaw(this);
2714    const hadItems = target.size !== 0;
2715    const oldTarget = true ? isMap(target) ? new Map(target) : new Set(target) : void 0;
2716    const result = target.clear();
2717    if (hadItems) {
2718      trigger(target, "clear", void 0, void 0, oldTarget);
2719    }
2720    return result;
2721  }
2722  function createForEach(isReadonly, isShallow) {
2723    return function forEach(callback, thisArg) {
2724      const observed = this;
2725      const target = observed["__v_raw"];
2726      const rawTarget = toRaw(target);
2727      const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
2728      !isReadonly && track(rawTarget, "iterate", ITERATE_KEY);
2729      return target.forEach((value, key) => {
2730        return callback.call(thisArg, wrap(value), wrap(key), observed);
2731      });
2732    };
2733  }
2734  function createIterableMethod(method, isReadonly, isShallow) {
2735    return function(...args) {
2736      const target = this["__v_raw"];
2737      const rawTarget = toRaw(target);
2738      const targetIsMap = isMap(rawTarget);
2739      const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
2740      const isKeyOnly = method === "keys" && targetIsMap;
2741      const innerIterator = target[method](...args);
2742      const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
2743      !isReadonly && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
2744      return {
2745        next() {
2746          const { value, done } = innerIterator.next();
2747          return done ? { value, done } : {
2748            value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),