https://ctpd.org.zm/livewire/livewire.js?id=6d832aed

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  

724// node_modules/alpinejs/dist/module.esm.js
725  var flushPending = false;
726  var flushing = false;
727  var queue = [];
728  var lastFlushedIndex = -1;
729  var transactionActive = false;
730  function scheduler(callback) {
731    queueJob(callback);
732  }
733  function startTransaction() {
734    transactionActive = true;
735  }
736  function commitTransaction() {
737    transactionActive = false;
738    queueFlush();
739  }
740  function queueJob(job) {
741    if (!queue.includes(job))
742      queue.push(job);
743    queueFlush();
744  }
745  function dequeueJob(job) {
746    let index = queue.indexOf(job);
747    if (index !== -1 && index > lastFlushedIndex)
748      queue.splice(index, 1);
749  }
750  function queueFlush() {
751    if (!flushing && !flushPending) {
752      if (transactionActive)
753        return;
754      flushPending = true;
755      queueMicrotask(flushJobs);
756    }
757  }
758  function flushJobs() {
759    flushPending = false;
760    flushing = true;
761    for (let i = 0; i < queue.length; i++) {
762      queue[i]();
763      lastFlushedIndex = i;
764    }
765    queue.length = 0;
766    lastFlushedIndex = -1;
767    flushing = false;
768  }
769  var reactive;
770  var effect;
771  var release;
772  var raw;
773  var shouldSchedule = true;
774  function disableEffectScheduling(callback) {
775    shouldSchedule = false;
776    callback();
777    shouldSchedule = true;
778  }
779  function setReactivityEngine(engine) {
780    reactive = engine.reactive;
781    release = engine.release;
782    effect = (callback) => engine.effect(callback, { scheduler: (task) => {
783      if (shouldSchedule) {
784        scheduler(task);
785      } else {
786        task();
787      }
788    } });
789    raw = engine.raw;
790  }
791  function overrideEffect(override) {
792    effect = override;
793  }
794  function elementBoundEffect(el) {
795    let cleanup2 = () => {
796    };
797    let wrappedEffect = (callback) => {
798      let effectReference = effect(callback);
799      if (!el._x_effects) {
800        el._x_effects = /* @__PURE__ */ new Set();
801        el._x_runEffects = () => {
802          el._x_effects.forEach((i) => i());
803        };
804      }
805      el._x_effects.add(effectReference);
806      cleanup2 = () => {
807        if (effectReference === void 0)
808          return;
809        el._x_effects.delete(effectReference);
810        release(effectReference);
811      };
812      return effectReference;
813    };
814    return [wrappedEffect, () => {
815      cleanup2();
816    }];
817  }
818  function watch(getter, callback) {
819    let firstTime = true;
820    let oldValue;
821    let oldValueJSON;
822    let effectReference = effect(() => {
823      let value = getter();
824      let newJSON = JSON.stringify(value);
825      if (!firstTime) {
826        if (typeof value === "object" || value !== oldValue) {
827          let previousValue = typeof oldValue === "object" ? JSON.parse(oldValueJSON) : oldValue;
828          queueMicrotask(() => {
829            callback(value, previousValue);
830          });
831        }
832      }
833      oldValue = value;
834      oldValueJSON = newJSON;
835      firstTime = false;
836    });
837    return () => release(effectReference);
838  }
839  async function transaction(callback) {
840    startTransaction();
841    try {
842      await callback();
843      await Promise.resolve();
844    } finally {
845      commitTransaction();
846    }
847  }
848  var onAttributeAddeds = [];
849  var onElRemoveds = [];
850  var onElAddeds = [];
851  function onElAdded(callback) {
852    onElAddeds.push(callback);
853  }
854  function onElRemoved(el, callback) {
855    if (typeof callback === "function") {
856      if (!el._x_cleanups)
857        el._x_cleanups = [];
858      el._x_cleanups.push(callback);
859    } else {
860      callback = el;
861      onElRemoveds.push(callback);
862    }
863  }
864  function onAttributesAdded(callback) {
865    onAttributeAddeds.push(callback);
866  }
867  function onAttributeRemoved(el, name, callback) {
868    if (!el._x_attributeCleanups)
869      el._x_attributeCleanups = {};
870    if (!el._x_attributeCleanups[name])
871      el._x_attributeCleanups[name] = [];
872    el._x_attributeCleanups[name].push(callback);
873  }
874  function cleanupAttributes(el, names) {
875    if (!el._x_attributeCleanups)
876      return;
877    Object.entries(el._x_attributeCleanups).forEach(([name, value]) => {
878      if (names === void 0 || names.includes(name)) {
879        value.forEach((i) => i());
880        delete el._x_attributeCleanups[name];
881      }
882    });
883  }
884  function cleanupElement(el) {
885    el._x_effects?.forEach(dequeueJob);
886    while (el._x_cleanups?.length)
887      el._x_cleanups.pop()();
888  }
889  var observer = new MutationObserver(onMutate);
890  var currentlyObserving = false;
891  function startObservingMutations() {
892    observer.observe(document, { subtree: true, childList: true, attributes: true, attributeOldValue: true });
893    currentlyObserving = true;
894  }
895  function stopObservingMutations() {
896    flushObserver();
897    observer.disconnect();
898    currentlyObserving = false;
899  }
900  var queuedMutations = [];
901  function flushObserver() {
902    let records = observer.takeRecords();
903    queuedMutations.push(() => records.length > 0 && onMutate(records));
904    let queueLengthWhenTriggered = queuedMutations.length;
905    queueMicrotask(() => {
906      if (queuedMutations.length === queueLengthWhenTriggered) {
907        while (queuedMutations.length > 0)
908          queuedMutations.shift()();
909      }
910    });
911  }
912  function mutateDom(callback) {
913    if (!currentlyObserving)
914      return callback();
915    stopObservingMutations();
916    let result = callback();
917    startObservingMutations();
918    return result;
919  }
920  var isCollecting = false;
921  var deferredMutations = [];
922  function deferMutations() {
923    isCollecting = true;
924  }
925  function flushAndStopDeferringMutations() {
926    isCollecting = false;
927    onMutate(deferredMutations);
928    deferredMutations = [];
929  }
930  function onMutate(mutations) {
931    if (isCollecting) {
932      deferredMutations = deferredMutations.concat(mutations);
933      return;
934    }
935    let addedNodes = [];
936    let removedNodes = /* @__PURE__ */ new Set();
937    let addedAttributes = /* @__PURE__ */ new Map();
938    let removedAttributes = /* @__PURE__ */ new Map();
939    for (let i = 0; i < mutations.length; i++) {
940      if (mutations[i].target._x_ignoreMutationObserver)
941        continue;
942      if (mutations[i].type === "childList") {
943        mutations[i].removedNodes.forEach((node) => {
944          if (node.nodeType !== 1)
945            return;
946          if (!node._x_marker)
947            return;
948          removedNodes.add(node);
949        });
950        mutations[i].addedNodes.forEach((node) => {
951          if (node.nodeType !== 1)
952            return;
953          if (removedNodes.has(node)) {
954            removedNodes.delete(node);
955            return;
956          }
957          if (node._x_marker)
958            return;
959          addedNodes.push(node);
960        });
961      }
962      if (mutations[i].type === "attributes") {
963        let el = mutations[i].target;
964        let name = mutations[i].attributeName;
965        let oldValue = mutations[i].oldValue;
966        let add2 = () => {
967          if (!addedAttributes.has(el))
968            addedAttributes.set(el, []);
969          addedAttributes.get(el).push({ name, value: el.getAttribute(name) });
970        };
971        let remove = () => {
972          if (!removedAttributes.has(el))
973            removedAttributes.set(el, []);
974          removedAttributes.get(el).push(name);
975        };
976        if (el.hasAttribute(name) && oldValue === null) {
977          add2();
978        } else if (el.hasAttribute(name)) {
979          remove();
980          add2();
981        } else {
982          remove();
983        }
984      }
985    }
986    removedAttributes.forEach((attrs, el) => {
987      cleanupAttributes(el, attrs);
988    });
989    addedAttributes.forEach((attrs, el) => {
990      onAttributeAddeds.forEach((i) => i(el, attrs));
991    });
992    for (let node of removedNodes) {
993      if (addedNodes.some((i) => i.contains(node)))
994        continue;
995      onElRemoveds.forEach((i) => i(node));
996    }
997    for (let node of addedNodes) {
998      if (!node.isConnected)
999        continue;
1000      onElAddeds.forEach((i) => i(node));
1001    }
1002    addedNodes = null;
1003    removedNodes = null;
1004    addedAttributes = null;
1005    removedAttributes = null;
1006  }
1007  function scope(node) {
1008    return mergeProxies(closestDataStack(node));
1009  }
1010  function addScopeToNode(node, data2, referenceNode) {
1011    node._x_dataStack = [data2, ...closestDataStack(referenceNode || node)];
1012    return () => {
1013      node._x_dataStack = node._x_dataStack.filter((i) => i !== data2);
1014    };
1015  }
1016  function closestDataStack(node) {
1017    if (node._x_dataStack)
1018      return node._x_dataStack;
1019    if (typeof ShadowRoot === "function" && node instanceof ShadowRoot) {
1020      return closestDataStack(node.host);
1021    }
1022    if (!node.parentNode) {
1023      return [];
1024    }
1025    return closestDataStack(node.parentNode);
1026  }
1027  function mergeProxies(objects) {
1028    return new Proxy({ objects }, mergeProxyTrap);
1029  }
1030  function keyInPrototypeChain(obj, key) {
1031    if (obj === null || obj === Object.prototype)
1032      return null;
1033    if (Object.prototype.hasOwnProperty.call(obj, key))
1034      return obj;
1035    return keyInPrototypeChain(Object.getPrototypeOf(obj), key);
1036  }
1037  var mergeProxyTrap = {
1038    ownKeys({ objects }) {
1039      return Array.from(new Set(objects.flatMap((i) => Object.keys(i))));
1040    },
1041    has({ objects }, name) {
1042      if (name == Symbol.unscopables)
1043        return false;
1044      return objects.some((obj) => Object.prototype.hasOwnProperty.call(obj, name) || Reflect.has(obj, name));
1045    },
1046    get({ objects }, name, thisProxy) {
1047      if (name == "toJSON")
1048        return collapseProxies;
1049      return Reflect.get(objects.find((obj) => Reflect.has(obj, name)) || {}, name, thisProxy);
1050    },
1051    set({ objects }, name, value, thisProxy) {
1052      let target;
1053      for (const obj of objects) {
1054        target = keyInPrototypeChain(obj, name);
1055        if (target)
1056          break;
1057      }
1058      if (!target)
1059        target = objects[objects.length - 1];
1060      const descriptor = Object.getOwnPropertyDescriptor(target, name);
1061      if (descriptor?.set && descriptor?.get)
1062        return descriptor.set.call(thisProxy, value) || true;
1063      return Reflect.set(target, name, value);
1064    }
1065  };
1066  function collapseProxies() {
1067    let keys = Reflect.ownKeys(this);
1068    return keys.reduce((acc, key) => {
1069      acc[key] = Reflect.get(this, key);
1070      return acc;
1071    }, {});
1072  }
1073  function initInterceptors(data2) {
1074    let isObject3 = (val) => typeof val === "object" && !Array.isArray(val) && val !== null;
1075    let recurse = (obj, basePath = "") => {
1076      Object.entries(Object.getOwnPropertyDescriptors(obj)).forEach(([key, { value, enumerable }]) => {
1077        if (enumerable === false || value === void 0)
1078          return;
1079        if (typeof value === "object" && value !== null && value.__v_skip)
1080          return;
1081        let path = basePath === "" ? key : `${basePath}.${key}`;
1082        if (typeof value === "object" && value !== null && value._x_interceptor) {
1083          obj[key] = value.initialize(data2, path, key);
1084        } else {
1085          if (isObject3(value) && value !== obj && !(value instanceof Element)) {
1086            recurse(value, path);
1087          }
1088        }
1089      });
1090    };
1091    return recurse(data2);
1092  }
1093  function interceptor(callback, mutateObj = () => {
1094  }) {
1095    let obj = {
1096      initialValue: void 0,
1097      _x_interceptor: true,
1098      initialize(data2, path, key) {
1099        return callback(this.initialValue, () => get(data2, path), (value) => set(data2, path, value), path, key);
1100      }
1101    };
1102    mutateObj(obj);
1103    return (initialValue) => {
1104      if (typeof initialValue === "object" && initialValue !== null && initialValue._x_interceptor) {
1105        let initialize = obj.initialize.bind(obj);
1106        obj.initialize = (data2, path, key) => {
1107          let innerValue = initialValue.initialize(data2, path, key);
1108          obj.initialValue = innerValue;
1109          return initialize(data2, path, key);
1110        };
1111      } else {
1112        obj.initialValue = initialValue;
1113      }
1114      return obj;
1115    };
1116  }
1117  function get(obj, path) {
1118    return path.split(".").reduce((carry, segment) => carry[segment], obj);
1119  }
1120  function set(obj, path, value) {
1121    if (typeof path === "string")
1122      path = path.split(".");
1123    if (path.length === 1)
1124      obj[path[0]] = value;
1125    else if (path.length === 0)
1126      throw error;
1127    else {
1128      if (obj[path[0]])
1129        return set(obj[path[0]], path.slice(1), value);
1130      else {
1131        obj[path[0]] = {};
1132        return set(obj[path[0]], path.slice(1), value);
1133      }
1134    }
1135  }
1136  var magics = {};
1137  function magic(name, callback) {
1138    magics[name] = callback;
1139  }
1140  function injectMagics(obj, el) {
1141    let memoizedUtilities = getUtilities(el);
1142    Object.entries(magics).forEach(([name, callback]) => {
1143      Object.defineProperty(obj, `$${name}`, {
1144        get() {
1145          return callback(el, memoizedUtilities);
1146        },
1147        enumerable: false
1148      });
1149    });
1150    return obj;
1151  }
1152  function getUtilities(el) {
1153    let [utilities, cleanup2] = getElementBoundUtilities(el);
1154    let utils = { interceptor, ...utilities };
1155    onElRemoved(el, cleanup2);
1156    return utils;
1157  }
1158  function tryCatch(el, expression, callback, ...args) {
1159    try {
1160      return callback(...args);
1161    } catch (e) {
1162      handleError(e, el, expression);
1163    }
1164  }
1165  function handleError(...args) {
1166    return errorHandler(...args);
1167  }
1168  var errorHandler = normalErrorHandler;
1169  function setErrorHandler(handler4) {
1170    errorHandler = handler4;
1171  }
1172  function normalErrorHandler(error2, el, expression = void 0) {
1173    error2 = Object.assign(error2 ?? { message: "No error message given." }, { el, expression });
1174    console.warn(`Alpine Expression Error: ${error2.message}
1175
1176${expression ? 'Expression: "' + expression + '"\n\n' : ""}`, el);
1177    setTimeout(() => {
1178      throw error2;
1179    }, 0);
1180  }
1181  var shouldAutoEvaluateFunctions = true;
1182  function dontAutoEvaluateFunctions(callback) {
1183    let cache = shouldAutoEvaluateFunctions;
1184    shouldAutoEvaluateFunctions = false;
1185    let result = callback();
1186    shouldAutoEvaluateFunctions = cache;
1187    return result;
1188  }
1189  function evaluate(el, expression, extras = {}) {
1190    let result;
1191    evaluateLater(el, expression)((value) => result = value, extras);
1192    return result;
1193  }
1194  function evaluateLater(...args) {
1195    return theEvaluatorFunction(...args);
1196  }
1197  var theEvaluatorFunction = () => {
1198  };
1199  function setEvaluator(newEvaluator) {
1200    theEvaluatorFunction = newEvaluator;
1201  }
1202  var theRawEvaluatorFunction;
1203  function setRawEvaluator(newEvaluator) {
1204    theRawEvaluatorFunction = newEvaluator;
1205  }
1206  function normalEvaluator(el, expression) {
1207    let overriddenMagics = {};
1208    injectMagics(overriddenMagics, el);
1209    let dataStack = [overriddenMagics, ...closestDataStack(el)];
1210    let evaluator = typeof expression === "function" ? generateEvaluatorFromFunction(dataStack, expression) : generateEvaluatorFromString(dataStack, expression, el);
1211    return tryCatch.bind(null, el, expression, evaluator);
1212  }
1213  function generateEvaluatorFromFunction(dataStack, func) {
1214    return (receiver = () => {
1215    }, { scope: scope2 = {}, params = [], context } = {}) => {
1216      if (!shouldAutoEvaluateFunctions) {
1217        runIfTypeOfFunction(receiver, func, mergeProxies([scope2, ...dataStack]), params);
1218        return;
1219      }
1220      let result = func.apply(mergeProxies([scope2, ...dataStack]), params);
1221      runIfTypeOfFunction(receiver, result);
1222    };
1223  }
1224  var evaluatorMemo = {};
1225  function generateFunctionFromString(expression, el) {
1226    if (evaluatorMemo[expression]) {
1227      return evaluatorMemo[expression];
1228    }
1229    let AsyncFunction = Object.getPrototypeOf(async function() {
1230    }).constructor;
1231    let rightSideSafeExpression = /^[\n\s]*if.*\(.*\)/.test(expression.trim()) || /^(let|const)\s/.test(expression.trim()) ? `(async()=>{ ${expression} })()` : expression;
1232    const safeAsyncFunction = () => {
1233      try {
1234        let func2 = new AsyncFunction(["__self", "scope"], `with (scope) { __self.result = ${rightSideSafeExpression} }; __self.finished = true; return __self.result;`);
1235        Object.defineProperty(func2, "name", {
1236          value: `[Alpine] ${expression}`
1237        });
1238        return func2;
1239      } catch (error2) {
1240        handleError(error2, el, expression);
1241        return Promise.resolve();
1242      }
1243    };
1244    let func = safeAsyncFunction();
1245    evaluatorMemo[expression] = func;
1246    return func;
1247  }
1248  function generateEvaluatorFromString(dataStack, expression, el) {
1249    let func = generateFunctionFromString(expression, el);
1250    return (receiver = () => {
1251    }, { scope: scope2 = {}, params = [], context } = {}) => {
1252      func.result = void 0;
1253      func.finished = false;
1254      let completeScope = mergeProxies([scope2, ...dataStack]);
1255      if (typeof func === "function") {
1256        let promise = func.call(context, func, completeScope).catch((error2) => handleError(error2, el, expression));
1257        if (func.finished) {
1258          runIfTypeOfFunction(receiver, func.result, completeScope, params, el);
1259          func.result = void 0;
1260        } else {
1261          promise.then((result) => {
1262            runIfTypeOfFunction(receiver, result, completeScope, params, el);
1263          }).catch((error2) => handleError(error2, el, expression)).finally(() => func.result = void 0);
1264        }
1265      }
1266    };
1267  }
1268  function runIfTypeOfFunction(receiver, value, scope2, params, el) {
1269    if (shouldAutoEvaluateFunctions && typeof value === "function") {
1270      let result = value.apply(scope2, params);
1271      if (result instanceof Promise) {
1272        result.then((i) => runIfTypeOfFunction(receiver, i, scope2, params)).catch((error2) => handleError(error2, el, value));
1273      } else {
1274        receiver(result);
1275      }
1276    } else if (typeof value === "object" && value instanceof Promise) {
1277      value.then((i) => receiver(i));
1278    } else {
1279      receiver(value);
1280    }
1281  }
1282  function evaluateRaw(...args) {
1283    return theRawEvaluatorFunction(...args);
1284  }
1285  function normalRawEvaluator(el, expression, extras = {}) {
1286    let overriddenMagics = {};
1287    injectMagics(overriddenMagics, el);
1288    let dataStack = [overriddenMagics, ...closestDataStack(el)];
1289    let scope2 = mergeProxies([extras.scope ?? {}, ...dataStack]);
1290    let params = extras.params ?? [];
1291    if (expression.includes("await")) {
1292      let AsyncFunction = Object.getPrototypeOf(async function() {
1293      }).constructor;
1294      let rightSideSafeExpression = /^[\n\s]*if.*\(.*\)/.test(expression.trim()) || /^(let|const)\s/.test(expression.trim()) ? `(async()=>{ ${expression} })()` : expression;
1295      let func = new AsyncFunction(["scope"], `with (scope) { let __result = ${rightSideSafeExpression}; return __result }`);
1296      let result = func.call(extras.context, scope2);
1297      return result;
1298    } else {
1299      let rightSideSafeExpression = /^[\n\s]*if.*\(.*\)/.test(expression.trim()) || /^(let|const)\s/.test(expression.trim()) ? `(()=>{ ${expression} })()` : expression;
1300      let func = new Function(["scope"], `with (scope) { let __result = ${rightSideSafeExpression}; return __result }`);
1301      let result = func.call(extras.context, scope2);
1302      if (typeof result === "function" && shouldAutoEvaluateFunctions) {
1303        return result.apply(scope2, params);
1304      }
1305      return result;
1306    }
1307  }
1308  var prefixAsString = "x-";
1309  function prefix(subject = "") {
1310    return prefixAsString + subject;
1311  }
1312  function setPrefix(newPrefix) {
1313    prefixAsString = newPrefix;
1314  }
1315  var directiveHandlers = {};
1316  function directive(name, callback) {
1317    directiveHandlers[name] = callback;
1318    return {
1319      before(directive22) {
1320        if (!directiveHandlers[directive22]) {
1321          console.warn(String.raw`Cannot find directive \`${directive22}\`. \`${name}\` will use the default order of execution`);
1322          return;
1323        }
1324        const pos = directiveOrder.indexOf(directive22);
1325        directiveOrder.splice(pos >= 0 ? pos : directiveOrder.indexOf("DEFAULT"), 0, name);
1326      }
1327    };
1328  }
1329  function directiveExists(name) {
1330    return Object.keys(directiveHandlers).includes(name);
1331  }
1332  function directives(el, attributes, originalAttributeOverride) {
1333    attributes = Array.from(attributes);
1334    if (el._x_virtualDirectives) {
1335      let vAttributes = Object.entries(el._x_virtualDirectives).map(([name, value]) => ({ name, value }));
1336      let staticAttributes = attributesOnly(vAttributes);
1337      vAttributes = vAttributes.map((attribute) => {
1338        if (staticAttributes.find((attr) => attr.name === attribute.name)) {
1339          return {
1340            name: `x-bind:${attribute.name}`,
1341            value: `"${attribute.value}"`
1342          };
1343        }
1344        return attribute;
1345      });
1346      attributes = attributes.concat(vAttributes);
1347    }
1348    let transformedAttributeMap = {};
1349    let directives2 = attributes.map(toTransformedAttributes((newName, oldName) => transformedAttributeMap[newName] = oldName)).filter(outNonAlpineAttributes).map(toParsedDirectives(transformedAttributeMap, originalAttributeOverride)).sort(byPriority);
1350    return directives2.map((directive22) => {
1351      return getDirectiveHandler(el, directive22);
1352    });
1353  }
1354  function attributesOnly(attributes) {
1355    return Array.from(attributes).map(toTransformedAttributes()).filter((attr) => !outNonAlpineAttributes(attr));
1356  }
1357  var isDeferringHandlers = false;
1358  var directiveHandlerStacks = /* @__PURE__ */ new Map();
1359  var currentHandlerStackKey = Symbol();
1360  function deferHandlingDirectives(callback) {
1361    isDeferringHandlers = true;
1362    let key = Symbol();
1363    currentHandlerStackKey = key;
1364    directiveHandlerStacks.set(key, []);
1365    let flushHandlers = () => {
1366      while (directiveHandlerStacks.get(key).length)
1367        directiveHandlerStacks.get(key).shift()();
1368      directiveHandlerStacks.delete(key);
1369    };
1370    let stopDeferring = () => {
1371      isDeferringHandlers = false;
1372      flushHandlers();
1373    };
1374    callback(flushHandlers);
1375    stopDeferring();
1376  }
1377  function getElementBoundUtilities(el) {
1378    let cleanups2 = [];
1379    let cleanup2 = (callback) => cleanups2.push(callback);
1380    let [effect3, cleanupEffect] = elementBoundEffect(el);
1381    cleanups2.push(cleanupEffect);
1382    let utilities = {
1383      Alpine: alpine_default,
1384      effect: effect3,
1385      cleanup: cleanup2,
1386      evaluateLater: evaluateLater.bind(evaluateLater, el),
1387      evaluate: evaluate.bind(evaluate, el)
1388    };
1389    let doCleanup = () => cleanups2.forEach((i) => i());
1390    return [utilities, doCleanup];
1391  }
1392  function getDirectiveHandler(el, directive22) {
1393    let noop = () => {
1394    };
1395    let handler4 = directiveHandlers[directive22.type] || noop;
1396    let [utilities, cleanup2] = getElementBoundUtilities(el);
1397    onAttributeRemoved(el, directive22.original, cleanup2);
1398    let fullHandler = () => {
1399      if (el._x_ignore || el._x_ignoreSelf)
1400        return;
1401      handler4.inline && handler4.inline(el, directive22, utilities);
1402      handler4 = handler4.bind(handler4, el, directive22, utilities);
1403      isDeferringHandlers ? directiveHandlerStacks.get(currentHandlerStackKey).push(handler4) : handler4();
1404    };
1405    fullHandler.runCleanups = cleanup2;
1406    return fullHandler;
1407  }
1408  var startingWith = (subject, replacement) => ({ name, value }) => {
1409    if (name.startsWith(subject))
1410      name = name.replace(subject, replacement);
1411    return { name, value };
1412  };
1413  var into = (i) => i;
1414  function toTransformedAttributes(callback = () => {
1415  }) {
1416    return ({ name, value }) => {
1417      let { name: newName, value: newValue } = attributeTransformers.reduce((carry, transform) => {
1418        return transform(carry);
1419      }, { name, value });
1420      if (newName !== name)
1421        callback(newName, name);
1422      return { name: newName, value: newValue };
1423    };
1424  }
1425  var attributeTransformers = [];
1426  function mapAttributes(callback) {
1427    attributeTransformers.push(callback);
1428  }
1429  function outNonAlpineAttributes({ name }) {
1430    return alpineAttributeRegex().test(name);
1431  }
1432  var alpineAttributeRegex = () => new RegExp(`^${prefixAsString}([^:^.]+)\\b`);
1433  function toParsedDirectives(transformedAttributeMap, originalAttributeOverride) {
1434    return ({ name, value }) => {
1435      if (name === value)
1436        value = "";
1437      let typeMatch = name.match(alpineAttributeRegex());
1438      let valueMatch = name.match(/:([a-zA-Z0-9\-_:]+)/);
1439      let modifiers = name.match(/\.[^.\]]+(?=[^\]]*$)/g) || [];
1440      let original = originalAttributeOverride || transformedAttributeMap[name] || name;
1441      return {
1442        type: typeMatch ? typeMatch[1] : null,
1443        value: valueMatch ? valueMatch[1] : null,
1444        modifiers: modifiers.map((i) => i.replace(".", "")),
1445        expression: value,
1446        original
1447      };
1448    };
1449  }
1450  var DEFAULT = "DEFAULT";
1451  var directiveOrder = [
1452    "ignore",
1453    "ref",
1454    "data",
1455    "id",
1456    "anchor",
1457    "bind",
1458    "init",
1459    "for",
1460    "model",
1461    "modelable",
1462    "transition",
1463    "show",
1464    "if",
1465    DEFAULT,
1466    "teleport"
1467  ];
1468  function byPriority(a, b) {
1469    let typeA = directiveOrder.indexOf(a.type) === -1 ? DEFAULT : a.type;
1470    let typeB = directiveOrder.indexOf(b.type) === -1 ? DEFAULT : b.type;
1471    return directiveOrder.indexOf(typeA) - directiveOrder.indexOf(typeB);
1472  }
1473  function dispatch2(el, name, detail = {}, options = {}) {
1474    return el.dispatchEvent(new CustomEvent(name, {
1475      detail,
1476      bubbles: true,
1477      composed: true,
1478      cancelable: true,
1479      ...options
1480    }));
1481  }
1482  function walk(el, callback) {
1483    if (typeof ShadowRoot === "function" && el instanceof ShadowRoot) {
1484      Array.from(el.children).forEach((el2) => walk(el2, callback));
1485      return;
1486    }
1487    let skip = false;
1488    callback(el, () => skip = true);
1489    if (skip)
1490      return;
1491    let node = el.firstElementChild;
1492    while (node) {
1493      walk(node, callback, false);
1494      node = node.nextElementSibling;
1495    }
1496  }
1497  function warn(message, ...args) {
1498    console.warn(`Alpine Warning: ${message}`, ...args);
1499  }
1500  var started = false;
1501  function start() {
1502    if (started)
1503      warn("Alpine has already been initialized on this page. Calling Alpine.start() more than once can cause problems.");
1504    started = true;
1505    if (!document.body)
1506      warn("Unable to initialize. Trying to load Alpine before `<body>` is available. Did you forget to add `defer` in Alpine's `<script>` tag?");
1507    dispatch2(document, "alpine:init");
1508    dispatch2(document, "alpine:initializing");
1509    startObservingMutations();
1510    onElAdded((el) => initTree(el, walk));
1511    onElRemoved((el) => destroyTree(el));
1512    onAttributesAdded((el, attrs) => {
1513      directives(el, attrs).forEach((handle) => handle());
1514    });
1515    let outNestedComponents = (el) => !closestRoot(el.parentElement, true);
1516    Array.from(document.querySelectorAll(allSelectors().join(","))).filter(outNestedComponents).forEach((el) => {
1517      initTree(el);
1518    });
1519    dispatch2(document, "alpine:initialized");
1520    setTimeout(() => {
1521      warnAboutMissingPlugins();
1522    });
1523  }
1524  var rootSelectorCallbacks = [];
1525  var initSelectorCallbacks = [];
1526  function rootSelectors() {
1527    return rootSelectorCallbacks.map((fn) => fn());
1528  }
1529  function allSelectors() {
1530    return rootSelectorCallbacks.concat(initSelectorCallbacks).map((fn) => fn());
1531  }
1532  function addRootSelector(selectorCallback) {
1533    rootSelectorCallbacks.push(selectorCallback);
1534  }
1535  function addInitSelector(selectorCallback) {
1536    initSelectorCallbacks.push(selectorCallback);
1537  }
1538  function closestRoot(el, includeInitSelectors = false) {
1539    return findClosest(el, (element) => {
1540      const selectors = includeInitSelectors ? allSelectors() : rootSelectors();
1541      if (selectors.some((selector) => element.matches(selector)))
1542        return true;
1543    });
1544  }
1545  function findClosest(el, callback) {
1546    if (!el)
1547      return;
1548    if (callback(el))
1549      return el;
1550    if (el._x_teleportBack)
1551      return findClosest(el._x_teleportBack, callback);
1552    if (el.parentNode instanceof ShadowRoot) {
1553      return findClosest(el.parentNode.host, callback);
1554    }
1555    if (!el.parentElement)
1556      return;
1557    return findClosest(el.parentElement, callback);
1558  }
1559  function isRoot(el) {
1560    return rootSelectors().some((selector) => el.matches(selector));
1561  }
1562  var initInterceptors2 = [];
1563  function interceptInit(callback) {
1564    initInterceptors2.push(callback);
1565  }
1566  var markerDispenser = 1;
1567  function initTree(el, walker = walk, intercept = () => {
1568  }) {
1569    if (findClosest(el, (i) => i._x_ignore))
1570      return;
1571    deferHandlingDirectives(() => {
1572      walker(el, (el2, skip) => {
1573        if (el2._x_marker)
1574          return;
1575        intercept(el2, skip);
1576        initInterceptors2.forEach((i) => i(el2, skip));
1577        directives(el2, el2.attributes).forEach((handle) => handle());
1578        if (!el2._x_ignore)
1579          el2._x_marker = markerDispenser++;
1580        el2._x_ignore && skip();
1581      });
1582    });
1583  }
1584  function destroyTree(root, walker = walk) {
1585    walker(root, (el) => {
1586      cleanupElement(el);
1587      cleanupAttributes(el);
1588      delete el._x_marker;
1589    });
1590  }
1591  function warnAboutMissingPlugins() {
1592    let pluginDirectives = [
1593      ["ui", "dialog", ["[x-dialog], [x-popover]"]],
1594      ["anchor", "anchor", ["[x-anchor]"]],
1595      ["sort", "sort", ["[x-sort]"]]
1596    ];
1597    pluginDirectives.forEach(([plugin2, directive22, selectors]) => {
1598      if (directiveExists(directive22))
1599        return;
1600      selectors.some((selector) => {
1601        if (document.querySelector(selector)) {
1602          warn(`found "${selector}", but missing ${plugin2} plugin`);
1603          return true;
1604        }
1605      });
1606    });
1607  }
1608  var tickStack = [];
1609  var isHolding = false;
1610  function nextTick(callback = () => {
1611  }) {
1612    queueMicrotask(() => {
1613      isHolding || setTimeout(() => {
1614        releaseNextTicks();
1615      });
1616    });
1617    return new Promise((res) => {
1618      tickStack.push(() => {
1619        callback();
1620        res();
1621      });
1622    });
1623  }
1624  function releaseNextTicks() {
1625    isHolding = false;
1626    while (tickStack.length)
1627      tickStack.shift()();
1628  }
1629  function holdNextTicks() {
1630    isHolding = true;
1631  }
1632  function setClasses(el, value) {
1633    if (Array.isArray(value)) {
1634      return setClassesFromString(el, value.join(" "));
1635    } else if (typeof value === "object" && value !== null) {
1636      return setClassesFromObject(el, value);
1637    } else if (typeof value === "function") {
1638      return setClasses(el, value());
1639    }
1640    return setClassesFromString(el, value);
1641  }
1642  function splitClasses(classString) {
1643    return classString.split(/\s/).filter(Boolean);
1644  }
1645  function setClassesFromString(el, classString) {
1646    let missingClasses = (classString2) => splitClasses(classString2).filter((i) => !el.classList.contains(i)).filter(Boolean);
1647    let addClassesAndReturnUndo = (classes) => {
1648      el.classList.add(...classes);
1649      return () => {
1650        el.classList.remove(...classes);
1651      };
1652    };
1653    classString = classString === true ? classString = "" : classString || "";
1654    return addClassesAndReturnUndo(missingClasses(classString));
1655  }
1656  function setClassesFromObject(el, classObject) {
1657    let forAdd = Object.entries(classObject).flatMap(([classString, bool]) => bool ? splitClasses(classString) : false).filter(Boolean);
1658    let forRemove = Object.entries(classObject).flatMap(([classString, bool]) => !bool ? splitClasses(classString) : false).filter(Boolean);
1659    let added = [];
1660    let removed = [];
1661    forRemove.forEach((i) => {
1662      if (el.classList.contains(i)) {
1663        el.classList.remove(i);
1664        removed.push(i);
1665      }
1666    });
1667    forAdd.forEach((i) => {
1668      if (!el.classList.contains(i)) {
1669        el.classList.add(i);
1670        added.push(i);
1671      }
1672    });
1673    return () => {
1674      removed.forEach((i) => el.classList.add(i));
1675      added.forEach((i) => el.classList.remove(i));
1676    };
1677  }
1678  function setStyles(el, value) {
1679    if (typeof value === "object" && value !== null) {
1680      return setStylesFromObject(el, value);
1681    }
1682    return setStylesFromString(el, value);
1683  }
1684  function setStylesFromObject(el, value) {
1685    let previousStyles = {};
1686    Object.entries(value).forEach(([key, value2]) => {
1687      previousStyles[key] = el.style[key];
1688      if (!key.startsWith("--")) {
1689        key = kebabCase(key);
1690      }
1691      el.style.setProperty(key, value2);
1692    });
1693    setTimeout(() => {
1694      if (el.style.length === 0) {
1695        el.removeAttribute("style");
1696      }
1697    });
1698    return () => {
1699      setStyles(el, previousStyles);
1700    };
1701  }
1702  function setStylesFromString(el, value) {
1703    let cache = el.getAttribute("style", value);
1704    el.setAttribute("style", value);
1705    return () => {
1706      el.setAttribute("style", cache || "");
1707    };
1708  }
1709  function kebabCase(subject) {
1710    return subject.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
1711  }
1712  function once(callback, fallback2 = () => {
1713  }) {
1714    let called = false;
1715    return function() {
1716      if (!called) {
1717        called = true;
1718        callback.apply(this, arguments);
1719      } else {
1720        fallback2.apply(this, arguments);
1721      }
1722    };
1723  }
1724  directive("transition", (el, { value, modifiers, expression }, { evaluate: evaluate22 }) => {
1725    if (typeof expression === "function")
1726      expression = evaluate22(expression);
1727    if (expression === false)
1728      return;
1729    if (!expression || typeof expression === "boolean") {
1730      registerTransitionsFromHelper(el, modifiers, value);
1731    } else {
1732      registerTransitionsFromClassString(el, expression, value);
1733    }
1734  });
1735  function registerTransitionsFromClassString(el, classString, stage) {
1736    registerTransitionObject(el, setClasses, "");
1737    let directiveStorageMap = {
1738      "enter": (classes) => {
1739        el._x_transition.enter.during = classes;
1740      },
1741      "enter-start": (classes) => {
1742        el._x_transition.enter.start = classes;
1743      },
1744      "enter-end": (classes) => {
1745        el._x_transition.enter.end = classes;
1746      },
1747      "leave": (classes) => {
1748        el._x_transition.leave.during = classes;
1749      },
1750      "leave-start": (classes) => {
1751        el._x_transition.leave.start = classes;
1752      },
1753      "leave-end": (classes) => {
1754        el._x_transition.leave.end = classes;
1755      }
1756    };
1757    directiveStorageMap[stage](classString);
1758  }
1759  function registerTransitionsFromHelper(el, modifiers, stage) {
1760    registerTransitionObject(el, setStyles);
1761    let doesntSpecify = !modifiers.includes("in") && !modifiers.includes("out") && !stage;
1762    let transitioningIn = doesntSpecify || modifiers.includes("in") || ["enter"].includes(stage);
1763    let transitioningOut = doesntSpecify || modifiers.includes("out") || ["leave"].includes(stage);
1764    if (modifiers.includes("in") && !doesntSpecify) {
1765      modifiers = modifiers.filter((i, index) => index < modifiers.indexOf("out"));
1766    }
1767    if (modifiers.includes("out") && !doesntSpecify) {
1768      modifiers = modifiers.filter((i, index) => index > modifiers.indexOf("out"));
1769    }
1770    let wantsAll = !modifiers.includes("opacity") && !modifiers.includes("scale");
1771    let wantsOpacity = wantsAll || modifiers.includes("opacity");
1772    let wantsScale = wantsAll || modifiers.includes("scale");
1773    let opacityValue = wantsOpacity ? 0 : 1;
1774    let scaleValue = wantsScale ? modifierValue(modifiers, "scale", 95) / 100 : 1;
1775    let delay3 = modifierValue(modifiers, "delay", 0) / 1e3;
1776    let origin = modifierValue(modifiers, "origin", "center");
1777    let property = "opacity, transform";
1778    let durationIn = modifierValue(modifiers, "duration", 150) / 1e3;
1779    let durationOut = modifierValue(modifiers, "duration", 75) / 1e3;
1780    let easing = `cubic-bezier(0.4, 0.0, 0.2, 1)`;
1781    if (transitioningIn) {
1782      el._x_transition.enter.during = {
1783        transformOrigin: origin,
1784        transitionDelay: `${delay3}s`,
1785        transitionProperty: property,
1786        transitionDuration: `${durationIn}s`,
1787        transitionTimingFunction: easing
1788      };
1789      el._x_transition.enter.start = {
1790        opacity: opacityValue,
1791        transform: `scale(${scaleValue})`
1792      };
1793      el._x_transition.enter.end = {
1794        opacity: 1,
1795        transform: `scale(1)`
1796      };
1797    }
1798    if (transitioningOut) {
1799      el._x_transition.leave.during = {
1800        transformOrigin: origin,
1801        transitionDelay: `${delay3}s`,
1802        transitionProperty: property,
1803        transitionDuration: `${durationOut}s`,
1804        transitionTimingFunction: easing
1805      };
1806      el._x_transition.leave.start = {
1807        opacity: 1,
1808        transform: `scale(1)`
1809      };
1810      el._x_transition.leave.end = {
1811        opacity: opacityValue,
1812        transform: `scale(${scaleValue})`
1813      };
1814    }
1815  }
1816  function registerTransitionObject(el, setFunction, defaultValue = {}) {
1817    if (!el._x_transition)
1818      el._x_transition = {
1819        enter: { during: defaultValue, start: defaultValue, end: defaultValue },
1820        leave: { during: defaultValue, start: defaultValue, end: defaultValue },
1821        in(before = () => {
1822        }, after = () => {
1823        }) {
1824          transition(el, setFunction, {
1825            during: this.enter.during,
1826            start: this.enter.start,
1827            end: this.enter.end
1828          }, before, after);
1829        },
1830        out(before = () => {
1831        }, after = () => {
1832        }) {
1833          transition(el, setFunction, {
1834            during: this.leave.during,
1835            start: this.leave.start,
1836            end: this.leave.end
1837          }, before, after);
1838        }
1839      };
1840  }
1841  window.Element.prototype._x_toggleAndCascadeWithTransitions = function(el, value, show, hide) {
1842    const nextTick2 = document.visibilityState === "visible" ? requestAnimationFrame : setTimeout;
1843    let clickAwayCompatibleShow = () => nextTick2(show);
1844    if (value) {
1845      if (el._x_transition && (el._x_transition.enter || el._x_transition.leave)) {
1846        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();
1847      } else {
1848        el._x_transition ? el._x_transition.in(show) : clickAwayCompatibleShow();
1849      }
1850      return;
1851    }
1852    el._x_hidePromise = el._x_transition ? new Promise((resolve, reject) => {
1853      el._x_transition.out(() => {
1854      }, () => resolve(hide));
1855      el._x_transitioning && el._x_transitioning.beforeCancel(() => reject({ isFromCancelledTransition: true }));
1856    }) : Promise.resolve(hide);
1857    queueMicrotask(() => {
1858      let closest = closestHide(el);
1859      if (closest) {
1860        if (!closest._x_hideChildren)
1861          closest._x_hideChildren = [];
1862        closest._x_hideChildren.push(el);
1863      } else {
1864        nextTick2(() => {
1865          let hideAfterChildren = (el2) => {
1866            let carry = Promise.all([
1867              el2._x_hidePromise,
1868              ...(el2._x_hideChildren || []).map(hideAfterChildren)
1869            ]).then(([i]) => i?.());
1870            delete el2._x_hidePromise;
1871            delete el2._x_hideChildren;
1872            return carry;
1873          };
1874          hideAfterChildren(el).catch((e) => {
1875            if (!e.isFromCancelledTransition)
1876              throw e;
1877          });
1878        });
1879      }
1880    });
1881  };
1882  function closestHide(el) {
1883    let parent = el.parentNode;
1884    if (!parent)
1885      return;
1886    return parent._x_hidePromise ? parent : closestHide(parent);
1887  }
1888  function transition(el, setFunction, { during, start: start22, end } = {}, before = () => {
1889  }, after = () => {
1890  }) {
1891    if (el._x_transitioning)
1892      el._x_transitioning.cancel();
1893    if (Object.keys(during).length === 0 && Object.keys(start22).length === 0 && Object.keys(end).length === 0) {
1894      before();
1895      after();
1896      return;
1897    }
1898    let undoStart, undoDuring, undoEnd;
1899    performTransition(el, {
1900      start() {
1901        undoStart = setFunction(el, start22);
1902      },
1903      during() {
1904        undoDuring = setFunction(el, during);
1905      },
1906      before,
1907      end() {
1908        undoStart();
1909        undoEnd = setFunction(el, end);
1910      },
1911      after,
1912      cleanup() {
1913        undoDuring();
1914        undoEnd();
1915      }
1916    });
1917  }
1918  function performTransition(el, stages) {
1919    let interrupted, reachedBefore, reachedEnd;
1920    let finish = once(() => {
1921      mutateDom(() => {
1922        interrupted = true;
1923        if (!reachedBefore)
1924          stages.before();
1925        if (!reachedEnd) {
1926          stages.end();
1927          releaseNextTicks();
1928        }
1929        stages.after();
1930        if (el.isConnected)
1931          stages.cleanup();
1932        delete el._x_transitioning;
1933      });
1934    });
1935    el._x_transitioning = {
1936      beforeCancels: [],
1937      beforeCancel(callback) {
1938        this.beforeCancels.push(callback);
1939      },
1940      cancel: once(function() {
1941        while (this.beforeCancels.length) {
1942          this.beforeCancels.shift()();
1943        }
1944        ;
1945        finish();
1946      }),
1947      finish
1948    };
1949    mutateDom(() => {
1950      stages.start();
1951      stages.during();
1952    });
1953    holdNextTicks();
1954    requestAnimationFrame(() => {
1955      if (interrupted)
1956        return;
1957      let duration = Number(getComputedStyle(el).transitionDuration.replace(/,.*/, "").replace("s", "")) * 1e3;
1958      let delay3 = Number(getComputedStyle(el).transitionDelay.replace(/,.*/, "").replace("s", "")) * 1e3;
1959      if (duration === 0)
1960        duration = Number(getComputedStyle(el).animationDuration.replace("s", "")) * 1e3;
1961      mutateDom(() => {
1962        stages.before();
1963      });
1964      reachedBefore = true;
1965      requestAnimationFrame(() => {
1966        if (interrupted)
1967          return;
1968        mutateDom(() => {
1969          stages.end();
1970        });
1971        releaseNextTicks();
1972        setTimeout(el._x_transitioning.finish, duration + delay3);
1973        reachedEnd = true;
1974      });
1975    });
1976  }
1977  function modifierValue(modifiers, key, fallback2) {
1978    if (modifiers.indexOf(key) === -1)
1979      return fallback2;
1980    const rawValue = modifiers[modifiers.indexOf(key) + 1];
1981    if (!rawValue)
1982      return fallback2;
1983    if (key === "scale") {
1984      if (isNaN(rawValue))
1985        return fallback2;
1986    }
1987    if (key === "duration" || key === "delay") {
1988      let match = rawValue.match(/([0-9]+)ms/);
1989      if (match)
1990        return match[1];
1991    }
1992    if (key === "origin") {
1993      if (["top", "right", "left", "center", "bottom"].includes(modifiers[modifiers.indexOf(key) + 2])) {
1994        return [rawValue, modifiers[modifiers.indexOf(key) + 2]].join(" ");
1995      }
1996    }
1997    return rawValue;
1998  }
1999  var isCloning = false;
2000  function skipDuringClone(callback, fallback2 = () => {
2001  }) {
2002    return (...args) => isCloning ? fallback2(...args) : callback(...args);
2003  }
2004  function onlyDuringClone(callback) {
2005    return (...args) => isCloning && callback(...args);
2006  }
2007  var interceptors = [];
2008  function interceptClone(callback) {
2009    interceptors.push(callback);
2010  }
2011  function cloneNode(from, to) {
2012    interceptors.forEach((i) => i(from, to));
2013    isCloning = true;
2014    dontRegisterReactiveSideEffects(() => {
2015      initTree(to, (el, callback) => {
2016        callback(el, () => {
2017        });
2018      });
2019    });
2020    isCloning = false;
2021  }
2022  var isCloningLegacy = false;
2023  function clone(oldEl, newEl) {
2024    if (!newEl._x_dataStack)
2025      newEl._x_dataStack = oldEl._x_dataStack;
2026    isCloning = true;
2027    isCloningLegacy = true;
2028    dontRegisterReactiveSideEffects(() => {
2029      cloneTree(newEl);
2030    });
2031    isCloning = false;
2032    isCloningLegacy = false;
2033  }
2034  function cloneTree(el) {
2035    let hasRunThroughFirstEl = false;
2036    let shallowWalker = (el2, callback) => {
2037      walk(el2, (el3, skip) => {
2038        if (hasRunThroughFirstEl && isRoot(el3))
2039          return skip();
2040        hasRunThroughFirstEl = true;
2041        callback(el3, skip);
2042      });
2043    };
2044    initTree(el, shallowWalker);
2045  }
2046  function dontRegisterReactiveSideEffects(callback) {
2047    let cache = effect;
2048    overrideEffect((callback2, el) => {
2049      let storedEffect = cache(callback2);
2050      release(storedEffect);
2051      return () => {
2052      };
2053    });
2054    callback();
2055    overrideEffect(cache);
2056  }
2057  function bind(el, name, value, modifiers = []) {
2058    if (!el._x_bindings)
2059      el._x_bindings = reactive({});
2060    el._x_bindings[name] = value;
2061    name = modifiers.includes("camel") ? camelCase(name) : name;
2062    switch (name) {
2063      case "value":
2064        bindInputValue(el, value);
2065        break;
2066      case "style":
2067        bindStyles(el, value);
2068        break;
2069      case "class":
2070        bindClasses(el, value);
2071        break;
2072      case "selected":
2073      case "checked":
2074        bindAttributeAndProperty(el, name, value);
2075        break;
2076      default:
2077        bindAttribute(el, name, value);
2078        break;
2079    }
2080  }
2081  function bindInputValue(el, value) {
2082    if (isRadio(el)) {
2083      if (el.attributes.value === void 0) {
2084        el.value = value;
2085      }
2086    } else if (isCheckbox(el)) {
2087      if (Number.isInteger(value)) {
2088        el.value = value;
2089      } else if (!Array.isArray(value) && typeof value !== "boolean" && ![null, void 0].includes(value)) {
2090        el.value = String(value);
2091      } else {
2092        if (Array.isArray(value)) {
2093          el.checked = value.some((val) => checkedAttrLooseCompare(val, el.value));
2094        } else {
2095          el.checked = !!value;
2096        }
2097      }
2098    } else if (el.tagName === "SELECT") {
2099      updateSelect(el, value);
2100    } else {
2101      if (el.value === value)
2102        return;
2103      el.value = value === void 0 ? "" : value;
2104    }
2105  }
2106  function bindClasses(el, value) {
2107    if (el._x_undoAddedClasses)
2108      el._x_undoAddedClasses();
2109    el._x_undoAddedClasses = setClasses(el, value);
2110  }
2111  function bindStyles(el, value) {
2112    if (el._x_undoAddedStyles)
2113      el._x_undoAddedStyles();
2114    el._x_undoAddedStyles = setStyles(el, value);
2115  }
2116  function bindAttributeAndProperty(el, name, value) {
2117    bindAttribute(el, name, value);
2118    setPropertyIfChanged(el, name, value);
2119  }
2120  function bindAttribute(el, name, value) {
2121    if ([null, void 0, false].includes(value) && attributeShouldntBePreservedIfFalsy(name)) {
2122      el.removeAttribute(name);
2123    } else {
2124      if (isBooleanAttr(name))
2125        value = name;
2126      setIfChanged(el, name, value);
2127    }
2128  }
2129  function setIfChanged(el, attrName, value) {
2130    if (el.getAttribute(attrName) != value) {
2131      el.setAttribute(attrName, value);
2132    }
2133  }
2134  function setPropertyIfChanged(el, propName, value) {
2135    if (el[propName] !== value) {
2136      el[propName] = value;
2137    }
2138  }
2139  function updateSelect(el, value) {
2140    const arrayWrappedValue = [].concat(value).map((value2) => {
2141      return value2 + "";
2142    });
2143    Array.from(el.options).forEach((option) => {
2144      option.selected = arrayWrappedValue.includes(option.value);
2145    });
2146  }
2147  function camelCase(subject) {
2148    return subject.toLowerCase().replace(/-(\w)/g, (match, char) => char.toUpperCase());
2149  }
2150  function checkedAttrLooseCompare(valueA, valueB) {
2151    return valueA == valueB;
2152  }
2153  function safeParseBoolean(rawValue) {
2154    if ([1, "1", "true", "on", "yes", true].includes(rawValue)) {
2155      return true;
2156    }
2157    if ([0, "0", "false", "off", "no", false].includes(rawValue)) {
2158      return false;
2159    }
2160    return rawValue ? Boolean(rawValue) : null;
2161  }
2162  var booleanAttributes = /* @__PURE__ */ new Set([
2163    "allowfullscreen",
2164    "async",
2165    "autofocus",
2166    "autoplay",
2167    "checked",
2168    "controls",
2169    "default",
2170    "defer",
2171    "disabled",
2172    "formnovalidate",
2173    "inert",
2174    "ismap",
2175    "itemscope",
2176    "loop",
2177    "multiple",
2178    "muted",
2179    "nomodule",
2180    "novalidate",
2181    "open",
2182    "playsinline",
2183    "readonly",
2184    "required",
2185    "reversed",
2186    "selected",
2187    "shadowrootclonable",
2188    "shadowrootdelegatesfocus",
2189    "shadowrootserializable"
2190  ]);
2191  function isBooleanAttr(attrName) {
2192    return booleanAttributes.has(attrName);
2193  }
2194  function attributeShouldntBePreservedIfFalsy(name) {
2195    return !["aria-pressed", "aria-checked", "aria-expanded", "aria-selected"].includes(name);
2196  }
2197  function getBinding(el, name, fallback2) {
2198    if (el._x_bindings && el._x_bindings[name] !== void 0)
2199      return el._x_bindings[name];
2200    return getAttributeBinding(el, name, fallback2);
2201  }
2202  function extractProp(el, name, fallback2, extract = true) {
2203    if (el._x_bindings && el._x_bindings[name] !== void 0)
2204      return el._x_bindings[name];
2205    if (el._x_inlineBindings && el._x_inlineBindings[name] !== void 0) {
2206      let binding = el._x_inlineBindings[name];
2207      binding.extract = extract;
2208      return dontAutoEvaluateFunctions(() => {
2209        return evaluate(el, binding.expression);
2210      });
2211    }
2212    return getAttributeBinding(el, name, fallback2);
2213  }
2214  function getAttributeBinding(el, name, fallback2) {
2215    let attr = el.getAttribute(name);
2216    if (attr === null)
2217      return typeof fallback2 === "function" ? fallback2() : fallback2;
2218    if (attr === "")
2219      return true;
2220    if (isBooleanAttr(name)) {
2221      return !![name, "true"].includes(attr);
2222    }
2223    return attr;
2224  }
2225  function isCheckbox(el) {
2226    return el.type === "checkbox" || el.localName === "ui-checkbox" || el.localName === "ui-switch";
2227  }
2228  function isRadio(el) {
2229    return el.type === "radio" || el.localName === "ui-radio";
2230  }
2231  function debounce(func, wait) {
2232    let timeout;
2233    return function() {
2234      const context = this, args = arguments;
2235      const later = function() {
2236        timeout = null;
2237        func.apply(context, args);
2238      };
2239      clearTimeout(timeout);
2240      timeout = setTimeout(later, wait);
2241    };
2242  }
2243  function throttle(func, limit) {
2244    let inThrottle;
2245    return function() {
2246      let context = this, args = arguments;
2247      if (!inThrottle) {
2248        func.apply(context, args);
2249        inThrottle = true;
2250        setTimeout(() => inThrottle = false, limit);
2251      }
2252    };
2253  }
2254  function entangle({ get: outerGet, set: outerSet }, { get: innerGet, set: innerSet }) {
2255    let firstRun = true;
2256    let outerHash;
2257    let innerHash;
2258    let reference = effect(() => {
2259      let outer = outerGet();
2260      let inner = innerGet();
2261      if (firstRun) {
2262        innerSet(cloneIfObject(outer));
2263        firstRun = false;
2264      } else {
2265        let outerHashLatest = JSON.stringify(outer);
2266        let innerHashLatest = JSON.stringify(inner);
2267        if (outerHashLatest !== outerHash) {
2268          innerSet(cloneIfObject(outer));
2269        } else if (outerHashLatest !== innerHashLatest) {
2270          outerSet(cloneIfObject(inner));
2271        } else {
2272        }
2273      }
2274      outerHash = JSON.stringify(outerGet());
2275      innerHash = JSON.stringify(innerGet());
2276    });
2277    return () => {
2278      release(reference);
2279    };
2280  }
2281  function cloneIfObject(value) {
2282    return typeof value === "object" ? JSON.parse(JSON.stringify(value)) : value;
2283  }
2284  function plugin(callback) {
2285    let callbacks = Array.isArray(callback) ? callback : [callback];
2286    callbacks.forEach((i) => i(alpine_default));
2287  }
2288  var stores = {};
2289  var isReactive = false;
2290  function store(name, value) {
2291    if (!isReactive) {
2292      stores = reactive(stores);
2293      isReactive = true;
2294    }
2295    if (value === void 0) {
2296      return stores[name];
2297    }
2298    stores[name] = value;
2299    initInterceptors(stores[name]);
2300    if (typeof value === "object" && value !== null && value.hasOwnProperty("init") && typeof value.init === "function") {
2301      stores[name].init();
2302    }
2303  }
2304  function getStores() {
2305    return stores;
2306  }
2307  var binds = {};
2308  function bind2(name, bindings) {
2309    let getBindings = typeof bindings !== "function" ? () => bindings : bindings;
2310    if (name instanceof Element) {
2311      return applyBindingsObject(name, getBindings());
2312    } else {
2313      binds[name] = getBindings;
2314    }
2315    return () => {
2316    };
2317  }
2318  function injectBindingProviders(obj) {
2319    Object.entries(binds).forEach(([name, callback]) => {
2320      Object.defineProperty(obj, name, {
2321        get() {
2322          return (...args) => {
2323            return callback(...args);
2324          };
2325        }
2326      });
2327    });
2328    return obj;
2329  }
2330  function applyBindingsObject(el, obj, original) {
2331    let cleanupRunners = [];
2332    while (cleanupRunners.length)
2333      cleanupRunners.pop()();
2334    let attributes = Object.entries(obj).map(([name, value]) => ({ name, value }));
2335    let staticAttributes = attributesOnly(attributes);
2336    attributes = attributes.map((attribute) => {
2337      if (staticAttributes.find((attr) => attr.name === attribute.name)) {
2338        return {
2339          name: `x-bind:${attribute.name}`,
2340          value: `"${attribute.value}"`
2341        };
2342      }
2343      return attribute;
2344    });
2345    directives(el, attributes, original).map((handle) => {
2346      cleanupRunners.push(handle.runCleanups);
2347      handle();
2348    });
2349    return () => {
2350      while (cleanupRunners.length)
2351        cleanupRunners.pop()();
2352    };
2353  }
2354  var datas = {};
2355  function data(name, callback) {
2356    datas[name] = callback;
2357  }
2358  function injectDataProviders(obj, context) {
2359    Object.entries(datas).forEach(([name, callback]) => {
2360      Object.defineProperty(obj, name, {
2361        get() {
2362          return (...args) => {
2363            return callback.bind(context)(...args);
2364          };
2365        },
2366        enumerable: false
2367      });
2368    });
2369    return obj;
2370  }
2371  var Alpine2 = {
2372    get reactive() {
2373      return reactive;
2374    },
2375    get release() {
2376      return release;
2377    },
2378    get effect() {
2379      return effect;
2380    },
2381    get raw() {
2382      return raw;
2383    },
2384    get transaction() {
2385      return transaction;
2386    },
2387    version: "3.15.11",
2388    flushAndStopDeferringMutations,
2389    dontAutoEvaluateFunctions,
2390    disableEffectScheduling,
2391    startObservingMutations,
2392    stopObservingMutations,
2393    setReactivityEngine,
2394    onAttributeRemoved,
2395    onAttributesAdded,
2396    closestDataStack,
2397    skipDuringClone,
2398    onlyDuringClone,
2399    addRootSelector,
2400    addInitSelector,
2401    setErrorHandler,
2402    interceptClone,
2403    addScopeToNode,
2404    deferMutations,
2405    mapAttributes,
2406    evaluateLater,
2407    interceptInit,
2408    initInterceptors,
2409    injectMagics,
2410    setEvaluator,
2411    setRawEvaluator,
2412    mergeProxies,
2413    extractProp,
2414    findClosest,
2415    onElRemoved,
2416    closestRoot,
2417    destroyTree,
2418    interceptor,
2419    transition,
2420    setStyles,
2421    mutateDom,
2422    directive,
2423    entangle,
2424    throttle,
2425    debounce,
2426    evaluate,
2427    evaluateRaw,
2428    initTree,
2429    nextTick,
2430    prefixed: prefix,
2431    prefix: setPrefix,
2432    plugin,
2433    magic,
2434    store,
2435    start,
2436    clone,
2437    cloneNode,
2438    bound: getBinding,
2439    $data: scope,
2440    watch,
2441    walk,
2442    data,
2443    bind: bind2
2444  };
2445  var alpine_default = Alpine2;
2446  function makeMap(str, expectsLowerCase) {
2447    const map = /* @__PURE__ */ Object.create(null);
2448    const list = str.split(",");
2449    for (let i = 0; i < list.length; i++) {
2450      map[list[i]] = true;
2451    }
2452    return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];
2453  }
2454  var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
2455  var isBooleanAttr2 = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`);
2456  var EMPTY_OBJ = true ? Object.freeze({}) : {};
2457  var EMPTY_ARR = true ? Object.freeze([]) : [];
2458  var hasOwnProperty = Object.prototype.hasOwnProperty;
2459  var hasOwn = (val, key) => hasOwnProperty.call(val, key);
2460  var isArray2 = Array.isArray;
2461  var isMap = (val) => toTypeString(val) === "[object Map]";
2462  var isString = (val) => typeof val === "string";
2463  var isSymbol = (val) => typeof val === "symbol";
2464  var isObject2 = (val) => val !== null && typeof val === "object";
2465  var objectToString = Object.prototype.toString;
2466  var toTypeString = (value) => objectToString.call(value);
2467  var toRawType = (value) => {
2468    return toTypeString(value).slice(8, -1);
2469  };
2470  var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
2471  var cacheStringFunction = (fn) => {
2472    const cache = /* @__PURE__ */ Object.create(null);
2473    return (str) => {
2474      const hit = cache[str];
2475      return hit || (cache[str] = fn(str));
2476    };
2477  };
2478  var camelizeRE = /-(\w)/g;
2479  var camelize = cacheStringFunction((str) => {
2480    return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
2481  });
2482  var hyphenateRE = /\B([A-Z])/g;
2483  var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
2484  var capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
2485  var toHandlerKey = cacheStringFunction((str) => str ? `on${capitalize(str)}` : ``);
2486  var hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);
2487  var targetMap = /* @__PURE__ */ new WeakMap();
2488  var effectStack = [];
2489  var activeEffect;
2490  var ITERATE_KEY = Symbol(true ? "iterate" : "");
2491  var MAP_KEY_ITERATE_KEY = Symbol(true ? "Map key iterate" : "");
2492  function isEffect(fn) {
2493    return fn && fn._isEffect === true;
2494  }
2495  function effect2(fn, options = EMPTY_OBJ) {
2496    if (isEffect(fn)) {
2497      fn = fn.raw;
2498    }
2499    const effect3 = createReactiveEffect(fn, options);
2500    if (!options.lazy) {
2501      effect3();
2502    }
2503    return effect3;
2504  }
2505  function stop(effect3) {
2506    if (effect3.active) {
2507      cleanup(effect3);
2508      if (effect3.options.onStop) {
2509        effect3.options.onStop();
2510      }
2511      effect3.active = false;
2512    }
2513  }
2514  var uid = 0;
2515  function createReactiveEffect(fn, options) {
2516    const effect3 = function reactiveEffect() {
2517      if (!effect3.active) {
2518        return fn();
2519      }
2520      if (!effectStack.includes(effect3)) {
2521        cleanup(effect3);
2522        try {
2523          enableTracking();
2524          effectStack.push(effect3);
2525          activeEffect = effect3;
2526          return fn();
2527        } finally {
2528          effectStack.pop();
2529          resetTracking();
2530          activeEffect = effectStack[effectStack.length - 1];
2531        }
2532      }
2533    };
2534    effect3.id = uid++;
2535    effect3.allowRecurse = !!options.allowRecurse;
2536    effect3._isEffect = true;
2537    effect3.active = true;
2538    effect3.raw = fn;
2539    effect3.deps = [];
2540    effect3.options = options;
2541    return effect3;
2542  }
2543  function cleanup(effect3) {
2544    const { deps } = effect3;
2545    if (deps.length) {
2546      for (let i = 0; i < deps.length; i++) {
2547        deps[i].delete(effect3);
2548      }
2549      deps.length = 0;
2550    }
2551  }
2552  var shouldTrack = true;
2553  var trackStack = [];
2554  function pauseTracking() {
2555    trackStack.push(shouldTrack);
2556    shouldTrack = false;
2557  }
2558  function enableTracking() {
2559    trackStack.push(shouldTrack);
2560    shouldTrack = true;
2561  }
2562  function resetTracking() {
2563    const last = trackStack.pop();
2564    shouldTrack = last === void 0 ? true : last;
2565  }
2566  function track(target, type, key) {
2567    if (!shouldTrack || activeEffect === void 0) {
2568      return;
2569    }
2570    let depsMap = targetMap.get(target);
2571    if (!depsMap) {
2572      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
2573    }
2574    let dep = depsMap.get(key);
2575    if (!dep) {
2576      depsMap.set(key, dep = /* @__PURE__ */ new Set());
2577    }
2578    if (!dep.has(activeEffect)) {
2579      dep.add(activeEffect);
2580      activeEffect.deps.push(dep);
2581      if (activeEffect.options.onTrack) {
2582        activeEffect.options.onTrack({
2583          effect: activeEffect,
2584          target,
2585          type,
2586          key
2587        });
2588      }
2589    }
2590  }
2591  function trigger(target, type, key, newValue, oldValue, oldTarget) {
2592    const depsMap = targetMap.get(target);
2593    if (!depsMap) {
2594      return;
2595    }
2596    const effects = /* @__PURE__ */ new Set();
2597    const add2 = (effectsToAdd) => {
2598      if (effectsToAdd) {
2599        effectsToAdd.forEach((effect3) => {
2600          if (effect3 !== activeEffect || effect3.allowRecurse) {
2601            effects.add(effect3);
2602          }
2603        });
2604      }
2605    };
2606    if (type === "clear") {
2607      depsMap.forEach(add2);
2608    } else if (key === "length" && isArray2(target)) {
2609      depsMap.forEach((dep, key2) => {
2610        if (key2 === "length" || key2 >= newValue) {
2611          add2(dep);
2612        }
2613      });
2614    } else {
2615      if (key !== void 0) {
2616        add2(depsMap.get(key));
2617      }
2618      switch (type) {
2619        case "add":
2620          if (!isArray2(target)) {
2621            add2(depsMap.get(ITERATE_KEY));
2622            if (isMap(target)) {
2623              add2(depsMap.get(MAP_KEY_ITERATE_KEY));
2624            }
2625          } else if (isIntegerKey(key)) {
2626            add2(depsMap.get("length"));
2627          }
2628          break;
2629        case "delete":
2630          if (!isArray2(target)) {
2631            add2(depsMap.get(ITERATE_KEY));
2632            if (isMap(target)) {
2633              add2(depsMap.get(MAP_KEY_ITERATE_KEY));
2634            }
2635          }
2636          break;
2637        case "set":
2638          if (isMap(target)) {
2639            add2(depsMap.get(ITERATE_KEY));
2640          }
2641          break;
2642      }
2643    }
2644    const run = (effect3) => {
2645      if (effect3.options.onTrigger) {
2646        effect3.options.onTrigger({
2647          effect: effect3,
2648          target,
2649          key,
2650          type,
2651          newValue,
2652          oldValue,
2653          oldTarget
2654        });
2655      }
2656      if (effect3.options.scheduler) {
2657        effect3.options.scheduler(effect3);
2658      } else {
2659        effect3();
2660      }
2661    };
2662    effects.forEach(run);
2663  }
2664  var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
2665  var builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map((key) => Symbol[key]).filter(isSymbol));
2666  var get2 = /* @__PURE__ */ createGetter();
2667  var readonlyGet = /* @__PURE__ */ createGetter(true);
2668  var arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
2669  function createArrayInstrumentations() {
2670    const instrumentations = {};
2671    ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
2672      instrumentations[key] = function(...args) {
2673        const arr = toRaw(this);
2674        for (let i = 0, l = this.length; i < l; i++) {
2675          track(arr, "get", i + "");
2676        }
2677        const res = arr[key](...args);
2678        if (res === -1 || res === false) {
2679          return arr[key](...args.map(toRaw));
2680        } else {
2681          return res;
2682        }
2683      };
2684    });
2685    ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
2686      instrumentations[key] = function(...args) {
2687        pauseTracking();
2688        const res = toRaw(this)[key].apply(this, args);
2689        resetTracking();
2690        return res;
2691      };
2692    });
2693    return instrumentations;
2694  }
2695  function createGetter(isReadonly = false, shallow = false) {
2696    return function get3(target, key, receiver) {
2697      if (key === "__v_isReactive") {
2698        return !isReadonly;
2699      } else if (key === "__v_isReadonly") {
2700        return isReadonly;
2701      } else if (key === "__v_raw" && receiver === (isReadonly ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
2702        return target;
2703      }
2704      const targetIsArray = isArray2(target);
2705      if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
2706        return Reflect.get(arrayInstrumentations, key, receiver);
2707      }
2708      const res = Reflect.get(target, key, receiver);
2709      if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
2710        return res;
2711      }
2712      if (!isReadonly) {
2713        track(target, "get", key);
2714      }
2715      if (shallow) {
2716        return res;
2717      }
2718      if (isRef(res)) {
2719        const shouldUnwrap = !targetIsArray || !isIntegerKey(key);
2720        return shouldUnwrap ? res.value : res;
2721      }
2722      if (isObject2(res)) {
2723        return isReadonly ? readonly(res) : reactive2(res);
2724      }
2725      return res;
2726    };
2727  }
2728  var set2 = /* @__PURE__ */ createSetter();
2729  function createSetter(shallow = false) {
2730    return function set3(target, key, value, receiver) {
2731      let oldValue = target[key];
2732      if (!shallow) {
2733        value = toRaw(value);
2734        oldValue = toRaw(oldValue);
2735        if (!isArray2(target) && isRef(oldValue) && !isRef(value)) {
2736          oldValue.value = value;
2737          return true;
2738        }
2739      }
2740      const hadKey = isArray2(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
2741      const result = Reflect.set(target, key, value, receiver);
2742      if (target === toRaw(receiver)) {
2743        if (!hadKey) {
2744          trigger(target, "add", key, value);
2745        } else if (hasChanged(value, oldValue)) {
2746          trigger(target, "set", key, value, oldValue);
2747        }
2748      }
2749      return result;
2750    };
2751  }
2752  function deleteProperty(target, key) {
2753    const hadKey = hasOwn(target, key);
2754    const oldValue = target[key];
2755    const result = Reflect.deleteProperty(target, key);
2756    if (result && hadKey) {
2757      trigger(target, "delete", key, void 0, oldValue);
2758    }
2759    return result;
2760  }
2761  function has(target, key) {
2762    const result = Reflect.has(target, key);
2763    if (!isSymbol(key) || !builtInSymbols.has(key)) {
2764      track(target, "has", key);
2765    }
2766    return result;
2767  }
2768  function ownKeys(target) {
2769    track(target, "iterate", isArray2(target) ? "length" : ITERATE_KEY);
2770    return Reflect.ownKeys(target);
2771  }
2772  var mutableHandlers = {
2773    get: get2,
2774    set: set2,
2775    deleteProperty,
2776    has,
2777    ownKeys
2778  };
2779  var readonlyHandlers = {
2780    get: readonlyGet,
2781    set(target, key) {
2782      if (true) {
2783        console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
2784      }
2785      return true;
2786    },
2787    deleteProperty(target, key) {
2788      if (true) {
2789        console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
2790      }
2791      return true;
2792    }
2793  };
2794  var toReactive = (value) => isObject2(value) ? reactive2(value) : value;
2795  var toReadonly = (value) => isObject2(value) ? readonly(value) : value;
2796  var toShallow = (value) => value;
2797  var getProto = (v) => Reflect.getPrototypeOf(v);
2798  function get$1(target, key, isReadonly = false, isShallow = false) {
2799    target = target["__v_raw"];
2800    const rawTarget = toRaw(target);
2801    const rawKey = toRaw(key);
2802    if (key !== rawKey) {
2803      !isReadonly && track(rawTarget, "get", key);
2804    }
2805    !isReadonly && track(rawTarget, "get", rawKey);
2806    const { has: has2 } = getProto(rawTarget);
2807    const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
2808    if (has2.call(rawTarget, key)) {
2809      return wrap(target.get(key));
2810    } else if (has2.call(rawTarget, rawKey)) {
2811      return wrap(target.get(rawKey));
2812    } else if (target !== rawTarget) {
2813      target.get(key);
2814    }
2815  }
2816  function has$1(key, isReadonly = false) {
2817    const target = this["__v_raw"];
2818    const rawTarget = toRaw(target);
2819    const rawKey = toRaw(key);
2820    if (key !== rawKey) {
2821      !isReadonly && track(rawTarget, "has", key);
2822    }
2823    !isReadonly && track(rawTarget, "has", rawKey);
2824    return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
2825  }
2826  function size(target, isReadonly = false) {
2827    target = target["__v_raw"];
2828    !isReadonly && track(toRaw(target), "iterate", ITERATE_KEY);
2829    return Reflect.get(target, "size", target);
2830  }
2831  function add(value) {
2832    value = toRaw(value);
2833    const target = toRaw(this);
2834    const proto = getProto(target);
2835    const hadKey = proto.has.call(target, value);
2836    if (!hadKey) {
2837      target.add(value);
2838      trigger(target, "add", value, value);
2839    }
2840    return this;
2841  }
2842  function set$1(key, value) {
2843    value = toRaw(value);
2844    const target = toRaw(this);
2845    const { has: has2, get: get3 } = getProto(target);
2846    let hadKey = has2.call(target, key);
2847    if (!hadKey) {
2848      key = toRaw(key);
2849      hadKey = has2.call(target, key);
2850    } else if (true) {
2851      checkIdentityKeys(target, has2, key);
2852    }
2853    const oldValue = get3.call(target, key);
2854    target.set(key, value);
2855    if (!hadKey) {
2856      trigger(target, "add", key, value);
2857    } else if (hasChanged(value, oldValue)) {
2858      trigger(target, "set", key, value, oldValue);
2859    }
2860    return this;
2861  }
2862  function deleteEntry(key) {
2863    const target = toRaw(this);
2864    const { has: has2, get: get3 } = getProto(target);
2865    let hadKey = has2.call(target, key);
2866    if (!hadKey) {
2867      key = toRaw(key);
2868      hadKey = has2.call(target, key);
2869    } else if (true) {
2870      checkIdentityKeys(target, has2, key);
2871    }
2872    const oldValue = get3 ? get3.call(target, key) : void 0;
2873    const result = target.delete(key);
2874    if (hadKey) {
2875      trigger(target, "delete", key, void 0, oldValue);
2876    }
2877    return result;
2878  }
2879  function clear() {
2880    const target = toRaw(this);
2881    const hadItems = target.size !== 0;
2882    const oldTarget = true ? isMap(target) ? new Map(target) : new Set(target) : void 0;
2883    const result = target.clear();
2884    if (hadItems) {
2885      trigger(target, "clear", void 0, void 0, oldTarget);
2886    }
2887    return result;
2888  }
2889  function createForEach(isReadonly, isShallow) {
2890    return function forEach(callback, thisArg) {
2891      const observed = this;
2892      const target = observed["__v_raw"];
2893      const rawTarget = toRaw(target);
2894      const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
2895      !isReadonly && track(rawTarget, "iterate", ITERATE_KEY);
2896      return target.forEach((value, key) => {
2897        return callback.call(thisArg, wrap(value), wrap(key), observed);
2898      });
2899    };
2900  }
2901  function createIterableMethod(method, isReadonly, isShallow) {
2902    return function(...args) {
2903      const target = this["__v_raw"];
2904      const rawTarget = toRaw(target);
2905      const targetIsMap = isMap(rawTarget);
2906      const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
2907      const isKeyOnly = method === "keys" && targetIsMap;
2908      const innerIterator = target[method](...args);
2909      const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
2910      !isReadonly && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
2911      return {
2912        next() {
2913          const { value, done } = innerIterator.next();
2914          return done ? { value, done } : {
2915            value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
2916            done
2917          };
2918        },
2919        [Symbol.iterator]() {
2920          return this;
2921        }
2922      };
2923    };
2924  }
2925  function createReadonlyMethod(type) {
2926    return function(...args) {
2927      if (true) {
2928        const key = args[0] ? `on key "${args[0]}" ` : ``;
2929        console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
2930      }
2931      return type === "delete" ? false : this;
2932    };
2933  }
2934  function createInstrumentations() {
2935    const mutableInstrumentations2 = {
2936      get(key) {
2937        return get$1(this, key);
2938      },
2939      get size() {
2940        return size(this);
2941      },
2942      has: has$1,
2943      add,
2944      set: set$1,
2945      delete: deleteEntry,
2946      clear,
2947      forEach: createForEach(false, false)
2948    };
2949    const shallowInstrumentations2 = {
2950      get(key) {
2951        return get$1(this, key, false, true);
2952      },
2953      get size() {
2954        return size(this);
2955      },
2956      has: has$1,
2957      add,
2958      set: set$1,
2959      delete: deleteEntry,
2960      clear,
2961      forEach: createForEach(false, true)
2962    };
2963    const readonlyInstrumentations2 = {
2964      get(key) {
2965        return get$1(this, key, true);
2966      },
2967      get size() {
2968        return size(this, true);
2969      },
2970      has(key) {
2971        return has$1.call(this, key, true);
2972      },
2973      add: createReadonlyMethod("add"),
2974      set: createReadonlyMethod("set"),
2975      delete: createReadonlyMethod("delete"),
2976      clear: createReadonlyMethod("clear"),
2977      forEach: createForEach(true, false)
2978    };
2979    const shallowReadonlyInstrumentations2 = {
2980      get(key) {
2981        return get$1(this, key, true, true);
2982      },
2983      get size() {
2984        return size(this, true);
2985      },
2986      has(key) {
2987        return has$1.call(this, key, true);
2988      },
2989      add: createReadonlyMethod("add"),
2990      set: createReadonlyMethod("set"),
2991      delete: createReadonlyMethod("delete"),
2992      clear: createReadonlyMethod("clear"),
2993      forEach: createForEach(true, true)
2994    };
2995    const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
2996    iteratorMethods.forEach((method) => {
2997      mutableInstrumentations2[method] = createIterableMethod(method, false, false);
2998      readonlyInstrumentations2[method] = createIterableMethod(method, true, false);
2999      shallowInstrumentations2[method] = createIterableMethod(method, false, true);
3000      shallowReadonlyInstrumentations2[method] = createIterableMethod(method, true, true);
3001    });
3002    return [
3003      mutableInstrumentations2,
3004      readonlyInstrumentations2,
3005      shallowInstrumentations2,
3006      shallowReadonlyInstrumentations2
3007    ];
3008  }
3009  var [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* @__PURE__ */ createInstrumentations();
3010  function createInstrumentationGetter(isReadonly, shallow) {
3011    const instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations;
3012    return (target, key, receiver) => {
3013      if (key === "__v_isReactive") {
3014        return !isReadonly;
3015      } else if (key === "__v_isReadonly") {
3016        return isReadonly;
3017      } else if (key === "__v_raw") {
3018        return target;
3019      }
3020      return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
3021    };
3022  }
3023  var mutableCollectionHandlers = {
3024    get: /* @__PURE__ */ createInstrumentationGetter(false, false)
3025  };
3026  var readonlyCollectionHandlers = {
3027    get: /* @__PURE__ */ createInstrumentationGetter(true, false)
3028  };
3029  function checkIdentityKeys(target, has2, key) {
3030    const rawKey = toRaw(key);
3031    if (rawKey !== key && has2.call(target, rawKey)) {
3032      const type = toRawType(target);
3033      console.warn(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`);
3034    }
3035  }
3036  var reactiveMap = /* @__PURE__ */ new WeakMap();
3037  var shallowReactiveMap = /* @__PURE__ */ new WeakMap();
3038  var readonlyMap = /* @__PURE__ */ new WeakMap();
3039  var shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
3040  function targetTypeMap(rawType) {
3041    switch (rawType) {
3042      case "Object":
3043      case "Array":
3044        return 1;
3045      case "Map":
3046      case "Set":
3047      case "WeakMap":
3048      case "WeakSet":
3049        return 2;
3050      default:
3051        return 0;
3052    }
3053  }
3054  function getTargetType(value) {
3055    return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
3056  }
3057  function reactive2(target) {
3058    if (target && target["__v_isReadonly"]) {
3059      return target;
3060    }
3061    return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
3062  }
3063  function readonly(target) {
3064    return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
3065  }
3066  function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
3067    if (!isObject2(target)) {
3068      if (true) {
3069        console.warn(`value cannot be made reactive: ${String(target)}`);
3070      }
3071      return target;
3072    }
3073    if (target["__v_raw"] && !(isReadonly && target["__v_isReactive"])) {
3074      return target;
3075    }
3076    const existingProxy = proxyMap.get(target);
3077    if (existingProxy) {
3078      return existingProxy;
3079    }
3080    const targetType = getTargetType(target);
3081    if (targetType === 0) {
3082      return target;
3083    }
3084    const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
3085    proxyMap.set(target, proxy);
3086    return proxy;
3087  }
3088  function toRaw(observed) {
3089    return observed && toRaw(observed["__v_raw"]) || observed;
3090  }
3091  function isRef(r) {
3092    return Boolean(r && r.__v_isRef === true);
3093  }
3094  magic("nextTick", () => nextTick);
3095  magic("dispatch", (el) => dispatch2.bind(dispatch2, el));
3096  magic("watch", (el, { evaluateLater: evaluateLater2, cleanup: cleanup2 }) => (key, callback) => {
3097    let evaluate22 = evaluateLater2(key);
3098    let getter = () => {
3099      let value;
3100      evaluate22((i) => value = i);
3101      return value;
3102    };
3103    let unwatch = watch(getter, callback);
3104    cleanup2(unwatch);
3105  });
3106  magic("store", getStores);
3107  magic("data", (el) => scope(el));
3108  magic("root", (el) => closestRoot(el));
3109  magic("refs", (el) => {
3110    if (el._x_refs_proxy)
3111      return el._x_refs_proxy;
3112    el._x_refs_proxy = mergeProxies(getArrayOfRefObject(el));
3113    return el._x_refs_proxy;
3114  });
3115  function getArrayOfRefObject(el) {
3116    let refObjects = [];
3117    findClosest(el, (i) => {
3118      if (i._x_refs)
3119        refObjects.push(i._x_refs);
3120    });
3121    return refObjects;
3122  }
3123  var globalIdMemo = {};
3124  function findAndIncrementId(name) {
3125    if (!globalIdMemo[name])
3126      globalIdMemo[name] = 0;
3127    return ++globalIdMemo[name];
3128  }
3129  function closestIdRoot(el, name) {
3130    return findClosest(el, (element) => {
3131      if (element._x_ids && element._x_ids[name])
3132        return true;
3133    });
3134  }
3135  function setIdRoot(el, name) {
3136    if (!el._x_ids)
3137      el._x_ids = {};
3138    if (!el._x_ids[name])
3139      el._x_ids[name] = findAndIncrementId(name);
3140  }
3141  magic("id", (el, { cleanup: cleanup2 }) => (name, key = null) => {
3142    let cacheKey = `${name}${key ? `-${key}` : ""}`;
3143    return cacheIdByNameOnElement(el, cacheKey, cleanup2, () => {
3144      let root = closestIdRoot(el, name);
3145      let id = root ? root._x_ids[name] : findAndIncrementId(name);
3146      return key ? `${name}-${id}-${key}` : `${name}-${id}`;
3147    });
3148  });
3149  interceptClone((from, to) => {
3150    if (from._x_id) {
3151      to._x_id = from._x_id;
3152    }
3153  });
3154  function cacheIdByNameOnElement(el, cacheKey, cleanup2, callback) {
3155    if (!el._x_id)
3156      el._x_id = {};
3157    if (el._x_id[cacheKey])
3158      return el._x_id[cacheKey];
3159    let output = callback();
3160    el._x_id[cacheKey] = output;
3161    cleanup2(() => {
3162      delete el._x_id[cacheKey];
3163    });
3164    return output;
3165  }
3166  magic("el", (el) => el);
3167  warnMissingPluginMagic("Focus", "focus", "focus");
3168  warnMissingPluginMagic("Persist", "persist", "persist");
3169  function warnMissingPluginMagic(name, magicName, slug) {
3170    magic(magicName, (el) => warn(`You can't use [$${magicName}] without first installing the "${name}" plugin here: https://alpinejs.dev/plugins/${slug}`, el));
3171  }
3172  directive("modelable", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2, cleanup: cleanup2 }) => {
3173    let func = evaluateLater2(expression);
3174    let innerGet = () => {
3175      let result;
3176      func((i) => result = i);
3177      return result;
3178    };
3179    let evaluateInnerSet = evaluateLater2(`${expression} = __placeholder`);
3180    let innerSet = (val) => evaluateInnerSet(() => {
3181    }, { scope: { "__placeholder": val } });
3182    let initialValue = innerGet();
3183    innerSet(initialValue);
3184    queueMicrotask(() => {
3185      if (!el._x_model)
3186        return;
3187      el._x_removeModelListeners["default"]();
3188      let outerGet = el._x_model.get;
3189      let outerSet = el._x_model.setWithModifiers;
3190      let releaseEntanglement = entangle({
3191        get() {
3192          return outerGet();
3193        },
3194        set(value) {
3195          outerSet(value);
3196        }
3197      }, {
3198        get() {
3199          return innerGet();
3200        },
3201        set(value) {
3202          innerSet(value);
3203        }
3204      });
3205      cleanup2(releaseEntanglement);
3206    });
3207  });
3208  directive("teleport", (el, { modifiers, expression }, { cleanup: cleanup2 }) => {
3209    if (el.tagName.toLowerCase() !== "template")
3210      warn("x-teleport can only be used on a <template> tag", el);
3211    let target = getTarget(expression);
3212    let clone2 = el.content.cloneNode(true).firstElementChild;
3213    el._x_teleport = clone2;
3214    clone2._x_teleportBack = el;
3215    el.setAttribute("data-teleport-template", true);
3216    clone2.setAttribute("data-teleport-target", true);
3217    if (el._x_forwardEvents) {
3218      el._x_forwardEvents.forEach((eventName) => {
3219        clone2.addEventListener(eventName, (e) => {
3220          e.stopPropagation();
3221          el.dispatchEvent(new e.constructor(e.type, e));
3222        });
3223      });
3224    }
3225    addScopeToNode(clone2, {}, el);
3226    let placeInDom = (clone3, target2, modifiers2) => {
3227      if (modifiers2.includes("prepend")) {
3228        target2.parentNode.insertBefore(clone3, target2);
3229      } else if (modifiers2.includes("append")) {
3230        target2.parentNode.insertBefore(clone3, target2.nextSibling);
3231      } else {
3232        target2.appendChild(clone3);
3233      }
3234    };
3235    mutateDom(() => {
3236      placeInDom(clone2, target, modifiers);
3237      skipDuringClone(() => {
3238        initTree(clone2);
3239      })();
3240    });
3241    el._x_teleportPutBack = () => {
3242      let target2 = getTarget(expression);
3243      mutateDom(() => {
3244        placeInDom(el._x_teleport, target2, modifiers);
3245      });
3246    };
3247    cleanup2(() => mutateDom(() => {
3248      clone2.remove();
3249      destroyTree(clone2);
3250    }));
3251  });
3252  var teleportContainerDuringClone = document.createElement("div");
3253  function getTarget(expression) {
3254    let target = skipDuringClone(() => {
3255      return document.querySelector(expression);
3256    }, () => {
3257      return teleportContainerDuringClone;
3258    })();
3259    if (!target)
3260      warn(`Cannot find x-teleport element for selector: "${expression}"`);
3261    return target;
3262  }
3263  var handler = () => {
3264  };
3265  handler.inline = (el, { modifiers }, { cleanup: cleanup2 }) => {
3266    modifiers.includes("self") ? el._x_ignoreSelf = true : el._x_ignore = true;
3267    cleanup2(() => {
3268      modifiers.includes("self") ? delete el._x_ignoreSelf : delete el._x_ignore;
3269    });
3270  };
3271  directive("ignore", handler);
3272  directive("effect", skipDuringClone((el, { expression }, { effect: effect3 }) => {
3273    effect3(evaluateLater(el, expression));
3274  }));
3275  function on(el, event, modifiers, callback) {
3276    let listenerTarget = el;
3277    let handler4 = (e) => callback(e);
3278    let options = {};
3279    let wrapHandler = (callback2, wrapper) => (e) => wrapper(callback2, e);
3280    if (modifiers.includes("dot"))
3281      event = dotSyntax(event);
3282    if (modifiers.includes("camel"))
3283      event = camelCase2(event);
3284    if (modifiers.includes("capture"))
3285      options.capture = true;
3286    if (modifiers.includes("window"))
3287      listenerTarget = window;
3288    if (modifiers.includes("document"))
3289      listenerTarget = document;
3290    if (modifiers.includes("passive")) {
3291      options.passive = modifiers[modifiers.indexOf("passive") + 1] !== "false";
3292    }
3293    handler4 = addDebounceOrThrottle(modifiers, handler4);
3294    if (modifiers.includes("prevent"))
3295      handler4 = wrapHandler(handler4, (next, e) => {
3296        e.preventDefault();
3297        next(e);
3298      });
3299    if (modifiers.includes("stop"))
3300      handler4 = wrapHandler(handler4, (next, e) => {
3301        e.stopPropagation();
3302        next(e);
3303      });
3304    if (modifiers.includes("once")) {
3305      handler4 = wrapHandler(handler4, (next, e) => {
3306        next(e);
3307        listenerTarget.removeEventListener(event, handler4, options);
3308      });
3309    }
3310    if (modifiers.includes("away") || modifiers.includes("outside")) {
3311      listenerTarget = document;
3312      handler4 = wrapHandler(handler4, (next, e) => {
3313        if (el.contains(e.target))
3314          return;
3315        if (e.target.isConnected === false)
3316          return;
3317        if (el.offsetWidth < 1 && el.offsetHeight < 1)
3318          return;
3319        if (el._x_isShown === false)
3320          return;
3321        next(e);
3322      });
3323    }
3324    if (modifiers.includes("self"))
3325      handler4 = wrapHandler(handler4, (next, e) => {
3326        e.target === el && next(e);
3327      });
3328    if (event === "submit") {
3329      handler4 = wrapHandler(handler4, (next, e) => {
3330        if (e.target._x_pendingModelUpdates) {
3331          e.target._x_pendingModelUpdates.forEach((fn) => fn());
3332        }
3333        next(e);
3334      });
3335    }
3336    if (isKeyEvent(event) || isClickEvent(event)) {
3337      handler4 = wrapHandler(handler4, (next, e) => {
3338        if (isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers)) {
3339          return;
3340        }
3341        next(e);
3342      });
3343    }
3344    listenerTarget.addEventListener(event, handler4, options);
3345    return () => {
3346      listenerTarget.removeEventListener(event, handler4, options);
3347    };
3348  }
3349  function addDebounceOrThrottle(modifiers, handler4) {
3350    if (modifiers.includes("debounce")) {
3351      let nextModifier = modifiers[modifiers.indexOf("debounce") + 1] || "invalid-wait";
3352      let wait = isNumeric(nextModifier.split("ms")[0]) ? Number(nextModifier.split("ms")[0]) : 250;
3353      handler4 = debounce(handler4, wait);
3354    }
3355    if (modifiers.includes("throttle")) {
3356      let nextModifier = modifiers[modifiers.indexOf("throttle") + 1] || "invalid-wait";
3357      let wait = isNumeric(nextModifier.split("ms")[0]) ? Number(nextModifier.split("ms")[0]) : 250;
3358      handler4 = throttle(handler4, wait);
3359    }
3360    return handler4;
3361  }
3362  function dotSyntax(subject) {
3363    return subject.replace(/-/g, ".");
3364  }
3365  function camelCase2(subject) {
3366    return subject.toLowerCase().replace(/-(\w)/g, (match, char) => char.toUpperCase());
3367  }
3368  function isNumeric(subject) {
3369    return !Array.isArray(subject) && !isNaN(subject);
3370  }
3371  function kebabCase2(subject) {
3372    if ([" ", "_"].includes(subject))
3373      return subject;
3374    return subject.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]/, "-").toLowerCase();
3375  }
3376  function isKeyEvent(event) {
3377    return ["keydown", "keyup"].includes(event);
3378  }
3379  function isClickEvent(event) {
3380    return ["contextmenu", "click", "mouse"].some((i) => event.includes(i));
3381  }
3382  function isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers) {
3383    let keyModifiers = modifiers.filter((i) => {
3384      return !["window", "document", "prevent", "stop", "once", "capture", "self", "away", "outside", "passive", "preserve-scroll", "blur", "change", "lazy"].includes(i);
3385    });
3386    if (keyModifiers.includes("debounce")) {
3387      let debounceIndex = keyModifiers.indexOf("debounce");
3388      keyModifiers.splice(debounceIndex, isNumeric((keyModifiers[debounceIndex + 1] || "invalid-wait").split("ms")[0]) ? 2 : 1);
3389    }
3390    if (keyModifiers.includes("throttle")) {
3391      let debounceIndex = keyModifiers.indexOf("throttle");
3392      keyModifiers.splice(debounceIndex, isNumeric((keyModifiers[debounceIndex + 1] || "invalid-wait").split("ms")[0]) ? 2 : 1);
3393    }
3394    if (keyModifiers.length === 0)
3395      return false;
3396    if (keyModifiers.length === 1 && keyToModifiers(e.key).includes(keyModifiers[0]))
3397      return false;
3398    const systemKeyModifiers = ["ctrl", "shift", "alt", "meta", "cmd", "super"];
3399    const selectedSystemKeyModifiers = systemKeyModifiers.filter((modifier) => keyModifiers.includes(modifier));
3400    keyModifiers = keyModifiers.filter((i) => !selectedSystemKeyModifiers.includes(i));
3401    if (selectedSystemKeyModifiers.length > 0) {
3402      const activelyPressedKeyModifiers = selectedSystemKeyModifiers.filter((modifier) => {
3403        if (modifier === "cmd" || modifier === "super")
3404          modifier = "meta";
3405        return e[`${modifier}Key`];
3406      });
3407      if (activelyPressedKeyModifiers.length === selectedSystemKeyModifiers.length) {
3408        if (isClickEvent(e.type))
3409          return false;
3410        if (keyToModifiers(e.key).includes(keyModifiers[0]))
3411          return false;
3412      }
3413    }
3414    return true;
3415  }
3416  function keyToModifiers(key) {
3417    if (!key)
3418      return [];
3419    key = kebabCase2(key);
3420    let modifierToKeyMap = {
3421      "ctrl": "control",
3422      "slash": "/",
3423      "space": " ",
3424      "spacebar": " ",
3425      "cmd": "meta",
3426      "esc": "escape",
3427      "up": "arrow-up",
3428      "down": "arrow-down",
3429      "left": "arrow-left",
3430      "right": "arrow-right",
3431      "period": ".",
3432      "comma": ",",
3433      "equal": "=",
3434      "minus": "-",
3435      "underscore": "_"
3436    };
3437    modifierToKeyMap[key] = key;
3438    return Object.keys(modifierToKeyMap).map((modifier) => {
3439      if (modifierToKeyMap[modifier] === key)
3440        return modifier;
3441    }).filter((modifier) => modifier);
3442  }
3443  directive("model", (el, { modifiers, expression }, { effect: effect3, cleanup: cleanup2 }) => {
3444    let scopeTarget = el;
3445    if (modifiers.includes("parent")) {
3446      scopeTarget = findClosest(el, (element) => element !== el);
3447    }
3448    let evaluateGet = evaluateLater(scopeTarget, expression);
3449    let evaluateSet;
3450    if (typeof expression === "string") {
3451      evaluateSet = evaluateLater(scopeTarget, `${expression} = __placeholder`);
3452    } else if (typeof expression === "function" && typeof expression() === "string") {
3453      evaluateSet = evaluateLater(scopeTarget, `${expression()} = __placeholder`);
3454    } else {
3455      evaluateSet = () => {
3456      };
3457    }
3458    let getValue = () => {
3459      let result;
3460      evaluateGet((value) => result = value);
3461      return isGetterSetter(result) ? result.get() : result;
3462    };
3463    let setValue = (value) => {
3464      let result;
3465      evaluateGet((value2) => result = value2);
3466      if (isGetterSetter(result)) {
3467        result.set(value);
3468      } else {
3469        evaluateSet(() => {
3470        }, {
3471          scope: { "__placeholder": value }
3472        });
3473      }
3474    };
3475    if (typeof expression === "string" && el.type === "radio") {
3476      mutateDom(() => {
3477        if (!el.hasAttribute("name"))
3478          el.setAttribute("name", expression);
3479      });
3480    }
3481    let hasChangeModifier = modifiers.includes("change") || modifiers.includes("lazy");
3482    let hasBlurModifier = modifiers.includes("blur");
3483    let hasEnterModifier = modifiers.includes("enter");
3484    let hasExplicitEventModifiers = hasChangeModifier || hasBlurModifier || hasEnterModifier;
3485    let removeListener;
3486    if (isCloning) {
3487      removeListener = () => {
3488      };
3489    } else if (hasExplicitEventModifiers) {
3490      let listeners2 = [];
3491      let syncValue = (e) => setValue(getInputValue(el, modifiers, e, getValue()));
3492      if (hasChangeModifier) {
3493        listeners2.push(on(el, "change", modifiers, syncValue));
3494      }
3495      if (hasBlurModifier) {
3496        listeners2.push(on(el, "blur", modifiers, syncValue));
3497        if (el.form) {
3498          let form = el.form;
3499          let syncCallback = () => syncValue({ target: el });
3500          if (!form._x_pendingModelUpdates)
3501            form._x_pendingModelUpdates = [];
3502          form._x_pendingModelUpdates.push(syncCallback);
3503          cleanup2(() => {
3504            if (form._x_pendingModelUpdates) {
3505              form._x_pendingModelUpdates.splice(form._x_pendingModelUpdates.indexOf(syncCallback), 1);
3506            }
3507          });
3508        }
3509      }
3510      if (hasEnterModifier) {
3511        listeners2.push(on(el, "keydown", modifiers, (e) => {
3512          if (e.key === "Enter")
3513            syncValue(e);
3514        }));
3515      }
3516      removeListener = () => listeners2.forEach((remove) => remove());
3517    } else {
3518      let event = el.tagName.toLowerCase() === "select" || ["checkbox", "radio"].includes(el.type) ? "change" : "input";
3519      removeListener = on(el, event, modifiers, (e) => {
3520        setValue(getInputValue(el, modifiers, e, getValue()));
3521      });
3522    }
3523    if (modifiers.includes("fill")) {
3524      if ([void 0, null, ""].includes(getValue()) || isCheckbox(el) && Array.isArray(getValue()) || el.tagName.toLowerCase() === "select" && el.multiple) {
3525        setValue(getInputValue(el, modifiers, { target: el }, getValue()));
3526      }
3527    }
3528    if (!el._x_removeModelListeners)
3529      el._x_removeModelListeners = {};
3530    el._x_removeModelListeners["default"] = removeListener;
3531    cleanup2(() => el._x_removeModelListeners["default"]());
3532    if (el.form) {
3533      let removeResetListener = on(el.form, "reset", [], (e) => {
3534        nextTick(() => el._x_model && el._x_model.set(getInputValue(el, modifiers, { target: el }, getValue())));
3535      });
3536      cleanup2(() => removeResetListener());
3537    }
3538    el._x_model = {
3539      get() {
3540        return getValue();
3541      },
3542      set(value) {
3543        setValue(value);
3544      },
3545      setWithModifiers: addDebounceOrThrottle(modifiers, setValue)
3546    };
3547    el._x_forceModelUpdate = (value) => {
3548      if (value === void 0 && typeof expression === "string" && expression.match(/\./))
3549        value = "";
3550      mutateDom(() => {
3551        if (isCheckbox(el)) {
3552          if (Array.isArray(value)) {
3553            el.checked = value.some((val) => val == el.value);
3554          } else {
3555            el.checked = !!value;
3556          }
3557        } else if (isRadio(el)) {
3558          if (typeof value === "boolean") {
3559            el.checked = safeParseBoolean(el.value) === value;
3560          } else {
3561            el.checked = el.value == value;
3562          }
3563        } else {
3564          bind(el, "value", value);
3565        }
3566      });
3567    };
3568    effect3(() => {
3569      let value = getValue();
3570      if (modifiers.includes("unintrusive") && document.activeElement.isSameNode(el))
3571        return;
3572      el._x_forceModelUpdate(value);
3573    });
3574  });
3575  function getInputValue(el, modifiers, event, currentValue) {
3576    return mutateDom(() => {
3577      if (event instanceof CustomEvent && event.detail !== void 0)
3578        return event.detail !== null && event.detail !== void 0 ? event.detail : event.target.value;
3579      else if (isCheckbox(el)) {
3580        if (Array.isArray(currentValue)) {
3581          let newValue = null;
3582          if (modifiers.includes("number")) {
3583            newValue = safeParseNumber(event.target.value);
3584          } else if (modifiers.includes("boolean")) {
3585            newValue = safeParseBoolean(event.target.value);
3586          } else {
3587            newValue = event.target.value;
3588          }
3589          return event.target.checked ? currentValue.includes(newValue) ? currentValue : currentValue.concat([newValue]) : currentValue.filter((el2) => !checkedAttrLooseCompare2(el2, newValue));
3590        } else {
3591          return event.target.checked;
3592        }
3593      } else if (el.tagName.toLowerCase() === "select" && el.multiple) {
3594        if (modifiers.includes("number")) {
3595          return Array.from(event.target.selectedOptions).map((option) => {
3596            let rawValue = option.value || option.text;
3597            return safeParseNumber(rawValue);
3598          });
3599        } else if (modifiers.includes("boolean")) {
3600          return Array.from(event.target.selectedOptions).map((option) => {
3601            let rawValue = option.value || option.text;
3602            return safeParseBoolean(rawValue);
3603          });
3604        }
3605        return Array.from(event.target.selectedOptions).map((option) => {
3606          return option.value || option.text;
3607        });
3608      } else {
3609        let newValue;
3610        if (isRadio(el)) {
3611          if (event.target.checked) {
3612            newValue = event.target.value;
3613          } else {
3614            newValue = currentValue;
3615          }
3616        } else {
3617          newValue = event.target.value;
3618        }
3619        if (modifiers.includes("number")) {
3620          return safeParseNumber(newValue);
3621        } else if (modifiers.includes("boolean")) {
3622          return safeParseBoolean(newValue);
3623        } else if (modifiers.includes("trim")) {
3624          return newValue.trim();
3625        } else {
3626          return newValue;
3627        }
3628      }
3629    });
3630  }
3631  function safeParseNumber(rawValue) {
3632    let number = rawValue ? parseFloat(rawValue) : null;
3633    return isNumeric2(number) ? number : rawValue;
3634  }
3635  function checkedAttrLooseCompare2(valueA, valueB) {
3636    return valueA == valueB;
3637  }
3638  function isNumeric2(subject) {
3639    return !Array.isArray(subject) && !isNaN(subject);
3640  }
3641  function isGetterSetter(value) {
3642    return value !== null && typeof value === "object" && typeof value.get === "function" && typeof value.set === "function";
3643  }
3644  directive("cloak", (el) => queueMicrotask(() => mutateDom(() => el.removeAttribute(prefix("cloak")))));
3645  addInitSelector(() => `[${prefix("init")}]`);
3646  directive("init", skipDuringClone((el, { expression }, { evaluate: evaluate22 }) => {
3647    if (typeof expression === "string") {
3648      return !!expression.trim() && evaluate22(expression, {}, false);
3649    }
3650    return evaluate22(expression, {}, false);
3651  }));
3652  directive("text", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2 }) => {
3653    let evaluate22 = evaluateLater2(expression);
3654    effect3(() => {
3655      evaluate22((value) => {
3656        mutateDom(() => {
3657          el.textContent = value;
3658        });
3659      });
3660    });
3661  });
3662  directive("html", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2 }) => {
3663    let evaluate22 = evaluateLater2(expression);
3664    effect3(() => {
3665      evaluate22((value) => {
3666        mutateDom(() => {
3667          el.innerHTML = value ?? "";
3668          el._x_ignoreSelf = true;
3669          initTree(el);
3670          delete el._x_ignoreSelf;
3671        });
3672      });
3673    });
3674  });
3675  mapAttributes(startingWith(":", into(prefix("bind:"))));
3676  var handler2 = (el, { value, modifiers, expression, original }, { effect: effect3, cleanup: cleanup2 }) => {
3677    if (!value) {
3678      let bindingProviders = {};
3679      injectBindingProviders(bindingProviders);
3680      let getBindings = evaluateLater(el, expression);
3681      getBindings((bindings) => {
3682        applyBindingsObject(el, bindings, original);
3683      }, { scope: bindingProviders });
3684      return;
3685    }
3686    if (value === "key")
3687      return storeKeyForXFor(el, expression);
3688    if (el._x_inlineBindings && el._x_inlineBindings[value] && el._x_inlineBindings[value].extract) {
3689      return;
3690    }
3691    let evaluate22 = evaluateLater(el, expression);
3692    effect3(() => evaluate22((result) => {
3693      if (result === void 0 && typeof expression === "string" && expression.match(/\./)) {
3694        result = "";
3695      }
3696      mutateDom(() => bind(el, value, result, modifiers));
3697    }));
3698    cleanup2(() => {
3699      el._x_undoAddedClasses && el._x_undoAddedClasses();
3700      el._x_undoAddedStyles && el._x_undoAddedStyles();
3701    });
3702  };
3703  handler2.inline = (el, { value, modifiers, expression }) => {
3704    if (!value)
3705      return;
3706    if (!el._x_inlineBindings)
3707      el._x_inlineBindings = {};
3708    el._x_inlineBindings[value] = { expression, extract: false };
3709  };
3710  directive("bind", handler2);
3711  function storeKeyForXFor(el, expression) {
3712    el._x_keyExpression = expression;
3713  }
3714  addRootSelector(() => `[${prefix("data")}]`);
3715  directive("data", (el, { expression }, { cleanup: cleanup2 }) => {
3716    if (shouldSkipRegisteringDataDuringClone(el))
3717      return;
3718    expression = expression === "" ? "{}" : expression;
3719    let magicContext = {};
3720    injectMagics(magicContext, el);
3721    let dataProviderContext = {};
3722    injectDataProviders(dataProviderContext, magicContext);
3723    let data2 = evaluate(el, expression, { scope: dataProviderContext });
3724    if (data2 === void 0 || data2 === true)
3725      data2 = {};
3726    injectMagics(data2, el);
3727    let reactiveData = reactive(data2);
3728    initInterceptors(reactiveData);
3729    let undo = addScopeToNode(el, reactiveData);
3730    reactiveData["init"] && evaluate(el, reactiveData["init"]);
3731    cleanup2(() => {
3732      reactiveData["destroy"] && evaluate(el, reactiveData["destroy"]);
3733      undo();
3734    });
3735  });
3736  interceptClone((from, to) => {
3737    if (from._x_dataStack) {
3738      to._x_dataStack = from._x_dataStack;
3739      to.setAttribute("data-has-alpine-state", true);
3740    }
3741  });
3742  function shouldSkipRegisteringDataDuringClone(el) {
3743    if (!isCloning)
3744      return false;
3745    if (isCloningLegacy)
3746      return true;
3747    return el.hasAttribute("data-has-alpine-state");
3748  }
3749  directive("show", (el, { modifiers, expression }, { effect: effect3 }) => {
3750    let evaluate22 = evaluateLater(el, expression);
3751    if (!el._x_doHide)
3752      el._x_doHide = () => {
3753        mutateDom(() => {
3754          el.style.setProperty("display", "none", modifiers.includes("important") ? "important" : void 0);
3755        });
3756      };
3757    if (!el._x_doShow)
3758      el._x_doShow = () => {
3759        mutateDom(() => {
3760          if (el.style.length === 1 && el.style.display === "none") {
3761            el.removeAttribute("style");
3762          } else {
3763            el.style.removeProperty("display");
3764          }
3765        });
3766      };
3767    let hide = () => {
3768      el._x_doHide();
3769      el._x_isShown = false;
3770    };
3771    let show = () => {
3772      el._x_doShow();
3773      el._x_isShown = true;
3774    };
3775    let clickAwayCompatibleShow = () => setTimeout(show);
3776    let toggle = once((value) => value ? show() : hide(), (value) => {
3777      if (typeof el._x_toggleAndCascadeWithTransitions === "function") {
3778        el._x_toggleAndCascadeWithTransitions(el, value, show, hide);
3779      } else {
3780        value ? clickAwayCompatibleShow() : hide();
3781      }
3782    });
3783    let oldValue;
3784    let firstTime = true;
3785    effect3(() => evaluate22((value) => {
3786      if (!firstTime && value === oldValue)
3787        return;
3788      if (modifiers.includes("immediate"))
3789        value ? clickAwayCompatibleShow() : hide();
3790      toggle(value);
3791      oldValue = value;
3792      firstTime = false;
3793    }));
3794  });
3795  directive("for", (el, { expression }, { effect: effect3, cleanup: cleanup2 }) => {
3796    let iteratorNames = parseForExpression(expression);
3797    let evaluateItems = evaluateLater(el, iteratorNames.items);
3798    let evaluateKey = evaluateLater(el, el._x_keyExpression || "index");
3799    el._x_lookup = /* @__PURE__ */ new Map();
3800    effect3(() => loop(el, iteratorNames, evaluateItems, evaluateKey));
3801    cleanup2(() => {
3802      el._x_lookup.forEach((el2) => mutateDom(() => {
3803        destroyTree(el2);
3804        el2.remove();
3805      }));
3806      delete el._x_lookup;
3807    });
3808  });
3809  function refreshScope(scope2) {
3810    return (newScope) => {
3811      Object.entries(newScope).forEach(([key, value]) => {
3812        scope2[key] = value;
3813      });
3814    };
3815  }
3816  function loop(templateEl, iteratorNames, evaluateItems, evaluateKey) {
3817    evaluateItems((items) => {
3818      if (isNumeric3(items))
3819        items = Array.from({ length: items }, (_, i) => i + 1);
3820      if (items === void 0)
3821        items = [];
3822      if (items instanceof Set)
3823        items = Array.from(items);
3824      if (items instanceof Map)
3825        items = Array.from(items);
3826      let oldLookup = templateEl._x_lookup;
3827      let lookup = /* @__PURE__ */ new Map();
3828      templateEl._x_lookup = lookup;
3829      let hasStringKeys = isObject22(items);
3830      let scopeEntries = Object.entries(items).map(([index, item]) => {
3831        if (!hasStringKeys)
3832          index = parseInt(index);
3833        let scope2 = getIterationScopeVariables(iteratorNames, item, index, items);
3834        let key;
3835        evaluateKey((innerKey) => {
3836          if (typeof innerKey === "object")
3837            warn("x-for key cannot be an object, it must be a string or an integer", templateEl);
3838          if (oldLookup.has(innerKey)) {
3839            lookup.set(innerKey, oldLookup.get(innerKey));
3840            oldLookup.delete(innerKey);
3841          }
3842          key = innerKey;
3843        }, { scope: { index, ...scope2 } });
3844        return [key, scope2];
3845      });
3846      mutateDom(() => {
3847        oldLookup.forEach((el) => {
3848          destroyTree(el);
3849          el.remove();
3850        });
3851        let added = /* @__PURE__ */ new Set();
3852        let prev = templateEl;
3853        scopeEntries.forEach(([key, scope2]) => {
3854          if (lookup.has(key)) {
3855            let el = lookup.get(key);
3856            el._x_refreshXForScope(scope2);
3857            if (prev.nextElementSibling !== el) {
3858              if (prev.nextElementSibling)
3859                el.replaceWith(prev.nextElementSibling);
3860              prev.after(el);
3861            }
3862            prev = el;
3863            if (el._x_currentIfEl) {
3864              if (el.nextElementSibling !== el._x_currentIfEl)
3865                prev.after(el._x_currentIfEl);
3866              prev = el._x_currentIfEl;
3867            }
3868            return;
3869          }
3870          if (templateEl.content.children.length > 1)
3871            warn("x-for templates require a single root element, additional elements will be ignored.", templateEl);
3872          let clone2 = document.importNode(templateEl.content, true).firstElementChild;
3873          let reactiveScope = reactive(scope2);
3874          addScopeToNode(clone2, reactiveScope, templateEl);
3875          clone2._x_refreshXForScope = refreshScope(reactiveScope);
3876          lookup.set(key, clone2);
3877          added.add(clone2);
3878          prev.after(clone2);
3879          prev = clone2;
3880        });
3881        skipDuringClone(() => added.forEach((clone2) => initTree(clone2)))();
3882      });
3883    });
3884  }
3885  function parseForExpression(expression) {
3886    let forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
3887    let stripParensRE = /^\s*\(|\)\s*$/g;
3888    let forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
3889    let inMatch = expression.match(forAliasRE);
3890    if (!inMatch)
3891      return;
3892    let res = {};
3893    res.items = inMatch[2].trim();
3894    let item = inMatch[1].replace(stripParensRE, "").trim();
3895    let iteratorMatch = item.match(forIteratorRE);
3896    if (iteratorMatch) {
3897      res.item = item.replace(forIteratorRE, "").trim();
3898      res.index = iteratorMatch[1].trim();
3899      if (iteratorMatch[2]) {
3900        res.collection = iteratorMatch[2].trim();
3901      }
3902    } else {
3903      res.item = item;
3904    }
3905    return res;
3906  }
3907  function getIterationScopeVariables(iteratorNames, item, index, items) {
3908    let scopeVariables = {};
3909    if (/^\[.*\]$/.test(iteratorNames.item) && Array.isArray(item)) {
3910      let names = iteratorNames.item.replace("[", "").replace("]", "").split(",").map((i) => i.trim());
3911      names.forEach((name, i) => {
3912        scopeVariables[name] = item[i];
3913      });
3914    } else if (/^\{.*\}$/.test(iteratorNames.item) && !Array.isArray(item) && typeof item === "object") {
3915      let names = iteratorNames.item.replace("{", "").replace("}", "").split(",").map((i) => i.trim());
3916      names.forEach((name) => {
3917        scopeVariables[name] = item[name];
3918      });
3919    } else {
3920      scopeVariables[iteratorNames.item] = item;
3921    }
3922    if (iteratorNames.index)
3923      scopeVariables[iteratorNames.index] = index;
3924    if (iteratorNames.collection)
3925      scopeVariables[iteratorNames.collection] = items;
3926    return scopeVariables;
3927  }
3928  function isNumeric3(subject) {
3929    return !Array.isArray(subject) && !isNaN(subject);
3930  }
3931  function isObject22(subject) {
3932    return typeof subject === "object" && !Array.isArray(subject);
3933  }
3934  function handler3() {
3935  }
3936  handler3.inline = (el, { expression }, { cleanup: cleanup2 }) => {
3937    let root = closestRoot(el);
3938    if (!root)
3939      return;
3940    if (!root._x_refs)
3941      root._x_refs = {};
3942    root._x_refs[expression] = el;
3943    cleanup2(() => delete root._x_refs[expression]);
3944  };
3945  directive("ref", handler3);
3946  directive("if", (el, { expression }, { effect: effect3, cleanup: cleanup2 }) => {
3947    if (el.tagName.toLowerCase() !== "template")
3948      warn("x-if can only be used on a <template> tag", el);
3949    let evaluate22 = evaluateLater(el, expression);
3950    let show = () => {
3951      if (el._x_currentIfEl)
3952        return el._x_currentIfEl;
3953      let clone2 = el.content.cloneNode(true).firstElementChild;
3954      addScopeToNode(clone2, {}, el);
3955      mutateDom(() => {
3956        el.after(clone2);
3957        skipDuringClone(() => initTree(clone2))();
3958      });
3959      el._x_currentIfEl = clone2;
3960      el._x_undoIf = () => {
3961        mutateDom(() => {
3962          destroyTree(clone2);
3963          clone2.remove();
3964        });
3965        delete el._x_currentIfEl;
3966      };
3967      return clone2;
3968    };
3969    let hide = () => {
3970      if (!el._x_undoIf)
3971        return;
3972      el._x_undoIf();
3973      delete el._x_undoIf;
3974    };
3975    effect3(() => evaluate22((value) => {
3976      value ? show() : hide();
3977    }));
3978    cleanup2(() => el._x_undoIf && el._x_undoIf());
3979  });
3980  directive("id", (el, { expression }, { evaluate: evaluate22 }) => {
3981    let names = evaluate22(expression);
3982    names.forEach((name) => setIdRoot(el, name));
3983  });
3984  interceptClone((from, to) => {
3985    if (from._x_ids) {
3986      to._x_ids = from._x_ids;
3987    }
3988  });
3989  mapAttributes(startingWith("@", into(prefix("on:"))));
3990  directive("on", skipDuringClone((el, { value, modifiers, expression }, { cleanup: cleanup2 }) => {
3991    let evaluate22 = expression ? evaluateLater(el, expression) : () => {
3992    };
3993    if (el.tagName.toLowerCase() === "template") {
3994      if (!el._x_forwardEvents)
3995        el._x_forwardEvents = [];
3996      if (!el._x_forwardEvents.includes(value))
3997        el._x_forwardEvents.push(value);
3998    }
3999    let removeListener = on(el, value, modifiers, (e) => {
4000      evaluate22(() => {
4001      }, { scope: { "$event": e }, params: [e] });
4002    });
4003    cleanup2(() => removeListener());
4004  }));
4005  warnMissingPluginDirective("Collapse", "collapse", "collapse");
4006  warnMissingPluginDirective("Intersect", "intersect", "intersect");
4007  warnMissingPluginDirective("Focus", "trap", "focus");
4008  warnMissingPluginDirective("Mask", "mask", "mask");
4009  function warnMissingPluginDirective(name, directiveName, slug) {
4010    directive(directiveName, (el) => warn(`You can't use [x-${directiveName}] without first installing the "${name}" plugin here: https://alpinejs.dev/plugins/${slug}`, el));
4011  }
4012  alpine_default.setEvaluator(normalEvaluator);
4013  alpine_default.setRawEvaluator(normalRawEvaluator);
4014  alpine_default.setReactivityEngine({ reactive: reactive2, effect: effect2, release: stop, raw: toRaw });
4015  var src_default = alpine_default;
4016  var module_default = src_default;
4017
4018