https://bellissima.com/cdn/shop/t/12/assets/app.min.js?v=17141677499625118481769773291

1/******/ (() => { // webpackBootstrap
2/******/ 	var __webpack_modules__ = ({
3

4/***/ "./node_modules/alpinejs/dist/module.esm.js":
5/*!**************************************************!*\
6  !*** ./node_modules/alpinejs/dist/module.esm.js ***!
7  \**************************************************/
8/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
9
10"use strict";
11__webpack_require__.r(__webpack_exports__);
12/* harmony export */ __webpack_require__.d(__webpack_exports__, {
13/* harmony export */   "default": () => (/* binding */ module_default)
14/* harmony export */ });
15// packages/alpinejs/src/scheduler.js
16var flushPending = false;
17var flushing = false;
18var queue = [];
19var lastFlushedIndex = -1;
20function scheduler(callback) {
21  queueJob(callback);
22}
23function queueJob(job) {
24  if (!queue.includes(job))
25    queue.push(job);
26  queueFlush();
27}
28function dequeueJob(job) {
29  let index = queue.indexOf(job);
30  if (index !== -1 && index > lastFlushedIndex)
31    queue.splice(index, 1);
32}
33function queueFlush() {
34  if (!flushing && !flushPending) {
35    flushPending = true;
36    queueMicrotask(flushJobs);
37  }
38}
39function flushJobs() {
40  flushPending = false;
41  flushing = true;
42  for (let i = 0; i < queue.length; i++) {
43    queue[i]();
44    lastFlushedIndex = i;
45  }
46  queue.length = 0;
47  lastFlushedIndex = -1;
48  flushing = false;
49}
50
51// packages/alpinejs/src/reactivity.js
52var reactive;
53var effect;
54var release;
55var raw;
56var shouldSchedule = true;
57function disableEffectScheduling(callback) {
58  shouldSchedule = false;
59  callback();
60  shouldSchedule = true;
61}
62function setReactivityEngine(engine) {
63  reactive = engine.reactive;
64  release = engine.release;
65  effect = (callback) => engine.effect(callback, { scheduler: (task) => {
66    if (shouldSchedule) {
67      scheduler(task);
68    } else {
69      task();
70    }
71  } });
72  raw = engine.raw;
73}
74function overrideEffect(override) {
75  effect = override;
76}
77function elementBoundEffect(el) {
78  let cleanup2 = () => {
79  };
80  let wrappedEffect = (callback) => {
81    let effectReference = effect(callback);
82    if (!el._x_effects) {
83      el._x_effects = /* @__PURE__ */ new Set();
84      el._x_runEffects = () => {
85        el._x_effects.forEach((i) => i());
86      };
87    }
88    el._x_effects.add(effectReference);
89    cleanup2 = () => {
90      if (effectReference === void 0)
91        return;
92      el._x_effects.delete(effectReference);
93      release(effectReference);
94    };
95    return effectReference;
96  };
97  return [wrappedEffect, () => {
98    cleanup2();
99  }];
100}
101
102// packages/alpinejs/src/utils/dispatch.js
103function dispatch(el, name, detail = {}) {
104  el.dispatchEvent(
105    new CustomEvent(name, {
106      detail,
107      bubbles: true,
108      // Allows events to pass the shadow DOM barrier.
109      composed: true,
110      cancelable: true
111    })
112  );
113}
114
115// packages/alpinejs/src/utils/walk.js
116function walk(el, callback) {
117  if (typeof ShadowRoot === "function" && el instanceof ShadowRoot) {
118    Array.from(el.children).forEach((el2) => walk(el2, callback));
119    return;
120  }
121  let skip = false;
122  callback(el, () => skip = true);
123  if (skip)
124    return;
125  let node = el.firstElementChild;
126  while (node) {
127    walk(node, callback, false);
128    node = node.nextElementSibling;
129  }
130}
131
132// packages/alpinejs/src/utils/warn.js
133function warn(message, ...args) {
134  console.warn(`Alpine Warning: ${message}`, ...args);
135}
136
137// packages/alpinejs/src/lifecycle.js
138var started = false;
139function start() {
140  if (started)
141    warn("Alpine has already been initialized on this page. Calling Alpine.start() more than once can cause problems.");
142  started = true;
143  if (!document.body)
144    warn("Unable to initialize. Trying to load Alpine before `<body>` is available. Did you forget to add `defer` in Alpine's `<script>` tag?");
145  dispatch(document, "alpine:init");
146  dispatch(document, "alpine:initializing");
147  startObservingMutations();
148  onElAdded((el) => initTree(el, walk));
149  onElRemoved((el) => destroyTree(el));
150  onAttributesAdded((el, attrs) => {
151    directives(el, attrs).forEach((handle) => handle());
152  });
153  let outNestedComponents = (el) => !closestRoot(el.parentElement, true);
154  Array.from(document.querySelectorAll(allSelectors())).filter(outNestedComponents).forEach((el) => {
155    initTree(el);
156  });
157  dispatch(document, "alpine:initialized");
158}
159var rootSelectorCallbacks = [];
160var initSelectorCallbacks = [];
161function rootSelectors() {
162  return rootSelectorCallbacks.map((fn) => fn());
163}
164function allSelectors() {
165  return rootSelectorCallbacks.concat(initSelectorCallbacks).map((fn) => fn());
166}
167function addRootSelector(selectorCallback) {
168  rootSelectorCallbacks.push(selectorCallback);
169}
170function addInitSelector(selectorCallback) {
171  initSelectorCallbacks.push(selectorCallback);
172}
173function closestRoot(el, includeInitSelectors = false) {
174  return findClosest(el, (element) => {
175    const selectors = includeInitSelectors ? allSelectors() : rootSelectors();
176    if (selectors.some((selector) => element.matches(selector)))
177      return true;
178  });
179}
180function findClosest(el, callback) {
181  if (!el)
182    return;
183  if (callback(el))
184    return el;
185  if (el._x_teleportBack)
186    el = el._x_teleportBack;
187  if (!el.parentElement)
188    return;
189  return findClosest(el.parentElement, callback);
190}
191function isRoot(el) {
192  return rootSelectors().some((selector) => el.matches(selector));
193}
194var initInterceptors = [];
195function interceptInit(callback) {
196  initInterceptors.push(callback);
197}
198function initTree(el, walker = walk, intercept = () => {
199}) {
200  deferHandlingDirectives(() => {
201    walker(el, (el2, skip) => {
202      intercept(el2, skip);
203      initInterceptors.forEach((i) => i(el2, skip));
204      directives(el2, el2.attributes).forEach((handle) => handle());
205      el2._x_ignore && skip();
206    });
207  });
208}
209function destroyTree(root) {
210  walk(root, (el) => {
211    cleanupAttributes(el);
212    cleanupElement(el);
213  });
214}
215
216// packages/alpinejs/src/mutation.js
217var onAttributeAddeds = [];
218var onElRemoveds = [];
219var onElAddeds = [];
220function onElAdded(callback) {
221  onElAddeds.push(callback);
222}
223function onElRemoved(el, callback) {
224  if (typeof callback === "function") {
225    if (!el._x_cleanups)
226      el._x_cleanups = [];
227    el._x_cleanups.push(callback);
228  } else {
229    callback = el;
230    onElRemoveds.push(callback);
231  }
232}
233function onAttributesAdded(callback) {
234  onAttributeAddeds.push(callback);
235}
236function onAttributeRemoved(el, name, callback) {
237  if (!el._x_attributeCleanups)
238    el._x_attributeCleanups = {};
239  if (!el._x_attributeCleanups[name])
240    el._x_attributeCleanups[name] = [];
241  el._x_attributeCleanups[name].push(callback);
242}
243function cleanupAttributes(el, names) {
244  if (!el._x_attributeCleanups)
245    return;
246  Object.entries(el._x_attributeCleanups).forEach(([name, value]) => {
247    if (names === void 0 || names.includes(name)) {
248      value.forEach((i) => i());
249      delete el._x_attributeCleanups[name];
250    }
251  });
252}
253function cleanupElement(el) {
254  if (el._x_cleanups) {
255    while (el._x_cleanups.length)
256      el._x_cleanups.pop()();
257  }
258}
259var observer = new MutationObserver(onMutate);
260var currentlyObserving = false;
261function startObservingMutations() {
262  observer.observe(document, { subtree: true, childList: true, attributes: true, attributeOldValue: true });
263  currentlyObserving = true;
264}
265function stopObservingMutations() {
266  flushObserver();
267  observer.disconnect();
268  currentlyObserving = false;
269}
270var recordQueue = [];
271var willProcessRecordQueue = false;
272function flushObserver() {
273  recordQueue = recordQueue.concat(observer.takeRecords());
274  if (recordQueue.length && !willProcessRecordQueue) {
275    willProcessRecordQueue = true;
276    queueMicrotask(() => {
277      processRecordQueue();
278      willProcessRecordQueue = false;
279    });
280  }
281}
282function processRecordQueue() {
283  onMutate(recordQueue);
284  recordQueue.length = 0;
285}
286function mutateDom(callback) {
287  if (!currentlyObserving)
288    return callback();
289  stopObservingMutations();
290  let result = callback();
291  startObservingMutations();
292  return result;
293}
294var isCollecting = false;
295var deferredMutations = [];
296function deferMutations() {
297  isCollecting = true;
298}
299function flushAndStopDeferringMutations() {
300  isCollecting = false;
301  onMutate(deferredMutations);
302  deferredMutations = [];
303}
304function onMutate(mutations) {
305  if (isCollecting) {
306    deferredMutations = deferredMutations.concat(mutations);
307    return;
308  }
309  let addedNodes = [];
310  let removedNodes = [];
311  let addedAttributes = /* @__PURE__ */ new Map();
312  let removedAttributes = /* @__PURE__ */ new Map();
313  for (let i = 0; i < mutations.length; i++) {
314    if (mutations[i].target._x_ignoreMutationObserver)
315      continue;
316    if (mutations[i].type === "childList") {
317      mutations[i].addedNodes.forEach((node) => node.nodeType === 1 && addedNodes.push(node));
318      mutations[i].removedNodes.forEach((node) => node.nodeType === 1 && removedNodes.push(node));
319    }
320    if (mutations[i].type === "attributes") {
321      let el = mutations[i].target;
322      let name = mutations[i].attributeName;
323      let oldValue = mutations[i].oldValue;
324      let add2 = () => {
325        if (!addedAttributes.has(el))
326          addedAttributes.set(el, []);
327        addedAttributes.get(el).push({ name, value: el.getAttribute(name) });
328      };
329      let remove = () => {
330        if (!removedAttributes.has(el))
331          removedAttributes.set(el, []);
332        removedAttributes.get(el).push(name);
333      };
334      if (el.hasAttribute(name) && oldValue === null) {
335        add2();
336      } else if (el.hasAttribute(name)) {
337        remove();
338        add2();
339      } else {
340        remove();
341      }
342    }
343  }
344  removedAttributes.forEach((attrs, el) => {
345    cleanupAttributes(el, attrs);
346  });
347  addedAttributes.forEach((attrs, el) => {
348    onAttributeAddeds.forEach((i) => i(el, attrs));
349  });
350  for (let node of removedNodes) {
351    if (addedNodes.includes(node))
352      continue;
353    onElRemoveds.forEach((i) => i(node));
354    destroyTree(node);
355  }
356  addedNodes.forEach((node) => {
357    node._x_ignoreSelf = true;
358    node._x_ignore = true;
359  });
360  for (let node of addedNodes) {
361    if (removedNodes.includes(node))
362      continue;
363    if (!node.isConnected)
364      continue;
365    delete node._x_ignoreSelf;
366    delete node._x_ignore;
367    onElAddeds.forEach((i) => i(node));
368    node._x_ignore = true;
369    node._x_ignoreSelf = true;
370  }
371  addedNodes.forEach((node) => {
372    delete node._x_ignoreSelf;
373    delete node._x_ignore;
374  });
375  addedNodes = null;
376  removedNodes = null;
377  addedAttributes = null;
378  removedAttributes = null;
379}
380
381// packages/alpinejs/src/scope.js
382function scope(node) {
383  return mergeProxies(closestDataStack(node));
384}
385function addScopeToNode(node, data2, referenceNode) {
386  node._x_dataStack = [data2, ...closestDataStack(referenceNode || node)];
387  return () => {
388    node._x_dataStack = node._x_dataStack.filter((i) => i !== data2);
389  };
390}
391function closestDataStack(node) {
392  if (node._x_dataStack)
393    return node._x_dataStack;
394  if (typeof ShadowRoot === "function" && node instanceof ShadowRoot) {
395    return closestDataStack(node.host);
396  }
397  if (!node.parentNode) {
398    return [];
399  }
400  return closestDataStack(node.parentNode);
401}
402function mergeProxies(objects) {
403  return new Proxy({ objects }, mergeProxyTrap);
404}
405var mergeProxyTrap = {
406  ownKeys({ objects }) {
407    return Array.from(
408      new Set(objects.flatMap((i) => Object.keys(i)))
409    );
410  },
411  has({ objects }, name) {
412    if (name == Symbol.unscopables)
413      return false;
414    return objects.some(
415      (obj) => Object.prototype.hasOwnProperty.call(obj, name)
416    );
417  },
418  get({ objects }, name, thisProxy) {
419    if (name == "toJSON")
420      return collapseProxies;
421    return Reflect.get(
422      objects.find(
423        (obj) => Object.prototype.hasOwnProperty.call(obj, name)
424      ) || {},
425      name,
426      thisProxy
427    );
428  },
429  set({ objects }, name, value) {
430    return Reflect.set(
431      objects.find(
432        (obj) => Object.prototype.hasOwnProperty.call(obj, name)
433      ) || objects[objects.length - 1],
434      name,
435      value
436    );
437  }
438};
439function collapseProxies() {
440  let keys = Reflect.ownKeys(this);
441  return keys.reduce((acc, key) => {
442    acc[key] = Reflect.get(this, key);
443    return acc;
444  }, {});
445}
446
447// packages/alpinejs/src/interceptor.js
448function initInterceptors2(data2) {
449  let isObject2 = (val) => typeof val === "object" && !Array.isArray(val) && val !== null;
450  let recurse = (obj, basePath = "") => {
451    Object.entries(Object.getOwnPropertyDescriptors(obj)).forEach(([key, { value, enumerable }]) => {
452      if (enumerable === false || value === void 0)
453        return;
454      let path = basePath === "" ? key : `${basePath}.${key}`;
455      if (typeof value === "object" && value !== null && value._x_interceptor) {
456        obj[key] = value.initialize(data2, path, key);
457      } else {
458        if (isObject2(value) && value !== obj && !(value instanceof Element)) {
459          recurse(value, path);
460        }
461      }
462    });
463  };
464  return recurse(data2);
465}
466function interceptor(callback, mutateObj = () => {
467}) {
468  let obj = {
469    initialValue: void 0,
470    _x_interceptor: true,
471    initialize(data2, path, key) {
472      return callback(this.initialValue, () => get(data2, path), (value) => set(data2, path, value), path, key);
473    }
474  };
475  mutateObj(obj);
476  return (initialValue) => {
477    if (typeof initialValue === "object" && initialValue !== null && initialValue._x_interceptor) {
478      let initialize = obj.initialize.bind(obj);
479      obj.initialize = (data2, path, key) => {
480        let innerValue = initialValue.initialize(data2, path, key);
481        obj.initialValue = innerValue;
482        return initialize(data2, path, key);
483      };
484    } else {
485      obj.initialValue = initialValue;
486    }
487    return obj;
488  };
489}
490function get(obj, path) {
491  return path.split(".").reduce((carry, segment) => carry[segment], obj);
492}
493function set(obj, path, value) {
494  if (typeof path === "string")
495    path = path.split(".");
496  if (path.length === 1)
497    obj[path[0]] = value;
498  else if (path.length === 0)
499    throw error;
500  else {
501    if (obj[path[0]])
502      return set(obj[path[0]], path.slice(1), value);
503    else {
504      obj[path[0]] = {};
505      return set(obj[path[0]], path.slice(1), value);
506    }
507  }
508}
509
510// packages/alpinejs/src/magics.js
511var magics = {};
512function magic(name, callback) {
513  magics[name] = callback;
514}
515function injectMagics(obj, el) {
516  Object.entries(magics).forEach(([name, callback]) => {
517    let memoizedUtilities = null;
518    function getUtilities() {
519      if (memoizedUtilities) {
520        return memoizedUtilities;
521      } else {
522        let [utilities, cleanup2] = getElementBoundUtilities(el);
523        memoizedUtilities = { interceptor, ...utilities };
524        onElRemoved(el, cleanup2);
525        return memoizedUtilities;
526      }
527    }
528    Object.defineProperty(obj, `$${name}`, {
529      get() {
530        return callback(el, getUtilities());
531      },
532      enumerable: false
533    });
534  });
535  return obj;
536}
537
538// packages/alpinejs/src/utils/error.js
539function tryCatch(el, expression, callback, ...args) {
540  try {
541    return callback(...args);
542  } catch (e) {
543    handleError(e, el, expression);
544  }
545}
546function handleError(error2, el, expression = void 0) {
547  Object.assign(error2, { el, expression });
548  console.warn(`Alpine Expression Error: ${error2.message}
549
550${expression ? 'Expression: "' + expression + '"\n\n' : ""}`, el);
551  setTimeout(() => {
552    throw error2;
553  }, 0);
554}
555
556// packages/alpinejs/src/evaluator.js
557var shouldAutoEvaluateFunctions = true;
558function dontAutoEvaluateFunctions(callback) {
559  let cache = shouldAutoEvaluateFunctions;
560  shouldAutoEvaluateFunctions = false;
561  let result = callback();
562  shouldAutoEvaluateFunctions = cache;
563  return result;
564}
565function evaluate(el, expression, extras = {}) {
566  let result;
567  evaluateLater(el, expression)((value) => result = value, extras);
568  return result;
569}
570function evaluateLater(...args) {
571  return theEvaluatorFunction(...args);
572}
573var theEvaluatorFunction = normalEvaluator;
574function setEvaluator(newEvaluator) {
575  theEvaluatorFunction = newEvaluator;
576}
577function normalEvaluator(el, expression) {
578  let overriddenMagics = {};
579  injectMagics(overriddenMagics, el);
580  let dataStack = [overriddenMagics, ...closestDataStack(el)];
581  let evaluator = typeof expression === "function" ? generateEvaluatorFromFunction(dataStack, expression) : generateEvaluatorFromString(dataStack, expression, el);
582  return tryCatch.bind(null, el, expression, evaluator);
583}
584function generateEvaluatorFromFunction(dataStack, func) {
585  return (receiver = () => {
586  }, { scope: scope2 = {}, params = [] } = {}) => {
587    let result = func.apply(mergeProxies([scope2, ...dataStack]), params);
588    runIfTypeOfFunction(receiver, result);
589  };
590}
591var evaluatorMemo = {};
592function generateFunctionFromString(expression, el) {
593  if (evaluatorMemo[expression]) {
594    return evaluatorMemo[expression];
595  }
596  let AsyncFunction = Object.getPrototypeOf(async function() {
597  }).constructor;
598  let rightSideSafeExpression = /^[\n\s]*if.*\(.*\)/.test(expression.trim()) || /^(let|const)\s/.test(expression.trim()) ? `(async()=>{ ${expression} })()` : expression;
599  const safeAsyncFunction = () => {
600    try {
601      let func2 = new AsyncFunction(
602        ["__self", "scope"],
603        `with (scope) { __self.result = ${rightSideSafeExpression} }; __self.finished = true; return __self.result;`
604      );
605      Object.defineProperty(func2, "name", {
606        value: `[Alpine] ${expression}`
607      });
608      return func2;
609    } catch (error2) {
610      handleError(error2, el, expression);
611      return Promise.resolve();
612    }
613  };
614  let func = safeAsyncFunction();
615  evaluatorMemo[expression] = func;
616  return func;
617}
618function generateEvaluatorFromString(dataStack, expression, el) {
619  let func = generateFunctionFromString(expression, el);
620  return (receiver = () => {
621  }, { scope: scope2 = {}, params = [] } = {}) => {
622    func.result = void 0;
623    func.finished = false;
624    let completeScope = mergeProxies([scope2, ...dataStack]);
625    if (typeof func === "function") {
626      let promise = func(func, completeScope).catch((error2) => handleError(error2, el, expression));
627      if (func.finished) {
628        runIfTypeOfFunction(receiver, func.result, completeScope, params, el);
629        func.result = void 0;
630      } else {
631        promise.then((result) => {
632          runIfTypeOfFunction(receiver, result, completeScope, params, el);
633        }).catch((error2) => handleError(error2, el, expression)).finally(() => func.result = void 0);
634      }
635    }
636  };
637}
638function runIfTypeOfFunction(receiver, value, scope2, params, el) {
639  if (shouldAutoEvaluateFunctions && typeof value === "function") {
640    let result = value.apply(scope2, params);
641    if (result instanceof Promise) {
642      result.then((i) => runIfTypeOfFunction(receiver, i, scope2, params)).catch((error2) => handleError(error2, el, value));
643    } else {
644      receiver(result);
645    }
646  } else if (typeof value === "object" && value instanceof Promise) {
647    value.then((i) => receiver(i));
648  } else {
649    receiver(value);
650  }
651}
652
653// packages/alpinejs/src/directives.js
654var prefixAsString = "x-";
655function prefix(subject = "") {
656  return prefixAsString + subject;
657}
658function setPrefix(newPrefix) {
659  prefixAsString = newPrefix;
660}
661var directiveHandlers = {};
662function directive(name, callback) {
663  directiveHandlers[name] = callback;
664  return {
665    before(directive2) {
666      if (!directiveHandlers[directive2]) {
667        console.warn(
668          "Cannot find directive `${directive}`. `${name}` will use the default order of execution"
669        );
670        return;
671      }
672      const pos = directiveOrder.indexOf(directive2);
673      directiveOrder.splice(pos >= 0 ? pos : directiveOrder.indexOf("DEFAULT"), 0, name);
674    }
675  };
676}
677function directives(el, attributes, originalAttributeOverride) {
678  attributes = Array.from(attributes);
679  if (el._x_virtualDirectives) {
680    let vAttributes = Object.entries(el._x_virtualDirectives).map(([name, value]) => ({ name, value }));
681    let staticAttributes = attributesOnly(vAttributes);
682    vAttributes = vAttributes.map((attribute) => {
683      if (staticAttributes.find((attr) => attr.name === attribute.name)) {
684        return {
685          name: `x-bind:${attribute.name}`,
686          value: `"${attribute.value}"`
687        };
688      }
689      return attribute;
690    });
691    attributes = attributes.concat(vAttributes);
692  }
693  let transformedAttributeMap = {};
694  let directives2 = attributes.map(toTransformedAttributes((newName, oldName) => transformedAttributeMap[newName] = oldName)).filter(outNonAlpineAttributes).map(toParsedDirectives(transformedAttributeMap, originalAttributeOverride)).sort(byPriority);
695  return directives2.map((directive2) => {
696    return getDirectiveHandler(el, directive2);
697  });
698}
699function attributesOnly(attributes) {
700  return Array.from(attributes).map(toTransformedAttributes()).filter((attr) => !outNonAlpineAttributes(attr));
701}
702var isDeferringHandlers = false;
703var directiveHandlerStacks = /* @__PURE__ */ new Map();
704var currentHandlerStackKey = Symbol();
705function deferHandlingDirectives(callback) {
706  isDeferringHandlers = true;
707  let key = Symbol();
708  currentHandlerStackKey = key;
709  directiveHandlerStacks.set(key, []);
710  let flushHandlers = () => {
711    while (directiveHandlerStacks.get(key).length)
712      directiveHandlerStacks.get(key).shift()();
713    directiveHandlerStacks.delete(key);
714  };
715  let stopDeferring = () => {
716    isDeferringHandlers = false;
717    flushHandlers();
718  };
719  callback(flushHandlers);
720  stopDeferring();
721}
722function getElementBoundUtilities(el) {
723  let cleanups = [];
724  let cleanup2 = (callback) => cleanups.push(callback);
725  let [effect3, cleanupEffect] = elementBoundEffect(el);
726  cleanups.push(cleanupEffect);
727  let utilities = {
728    Alpine: alpine_default,
729    effect: effect3,
730    cleanup: cleanup2,
731    evaluateLater: evaluateLater.bind(evaluateLater, el),
732    evaluate: evaluate.bind(evaluate, el)
733  };
734  let doCleanup = () => cleanups.forEach((i) => i());
735  return [utilities, doCleanup];
736}
737function getDirectiveHandler(el, directive2) {
738  let noop = () => {
739  };
740  let handler4 = directiveHandlers[directive2.type] || noop;
741  let [utilities, cleanup2] = getElementBoundUtilities(el);
742  onAttributeRemoved(el, directive2.original, cleanup2);
743  let fullHandler = () => {
744    if (el._x_ignore || el._x_ignoreSelf)
745      return;
746    handler4.inline && handler4.inline(el, directive2, utilities);
747    handler4 = handler4.bind(handler4, el, directive2, utilities);
748    isDeferringHandlers ? directiveHandlerStacks.get(currentHandlerStackKey).push(handler4) : handler4();
749  };
750  fullHandler.runCleanups = cleanup2;
751  return fullHandler;
752}
753var startingWith = (subject, replacement) => ({ name, value }) => {
754  if (name.startsWith(subject))
755    name = name.replace(subject, replacement);
756  return { name, value };
757};
758var into = (i) => i;
759function toTransformedAttributes(callback = () => {
760}) {
761  return ({ name, value }) => {
762    let { name: newName, value: newValue } = attributeTransformers.reduce((carry, transform) => {
763      return transform(carry);
764    }, { name, value });
765    if (newName !== name)
766      callback(newName, name);
767    return { name: newName, value: newValue };
768  };
769}
770var attributeTransformers = [];
771function mapAttributes(callback) {
772  attributeTransformers.push(callback);
773}
774function outNonAlpineAttributes({ name }) {
775  return alpineAttributeRegex().test(name);
776}
777var alpineAttributeRegex = () => new RegExp(`^${prefixAsString}([^:^.]+)\\b`);
778function toParsedDirectives(transformedAttributeMap, originalAttributeOverride) {
779  return ({ name, value }) => {
780    let typeMatch = name.match(alpineAttributeRegex());
781    let valueMatch = name.match(/:([a-zA-Z0-9\-:]+)/);
782    let modifiers = name.match(/\.[^.\]]+(?=[^\]]*$)/g) || [];
783    let original = originalAttributeOverride || transformedAttributeMap[name] || name;
784    return {
785      type: typeMatch ? typeMatch[1] : null,
786      value: valueMatch ? valueMatch[1] : null,
787      modifiers: modifiers.map((i) => i.replace(".", "")),
788      expression: value,
789      original
790    };
791  };
792}
793var DEFAULT = "DEFAULT";
794var directiveOrder = [
795  "ignore",
796  "ref",
797  "data",
798  "id",
799  "bind",
800  "init",
801  "for",
802  "model",
803  "modelable",
804  "transition",
805  "show",
806  "if",
807  DEFAULT,
808  "teleport"
809];
810function byPriority(a, b) {
811  let typeA = directiveOrder.indexOf(a.type) === -1 ? DEFAULT : a.type;
812  let typeB = directiveOrder.indexOf(b.type) === -1 ? DEFAULT : b.type;
813  return directiveOrder.indexOf(typeA) - directiveOrder.indexOf(typeB);
814}
815
816// packages/alpinejs/src/nextTick.js
817var tickStack = [];
818var isHolding = false;
819function nextTick(callback = () => {
820}) {
821  queueMicrotask(() => {
822    isHolding || setTimeout(() => {
823      releaseNextTicks();
824    });
825  });
826  return new Promise((res) => {
827    tickStack.push(() => {
828      callback();
829      res();
830    });
831  });
832}
833function releaseNextTicks() {
834  isHolding = false;
835  while (tickStack.length)
836    tickStack.shift()();
837}
838function holdNextTicks() {
839  isHolding = true;
840}
841
842// packages/alpinejs/src/utils/classes.js
843function setClasses(el, value) {
844  if (Array.isArray(value)) {
845    return setClassesFromString(el, value.join(" "));
846  } else if (typeof value === "object" && value !== null) {
847    return setClassesFromObject(el, value);
848  } else if (typeof value === "function") {
849    return setClasses(el, value());
850  }
851  return setClassesFromString(el, value);
852}
853function setClassesFromString(el, classString) {
854  let split = (classString2) => classString2.split(" ").filter(Boolean);
855  let missingClasses = (classString2) => classString2.split(" ").filter((i) => !el.classList.contains(i)).filter(Boolean);
856  let addClassesAndReturnUndo = (classes) => {
857    el.classList.add(...classes);
858    return () => {
859      el.classList.remove(...classes);
860    };
861  };
862  classString = classString === true ? classString = "" : classString || "";
863  return addClassesAndReturnUndo(missingClasses(classString));
864}
865function setClassesFromObject(el, classObject) {
866  let split = (classString) => classString.split(" ").filter(Boolean);
867  let forAdd = Object.entries(classObject).flatMap(([classString, bool]) => bool ? split(classString) : false).filter(Boolean);
868  let forRemove = Object.entries(classObject).flatMap(([classString, bool]) => !bool ? split(classString) : false).filter(Boolean);
869  let added = [];
870  let removed = [];
871  forRemove.forEach((i) => {
872    if (el.classList.contains(i)) {
873      el.classList.remove(i);
874      removed.push(i);
875    }
876  });
877  forAdd.forEach((i) => {
878    if (!el.classList.contains(i)) {
879      el.classList.add(i);
880      added.push(i);
881    }
882  });
883  return () => {
884    removed.forEach((i) => el.classList.add(i));
885    added.forEach((i) => el.classList.remove(i));
886  };
887}
888
889// packages/alpinejs/src/utils/styles.js
890function setStyles(el, value) {
891  if (typeof value === "object" && value !== null) {
892    return setStylesFromObject(el, value);
893  }
894  return setStylesFromString(el, value);
895}
896function setStylesFromObject(el, value) {
897  let previousStyles = {};
898  Object.entries(value).forEach(([key, value2]) => {
899    previousStyles[key] = el.style[key];
900    if (!key.startsWith("--")) {
901      key = kebabCase(key);
902    }
903    el.style.setProperty(key, value2);
904  });
905  setTimeout(() => {
906    if (el.style.length === 0) {
907      el.removeAttribute("style");
908    }
909  });
910  return () => {
911    setStyles(el, previousStyles);
912  };
913}
914function setStylesFromString(el, value) {
915  let cache = el.getAttribute("style", value);
916  el.setAttribute("style", value);
917  return () => {
918    el.setAttribute("style", cache || "");
919  };
920}
921function kebabCase(subject) {
922  return subject.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
923}
924
925// packages/alpinejs/src/utils/once.js
926function once(callback, fallback = () => {
927}) {
928  let called = false;
929  return function() {
930    if (!called) {
931      called = true;
932      callback.apply(this, arguments);
933    } else {
934      fallback.apply(this, arguments);
935    }
936  };
937}
938
939// packages/alpinejs/src/directives/x-transition.js
940directive("transition", (el, { value, modifiers, expression }, { evaluate: evaluate2 }) => {
941  if (typeof expression === "function")
942    expression = evaluate2(expression);
943  if (expression === false)
944    return;
945  if (!expression || typeof expression === "boolean") {
946    registerTransitionsFromHelper(el, modifiers, value);
947  } else {
948    registerTransitionsFromClassString(el, expression, value);
949  }
950});
951function registerTransitionsFromClassString(el, classString, stage) {
952  registerTransitionObject(el, setClasses, "");
953  let directiveStorageMap = {
954    "enter": (classes) => {
955      el._x_transition.enter.during = classes;
956    },
957    "enter-start": (classes) => {
958      el._x_transition.enter.start = classes;
959    },
960    "enter-end": (classes) => {
961      el._x_transition.enter.end = classes;
962    },
963    "leave": (classes) => {
964      el._x_transition.leave.during = classes;
965    },
966    "leave-start": (classes) => {
967      el._x_transition.leave.start = classes;
968    },
969    "leave-end": (classes) => {
970      el._x_transition.leave.end = classes;
971    }
972  };
973  directiveStorageMap[stage](classString);
974}
975function registerTransitionsFromHelper(el, modifiers, stage) {
976  registerTransitionObject(el, setStyles);
977  let doesntSpecify = !modifiers.includes("in") && !modifiers.includes("out") && !stage;
978  let transitioningIn = doesntSpecify || modifiers.includes("in") || ["enter"].includes(stage);
979  let transitioningOut = doesntSpecify || modifiers.includes("out") || ["leave"].includes(stage);
980  if (modifiers.includes("in") && !doesntSpecify) {
981    modifiers = modifiers.filter((i, index) => index < modifiers.indexOf("out"));
982  }
983  if (modifiers.includes("out") && !doesntSpecify) {
984    modifiers = modifiers.filter((i, index) => index > modifiers.indexOf("out"));
985  }
986  let wantsAll = !modifiers.includes("opacity") && !modifiers.includes("scale");
987  let wantsOpacity = wantsAll || modifiers.includes("opacity");
988  let wantsScale = wantsAll || modifiers.includes("scale");
989  let opacityValue = wantsOpacity ? 0 : 1;
990  let scaleValue = wantsScale ? modifierValue(modifiers, "scale", 95) / 100 : 1;
991  let delay = modifierValue(modifiers, "delay", 0) / 1e3;
992  let origin = modifierValue(modifiers, "origin", "center");
993  let property = "opacity, transform";
994  let durationIn = modifierValue(modifiers, "duration", 150) / 1e3;
995  let durationOut = modifierValue(modifiers, "duration", 75) / 1e3;
996  let easing = `cubic-bezier(0.4, 0.0, 0.2, 1)`;
997  if (transitioningIn) {
998    el._x_transition.enter.during = {
999      transformOrigin: origin,
1000      transitionDelay: `${delay}s`,
1001      transitionProperty: property,
1002      transitionDuration: `${durationIn}s`,
1003      transitionTimingFunction: easing
1004    };
1005    el._x_transition.enter.start = {
1006      opacity: opacityValue,
1007      transform: `scale(${scaleValue})`
1008    };
1009    el._x_transition.enter.end = {
1010      opacity: 1,
1011      transform: `scale(1)`
1012    };
1013  }
1014  if (transitioningOut) {
1015    el._x_transition.leave.during = {
1016      transformOrigin: origin,
1017      transitionDelay: `${delay}s`,
1018      transitionProperty: property,
1019      transitionDuration: `${durationOut}s`,
1020      transitionTimingFunction: easing
1021    };
1022    el._x_transition.leave.start = {
1023      opacity: 1,
1024      transform: `scale(1)`
1025    };
1026    el._x_transition.leave.end = {
1027      opacity: opacityValue,
1028      transform: `scale(${scaleValue})`
1029    };
1030  }
1031}
1032function registerTransitionObject(el, setFunction, defaultValue = {}) {
1033  if (!el._x_transition)
1034    el._x_transition = {
1035      enter: { during: defaultValue, start: defaultValue, end: defaultValue },
1036      leave: { during: defaultValue, start: defaultValue, end: defaultValue },
1037      in(before = () => {
1038      }, after = () => {
1039      }) {
1040        transition(el, setFunction, {
1041          during: this.enter.during,
1042          start: this.enter.start,
1043          end: this.enter.end
1044        }, before, after);
1045      },
1046      out(before = () => {
1047      }, after = () => {
1048      }) {
1049        transition(el, setFunction, {
1050          during: this.leave.during,
1051          start: this.leave.start,
1052          end: this.leave.end
1053        }, before, after);
1054      }
1055    };
1056}
1057window.Element.prototype._x_toggleAndCascadeWithTransitions = function(el, value, show, hide) {
1058  const nextTick2 = document.visibilityState === "visible" ? requestAnimationFrame : setTimeout;
1059  let clickAwayCompatibleShow = () => nextTick2(show);
1060  if (value) {
1061    if (el._x_transition && (el._x_transition.enter || el._x_transition.leave)) {
1062      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();
1063    } else {
1064      el._x_transition ? el._x_transition.in(show) : clickAwayCompatibleShow();
1065    }
1066    return;
1067  }
1068  el._x_hidePromise = el._x_transition ? new Promise((resolve, reject) => {
1069    el._x_transition.out(() => {
1070    }, () => resolve(hide));
1071    el._x_transitioning.beforeCancel(() => reject({ isFromCancelledTransition: true }));
1072  }) : Promise.resolve(hide);
1073  queueMicrotask(() => {
1074    let closest = closestHide(el);
1075    if (closest) {
1076      if (!closest._x_hideChildren)
1077        closest._x_hideChildren = [];
1078      closest._x_hideChildren.push(el);
1079    } else {
1080      nextTick2(() => {
1081        let hideAfterChildren = (el2) => {
1082          let carry = Promise.all([
1083            el2._x_hidePromise,
1084            ...(el2._x_hideChildren || []).map(hideAfterChildren)
1085          ]).then(([i]) => i());
1086          delete el2._x_hidePromise;
1087          delete el2._x_hideChildren;
1088          return carry;
1089        };
1090        hideAfterChildren(el).catch((e) => {
1091          if (!e.isFromCancelledTransition)
1092            throw e;
1093        });
1094      });
1095    }
1096  });
1097};
1098function closestHide(el) {
1099  let parent = el.parentNode;
1100  if (!parent)
1101    return;
1102  return parent._x_hidePromise ? parent : closestHide(parent);
1103}
1104function transition(el, setFunction, { during, start: start2, end } = {}, before = () => {
1105}, after = () => {
1106}) {
1107  if (el._x_transitioning)
1108    el._x_transitioning.cancel();
1109  if (Object.keys(during).length === 0 && Object.keys(start2).length === 0 && Object.keys(end).length === 0) {
1110    before();
1111    after();
1112    return;
1113  }
1114  let undoStart, undoDuring, undoEnd;
1115  performTransition(el, {
1116    start() {
1117      undoStart = setFunction(el, start2);
1118    },
1119    during() {
1120      undoDuring = setFunction(el, during);
1121    },
1122    before,
1123    end() {
1124      undoStart();
1125      undoEnd = setFunction(el, end);
1126    },
1127    after,
1128    cleanup() {
1129      undoDuring();
1130      undoEnd();
1131    }
1132  });
1133}
1134function performTransition(el, stages) {
1135  let interrupted, reachedBefore, reachedEnd;
1136  let finish = once(() => {
1137    mutateDom(() => {
1138      interrupted = true;
1139      if (!reachedBefore)
1140        stages.before();
1141      if (!reachedEnd) {
1142        stages.end();
1143        releaseNextTicks();
1144      }
1145      stages.after();
1146      if (el.isConnected)
1147        stages.cleanup();
1148      delete el._x_transitioning;
1149    });
1150  });
1151  el._x_transitioning = {
1152    beforeCancels: [],
1153    beforeCancel(callback) {
1154      this.beforeCancels.push(callback);
1155    },
1156    cancel: once(function() {
1157      while (this.beforeCancels.length) {
1158        this.beforeCancels.shift()();
1159      }
1160      ;
1161      finish();
1162    }),
1163    finish
1164  };
1165  mutateDom(() => {
1166    stages.start();
1167    stages.during();
1168  });
1169  holdNextTicks();
1170  requestAnimationFrame(() => {
1171    if (interrupted)
1172      return;
1173    let duration = Number(getComputedStyle(el).transitionDuration.replace(/,.*/, "").replace("s", "")) * 1e3;
1174    let delay = Number(getComputedStyle(el).transitionDelay.replace(/,.*/, "").replace("s", "")) * 1e3;
1175    if (duration === 0)
1176      duration = Number(getComputedStyle(el).animationDuration.replace("s", "")) * 1e3;
1177    mutateDom(() => {
1178      stages.before();
1179    });
1180    reachedBefore = true;
1181    requestAnimationFrame(() => {
1182      if (interrupted)
1183        return;
1184      mutateDom(() => {
1185        stages.end();
1186      });
1187      releaseNextTicks();
1188      setTimeout(el._x_transitioning.finish, duration + delay);
1189      reachedEnd = true;
1190    });
1191  });
1192}
1193function modifierValue(modifiers, key, fallback) {
1194  if (modifiers.indexOf(key) === -1)
1195    return fallback;
1196  const rawValue = modifiers[modifiers.indexOf(key) + 1];
1197  if (!rawValue)
1198    return fallback;
1199  if (key === "scale") {
1200    if (isNaN(rawValue))
1201      return fallback;
1202  }
1203  if (key === "duration" || key === "delay") {
1204    let match = rawValue.match(/([0-9]+)ms/);
1205    if (match)
1206      return match[1];
1207  }
1208  if (key === "origin") {
1209    if (["top", "right", "left", "center", "bottom"].includes(modifiers[modifiers.indexOf(key) + 2])) {
1210      return [rawValue, modifiers[modifiers.indexOf(key) + 2]].join(" ");
1211    }
1212  }
1213  return rawValue;
1214}
1215
1216// packages/alpinejs/src/clone.js
1217var isCloning = false;
1218function skipDuringClone(callback, fallback = () => {
1219}) {
1220  return (...args) => isCloning ? fallback(...args) : callback(...args);
1221}
1222function onlyDuringClone(callback) {
1223  return (...args) => isCloning && callback(...args);
1224}
1225function cloneNode(from, to) {
1226  if (from._x_dataStack) {
1227    to._x_dataStack = from._x_dataStack;
1228    to.setAttribute("data-has-alpine-state", true);
1229  }
1230  isCloning = true;
1231  dontRegisterReactiveSideEffects(() => {
1232    initTree(to, (el, callback) => {
1233      callback(el, () => {
1234      });
1235    });
1236  });
1237  isCloning = false;
1238}
1239var isCloningLegacy = false;
1240function clone(oldEl, newEl) {
1241  if (!newEl._x_dataStack)
1242    newEl._x_dataStack = oldEl._x_dataStack;
1243  isCloning = true;
1244  isCloningLegacy = true;
1245  dontRegisterReactiveSideEffects(() => {
1246    cloneTree(newEl);
1247  });
1248  isCloning = false;
1249  isCloningLegacy = false;
1250}
1251function cloneTree(el) {
1252  let hasRunThroughFirstEl = false;
1253  let shallowWalker = (el2, callback) => {
1254    walk(el2, (el3, skip) => {
1255      if (hasRunThroughFirstEl && isRoot(el3))
1256        return skip();
1257      hasRunThroughFirstEl = true;
1258      callback(el3, skip);
1259    });
1260  };
1261  initTree(el, shallowWalker);
1262}
1263function dontRegisterReactiveSideEffects(callback) {
1264  let cache = effect;
1265  overrideEffect((callback2, el) => {
1266    let storedEffect = cache(callback2);
1267    release(storedEffect);
1268    return () => {
1269    };
1270  });
1271  callback();
1272  overrideEffect(cache);
1273}
1274function shouldSkipRegisteringDataDuringClone(el) {
1275  if (!isCloning)
1276    return false;
1277  if (isCloningLegacy)
1278    return true;
1279  return el.hasAttribute("data-has-alpine-state");
1280}
1281
1282// packages/alpinejs/src/utils/bind.js
1283function bind(el, name, value, modifiers = []) {
1284  if (!el._x_bindings)
1285    el._x_bindings = reactive({});
1286  el._x_bindings[name] = value;
1287  name = modifiers.includes("camel") ? camelCase(name) : name;
1288  switch (name) {
1289    case "value":
1290      bindInputValue(el, value);
1291      break;
1292    case "style":
1293      bindStyles(el, value);
1294      break;
1295    case "class":
1296      bindClasses(el, value);
1297      break;
1298    case "selected":
1299    case "checked":
1300      bindAttributeAndProperty(el, name, value);
1301      break;
1302    default:
1303      bindAttribute(el, name, value);
1304      break;
1305  }
1306}
1307function bindInputValue(el, value) {
1308  if (el.type === "radio") {
1309    if (el.attributes.value === void 0) {
1310      el.value = value;
1311    }
1312    if (window.fromModel) {
1313      el.checked = checkedAttrLooseCompare(el.value, value);
1314    }
1315  } else if (el.type === "checkbox") {
1316    if (Number.isInteger(value)) {
1317      el.value = value;
1318    } else if (!Array.isArray(value) && typeof value !== "boolean" && ![null, void 0].includes(value)) {
1319      el.value = String(value);
1320    } else {
1321      if (Array.isArray(value)) {
1322        el.checked = value.some((val) => checkedAttrLooseCompare(val, el.value));
1323      } else {
1324        el.checked = !!value;
1325      }
1326    }
1327  } else if (el.tagName === "SELECT") {
1328    updateSelect(el, value);
1329  } else {
1330    if (el.value === value)
1331      return;
1332    el.value = value === void 0 ? "" : value;
1333  }
1334}
1335function bindClasses(el, value) {
1336  if (el._x_undoAddedClasses)
1337    el._x_undoAddedClasses();
1338  el._x_undoAddedClasses = setClasses(el, value);
1339}
1340function bindStyles(el, value) {
1341  if (el._x_undoAddedStyles)
1342    el._x_undoAddedStyles();
1343  el._x_undoAddedStyles = setStyles(el, value);
1344}
1345function bindAttributeAndProperty(el, name, value) {
1346  bindAttribute(el, name, value);
1347  setPropertyIfChanged(el, name, value);
1348}
1349function bindAttribute(el, name, value) {
1350  if ([null, void 0, false].includes(value) && attributeShouldntBePreservedIfFalsy(name)) {
1351    el.removeAttribute(name);
1352  } else {
1353    if (isBooleanAttr(name))
1354      value = name;
1355    setIfChanged(el, name, value);
1356  }
1357}
1358function setIfChanged(el, attrName, value) {
1359  if (el.getAttribute(attrName) != value) {
1360    el.setAttribute(attrName, value);
1361  }
1362}
1363function setPropertyIfChanged(el, propName, value) {
1364  if (el[propName] !== value) {
1365    el[propName] = value;
1366  }
1367}
1368function updateSelect(el, value) {
1369  const arrayWrappedValue = [].concat(value).map((value2) => {
1370    return value2 + "";
1371  });
1372  Array.from(el.options).forEach((option) => {
1373    option.selected = arrayWrappedValue.includes(option.value);
1374  });
1375}
1376function camelCase(subject) {
1377  return subject.toLowerCase().replace(/-(\w)/g, (match, char) => char.toUpperCase());
1378}
1379function checkedAttrLooseCompare(valueA, valueB) {
1380  return valueA == valueB;
1381}
1382function isBooleanAttr(attrName) {
1383  const booleanAttributes = [
1384    "disabled",
1385    "checked",
1386    "required",
1387    "readonly",
1388    "hidden",
1389    "open",
1390    "selected",
1391    "autofocus",
1392    "itemscope",
1393    "multiple",
1394    "novalidate",
1395    "allowfullscreen",
1396    "allowpaymentrequest",
1397    "formnovalidate",
1398    "autoplay",
1399    "controls",
1400    "loop",
1401    "muted",
1402    "playsinline",
1403    "default",
1404    "ismap",
1405    "reversed",
1406    "async",
1407    "defer",
1408    "nomodule"
1409  ];
1410  return booleanAttributes.includes(attrName);
1411}
1412function attributeShouldntBePreservedIfFalsy(name) {
1413  return !["aria-pressed", "aria-checked", "aria-expanded", "aria-selected"].includes(name);
1414}
1415function getBinding(el, name, fallback) {
1416  if (el._x_bindings && el._x_bindings[name] !== void 0)
1417    return el._x_bindings[name];
1418  return getAttributeBinding(el, name, fallback);
1419}
1420function extractProp(el, name, fallback, extract = true) {
1421  if (el._x_bindings && el._x_bindings[name] !== void 0)
1422    return el._x_bindings[name];
1423  if (el._x_inlineBindings && el._x_inlineBindings[name] !== void 0) {
1424    let binding = el._x_inlineBindings[name];
1425    binding.extract = extract;
1426    return dontAutoEvaluateFunctions(() => {
1427      return evaluate(el, binding.expression);
1428    });
1429  }
1430  return getAttributeBinding(el, name, fallback);
1431}
1432function getAttributeBinding(el, name, fallback) {
1433  let attr = el.getAttribute(name);
1434  if (attr === null)
1435    return typeof fallback === "function" ? fallback() : fallback;
1436  if (attr === "")
1437    return true;
1438  if (isBooleanAttr(name)) {
1439    return !![name, "true"].includes(attr);
1440  }
1441  return attr;
1442}
1443
1444// packages/alpinejs/src/utils/debounce.js
1445function debounce(func, wait) {
1446  var timeout;
1447  return function() {
1448    var context = this, args = arguments;
1449    var later = function() {
1450      timeout = null;
1451      func.apply(context, args);
1452    };
1453    clearTimeout(timeout);
1454    timeout = setTimeout(later, wait);
1455  };
1456}
1457
1458// packages/alpinejs/src/utils/throttle.js
1459function throttle(func, limit) {
1460  let inThrottle;
1461  return function() {
1462    let context = this, args = arguments;
1463    if (!inThrottle) {
1464      func.apply(context, args);
1465      inThrottle = true;
1466      setTimeout(() => inThrottle = false, limit);
1467    }
1468  };
1469}
1470
1471// packages/alpinejs/src/entangle.js
1472function entangle({ get: outerGet, set: outerSet }, { get: innerGet, set: innerSet }) {
1473  let firstRun = true;
1474  let outerHash, innerHash, outerHashLatest, innerHashLatest;
1475  let reference = effect(() => {
1476    let outer, inner;
1477    if (firstRun) {
1478      outer = outerGet();
1479      innerSet(JSON.parse(JSON.stringify(outer)));
1480      inner = innerGet();
1481      firstRun = false;
1482    } else {
1483      outer = outerGet();
1484      inner = innerGet();
1485      outerHashLatest = JSON.stringify(outer);
1486      innerHashLatest = JSON.stringify(inner);
1487      if (outerHashLatest !== outerHash) {
1488        inner = innerGet();
1489        innerSet(outer);
1490        inner = outer;
1491      } else {
1492        outerSet(JSON.parse(innerHashLatest ?? null));
1493        outer = inner;
1494      }
1495    }
1496    outerHash = JSON.stringify(outer);
1497    innerHash = JSON.stringify(inner);
1498  });
1499  return () => {
1500    release(reference);
1501  };
1502}
1503
1504// packages/alpinejs/src/plugin.js
1505function plugin(callback) {
1506  let callbacks = Array.isArray(callback) ? callback : [callback];
1507  callbacks.forEach((i) => i(alpine_default));
1508}
1509
1510// packages/alpinejs/src/store.js
1511var stores = {};
1512var isReactive = false;
1513function store(name, value) {
1514  if (!isReactive) {
1515    stores = reactive(stores);
1516    isReactive = true;
1517  }
1518  if (value === void 0) {
1519    return stores[name];
1520  }
1521  stores[name] = value;
1522  if (typeof value === "object" && value !== null && value.hasOwnProperty("init") && typeof value.init === "function") {
1523    stores[name].init();
1524  }
1525  initInterceptors2(stores[name]);
1526}
1527function getStores() {
1528  return stores;
1529}
1530
1531// packages/alpinejs/src/binds.js
1532var binds = {};
1533function bind2(name, bindings) {
1534  let getBindings = typeof bindings !== "function" ? () => bindings : bindings;
1535  if (name instanceof Element) {
1536    return applyBindingsObject(name, getBindings());
1537  } else {
1538    binds[name] = getBindings;
1539  }
1540  return () => {
1541  };
1542}
1543function injectBindingProviders(obj) {
1544  Object.entries(binds).forEach(([name, callback]) => {
1545    Object.defineProperty(obj, name, {
1546      get() {
1547        return (...args) => {
1548          return callback(...args);
1549        };
1550      }
1551    });
1552  });
1553  return obj;
1554}
1555function applyBindingsObject(el, obj, original) {
1556  let cleanupRunners = [];
1557  while (cleanupRunners.length)
1558    cleanupRunners.pop()();
1559  let attributes = Object.entries(obj).map(([name, value]) => ({ name, value }));
1560  let staticAttributes = attributesOnly(attributes);
1561  attributes = attributes.map((attribute) => {
1562    if (staticAttributes.find((attr) => attr.name === attribute.name)) {
1563      return {
1564        name: `x-bind:${attribute.name}`,
1565        value: `"${attribute.value}"`
1566      };
1567    }
1568    return attribute;
1569  });
1570  directives(el, attributes, original).map((handle) => {
1571    cleanupRunners.push(handle.runCleanups);
1572    handle();
1573  });
1574  return () => {
1575    while (cleanupRunners.length)
1576      cleanupRunners.pop()();
1577  };
1578}
1579
1580// packages/alpinejs/src/datas.js
1581var datas = {};
1582function data(name, callback) {
1583  datas[name] = callback;
1584}
1585function injectDataProviders(obj, context) {
1586  Object.entries(datas).forEach(([name, callback]) => {
1587    Object.defineProperty(obj, name, {
1588      get() {
1589        return (...args) => {
1590          return callback.bind(context)(...args);
1591        };
1592      },
1593      enumerable: false
1594    });
1595  });
1596  return obj;
1597}
1598
1599// packages/alpinejs/src/alpine.js
1600var Alpine = {
1601  get reactive() {
1602    return reactive;
1603  },
1604  get release() {
1605    return release;
1606  },
1607  get effect() {
1608    return effect;
1609  },
1610  get raw() {
1611    return raw;
1612  },
1613  version: "3.13.1",
1614  flushAndStopDeferringMutations,
1615  dontAutoEvaluateFunctions,
1616  disableEffectScheduling,
1617  startObservingMutations,
1618  stopObservingMutations,
1619  setReactivityEngine,
1620  onAttributeRemoved,
1621  onAttributesAdded,
1622  closestDataStack,
1623  skipDuringClone,
1624  onlyDuringClone,
1625  addRootSelector,
1626  addInitSelector,
1627  addScopeToNode,
1628  deferMutations,
1629  mapAttributes,
1630  evaluateLater,
1631  interceptInit,
1632  setEvaluator,
1633  mergeProxies,
1634  extractProp,
1635  findClosest,
1636  onElRemoved,
1637  closestRoot,
1638  destroyTree,
1639  interceptor,
1640  // INTERNAL: not public API and is subject to change without major release.
1641  transition,
1642  // INTERNAL
1643  setStyles,
1644  // INTERNAL
1645  mutateDom,
1646  directive,
1647  entangle,
1648  throttle,
1649  debounce,
1650  evaluate,
1651  initTree,
1652  nextTick,
1653  prefixed: prefix,
1654  prefix: setPrefix,
1655  plugin,
1656  magic,
1657  store,
1658  start,
1659  clone,
1660  // INTERNAL
1661  cloneNode,
1662  // INTERNAL
1663  bound: getBinding,
1664  $data: scope,
1665  walk,
1666  data,
1667  bind: bind2
1668};
1669var alpine_default = Alpine;
1670
1671// node_modules/@vue/shared/dist/shared.esm-bundler.js
1672function makeMap(str, expectsLowerCase) {
1673  const map = /* @__PURE__ */ Object.create(null);
1674  const list = str.split(",");
1675  for (let i = 0; i < list.length; i++) {
1676    map[list[i]] = true;
1677  }
1678  return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];
1679}
1680var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
1681var isBooleanAttr2 = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`);
1682var EMPTY_OBJ =  true ? Object.freeze({}) : 0;
1683var EMPTY_ARR =  true ? Object.freeze([]) : 0;
1684var hasOwnProperty = Object.prototype.hasOwnProperty;
1685var hasOwn = (val, key) => hasOwnProperty.call(val, key);
1686var isArray = Array.isArray;
1687var isMap = (val) => toTypeString(val) === "[object Map]";
1688var isString = (val) => typeof val === "string";
1689var isSymbol = (val) => typeof val === "symbol";
1690var isObject = (val) => val !== null && typeof val === "object";
1691var objectToString = Object.prototype.toString;
1692var toTypeString = (value) => objectToString.call(value);
1693var toRawType = (value) => {
1694  return toTypeString(value).slice(8, -1);
1695};
1696var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
1697var cacheStringFunction = (fn) => {
1698  const cache = /* @__PURE__ */ Object.create(null);
1699  return (str) => {
1700    const hit = cache[str];
1701    return hit || (cache[str] = fn(str));
1702  };
1703};
1704var camelizeRE = /-(\w)/g;
1705var camelize = cacheStringFunction((str) => {
1706  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
1707});
1708var hyphenateRE = /\B([A-Z])/g;
1709var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
1710var capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
1711var toHandlerKey = cacheStringFunction((str) => str ? `on${capitalize(str)}` : ``);
1712var hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);
1713
1714// node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
1715var targetMap = /* @__PURE__ */ new WeakMap();
1716var effectStack = [];
1717var activeEffect;
1718var ITERATE_KEY = Symbol( true ? "iterate" : 0);
1719var MAP_KEY_ITERATE_KEY = Symbol( true ? "Map key iterate" : 0);
1720function isEffect(fn) {
1721  return fn && fn._isEffect === true;
1722}
1723function effect2(fn, options = EMPTY_OBJ) {
1724  if (isEffect(fn)) {
1725    fn = fn.raw;
1726  }
1727  const effect3 = createReactiveEffect(fn, options);
1728  if (!options.lazy) {
1729    effect3();
1730  }
1731  return effect3;
1732}
1733function stop(effect3) {
1734  if (effect3.active) {
1735    cleanup(effect3);
1736    if (effect3.options.onStop) {
1737      effect3.options.onStop();
1738    }
1739    effect3.active = false;
1740  }
1741}
1742var uid = 0;
1743function createReactiveEffect(fn, options) {
1744  const effect3 = function reactiveEffect() {
1745    if (!effect3.active) {
1746      return fn();
1747    }
1748    if (!effectStack.includes(effect3)) {
1749      cleanup(effect3);
1750      try {
1751        enableTracking();
1752        effectStack.push(effect3);
1753        activeEffect = effect3;
1754        return fn();
1755      } finally {
1756        effectStack.pop();
1757        resetTracking();
1758        activeEffect = effectStack[effectStack.length - 1];
1759      }
1760    }
1761  };
1762  effect3.id = uid++;
1763  effect3.allowRecurse = !!options.allowRecurse;
1764  effect3._isEffect = true;
1765  effect3.active = true;
1766  effect3.raw = fn;
1767  effect3.deps = [];
1768  effect3.options = options;
1769  return effect3;
1770}
1771function cleanup(effect3) {
1772  const { deps } = effect3;
1773  if (deps.length) {
1774    for (let i = 0; i < deps.length; i++) {
1775      deps[i].delete(effect3);
1776    }
1777    deps.length = 0;
1778  }
1779}
1780var shouldTrack = true;
1781var trackStack = [];
1782function pauseTracking() {
1783  trackStack.push(shouldTrack);
1784  shouldTrack = false;
1785}
1786function enableTracking() {
1787  trackStack.push(shouldTrack);
1788  shouldTrack = true;
1789}
1790function resetTracking() {
1791  const last = trackStack.pop();
1792  shouldTrack = last === void 0 ? true : last;
1793}
1794function track(target, type, key) {
1795  if (!shouldTrack || activeEffect === void 0) {
1796    return;
1797  }
1798  let depsMap = targetMap.get(target);
1799  if (!depsMap) {
1800    targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
1801  }
1802  let dep = depsMap.get(key);
1803  if (!dep) {
1804    depsMap.set(key, dep = /* @__PURE__ */ new Set());
1805  }
1806  if (!dep.has(activeEffect)) {
1807    dep.add(activeEffect);
1808    activeEffect.deps.push(dep);
1809    if (activeEffect.options.onTrack) {
1810      activeEffect.options.onTrack({
1811        effect: activeEffect,
1812        target,
1813        type,
1814        key
1815      });
1816    }
1817  }
1818}
1819function trigger(target, type, key, newValue, oldValue, oldTarget) {
1820  const depsMap = targetMap.get(target);
1821  if (!depsMap) {
1822    return;
1823  }
1824  const effects = /* @__PURE__ */ new Set();
1825  const add2 = (effectsToAdd) => {
1826    if (effectsToAdd) {
1827      effectsToAdd.forEach((effect3) => {
1828        if (effect3 !== activeEffect || effect3.allowRecurse) {
1829          effects.add(effect3);
1830        }
1831      });
1832    }
1833  };
1834  if (type === "clear") {
1835    depsMap.forEach(add2);
1836  } else if (key === "length" && isArray(target)) {
1837    depsMap.forEach((dep, key2) => {
1838      if (key2 === "length" || key2 >= newValue) {
1839        add2(dep);
1840      }
1841    });
1842  } else {
1843    if (key !== void 0) {
1844      add2(depsMap.get(key));
1845    }
1846    switch (type) {
1847      case "add":
1848        if (!isArray(target)) {
1849          add2(depsMap.get(ITERATE_KEY));
1850          if (isMap(target)) {
1851            add2(depsMap.get(MAP_KEY_ITERATE_KEY));
1852          }
1853        } else if (isIntegerKey(key)) {
1854          add2(depsMap.get("length"));
1855        }
1856        break;
1857      case "delete":
1858        if (!isArray(target)) {
1859          add2(depsMap.get(ITERATE_KEY));
1860          if (isMap(target)) {
1861            add2(depsMap.get(MAP_KEY_ITERATE_KEY));
1862          }
1863        }
1864        break;
1865      case "set":
1866        if (isMap(target)) {
1867          add2(depsMap.get(ITERATE_KEY));
1868        }
1869        break;
1870    }
1871  }
1872  const run = (effect3) => {
1873    if (effect3.options.onTrigger) {
1874      effect3.options.onTrigger({
1875        effect: effect3,
1876        target,
1877        key,
1878        type,
1879        newValue,
1880        oldValue,
1881        oldTarget
1882      });
1883    }
1884    if (effect3.options.scheduler) {
1885      effect3.options.scheduler(effect3);
1886    } else {
1887      effect3();
1888    }
1889  };
1890  effects.forEach(run);
1891}
1892var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
1893var builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map((key) => Symbol[key]).filter(isSymbol));
1894var get2 = /* @__PURE__ */ createGetter();
1895var readonlyGet = /* @__PURE__ */ createGetter(true);
1896var arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
1897function createArrayInstrumentations() {
1898  const instrumentations = {};
1899  ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
1900    instrumentations[key] = function(...args) {
1901      const arr = toRaw(this);
1902      for (let i = 0, l = this.length; i < l; i++) {
1903        track(arr, "get", i + "");
1904      }
1905      const res = arr[key](...args);
1906      if (res === -1 || res === false) {
1907        return arr[key](...args.map(toRaw));
1908      } else {
1909        return res;
1910      }
1911    };
1912  });
1913  ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
1914    instrumentations[key] = function(...args) {
1915      pauseTracking();
1916      const res = toRaw(this)[key].apply(this, args);
1917      resetTracking();
1918      return res;
1919    };
1920  });
1921  return instrumentations;
1922}
1923function createGetter(isReadonly = false, shallow = false) {
1924  return function get3(target, key, receiver) {
1925    if (key === "__v_isReactive") {
1926      return !isReadonly;
1927    } else if (key === "__v_isReadonly") {
1928      return isReadonly;
1929    } else if (key === "__v_raw" && receiver === (isReadonly ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
1930      return target;
1931    }
1932    const targetIsArray = isArray(target);
1933    if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
1934      return Reflect.get(arrayInstrumentations, key, receiver);
1935    }
1936    const res = Reflect.get(target, key, receiver);
1937    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
1938      return res;
1939    }
1940    if (!isReadonly) {
1941      track(target, "get", key);
1942    }
1943    if (shallow) {
1944      return res;
1945    }
1946    if (isRef(res)) {
1947      const shouldUnwrap = !targetIsArray || !isIntegerKey(key);
1948      return shouldUnwrap ? res.value : res;
1949    }
1950    if (isObject(res)) {
1951      return isReadonly ? readonly(res) : reactive2(res);
1952    }
1953    return res;
1954  };
1955}
1956var set2 = /* @__PURE__ */ createSetter();
1957function createSetter(shallow = false) {
1958  return function set3(target, key, value, receiver) {
1959    let oldValue = target[key];
1960    if (!shallow) {
1961      value = toRaw(value);
1962      oldValue = toRaw(oldValue);
1963      if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
1964        oldValue.value = value;
1965        return true;
1966      }
1967    }
1968    const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
1969    const result = Reflect.set(target, key, value, receiver);
1970    if (target === toRaw(receiver)) {
1971      if (!hadKey) {
1972        trigger(target, "add", key, value);
1973      } else if (hasChanged(value, oldValue)) {
1974        trigger(target, "set", key, value, oldValue);
1975      }
1976    }
1977    return result;
1978  };
1979}
1980function deleteProperty(target, key) {
1981  const hadKey = hasOwn(target, key);
1982  const oldValue = target[key];
1983  const result = Reflect.deleteProperty(target, key);
1984  if (result && hadKey) {
1985    trigger(target, "delete", key, void 0, oldValue);
1986  }
1987  return result;
1988}
1989function has(target, key) {
1990  const result = Reflect.has(target, key);
1991  if (!isSymbol(key) || !builtInSymbols.has(key)) {
1992    track(target, "has", key);
1993  }
1994  return result;
1995}
1996function ownKeys(target) {
1997  track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
1998  return Reflect.ownKeys(target);
1999}
2000var mutableHandlers = {
2001  get: get2,
2002  set: set2,
2003  deleteProperty,
2004  has,
2005  ownKeys
2006};
2007var readonlyHandlers = {
2008  get: readonlyGet,
2009  set(target, key) {
2010    if (true) {
2011      console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
2012    }
2013    return true;
2014  },
2015  deleteProperty(target, key) {
2016    if (true) {
2017      console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
2018    }
2019    return true;
2020  }
2021};
2022var toReactive = (value) => isObject(value) ? reactive2(value) : value;
2023var toReadonly = (value) => isObject(value) ? readonly(value) : value;
2024var toShallow = (value) => value;
2025var getProto = (v) => Reflect.getPrototypeOf(v);
2026function get$1(target, key, isReadonly = false, isShallow = false) {
2027  target = target[
2028    "__v_raw"
2029    /* RAW */
2030  ];
2031  const rawTarget = toRaw(target);
2032  const rawKey = toRaw(key);
2033  if (key !== rawKey) {
2034    !isReadonly && track(rawTarget, "get", key);
2035  }
2036  !isReadonly && track(rawTarget, "get", rawKey);
2037  const { has: has2 } = getProto(rawTarget);
2038  const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
2039  if (has2.call(rawTarget, key)) {
2040    return wrap(target.get(key));
2041  } else if (has2.call(rawTarget, rawKey)) {
2042    return wrap(target.get(rawKey));
2043  } else if (target !== rawTarget) {
2044    target.get(key);
2045  }
2046}
2047function has$1(key, isReadonly = false) {
2048  const target = this[
2049    "__v_raw"
2050    /* RAW */
2051  ];
2052  const rawTarget = toRaw(target);
2053  const rawKey = toRaw(key);
2054  if (key !== rawKey) {
2055    !isReadonly && track(rawTarget, "has", key);
2056  }
2057  !isReadonly && track(rawTarget, "has", rawKey);
2058  return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
2059}
2060function size(target, isReadonly = false) {
2061  target = target[
2062    "__v_raw"
2063    /* RAW */
2064  ];
2065  !isReadonly && track(toRaw(target), "iterate", ITERATE_KEY);
2066  return Reflect.get(target, "size", target);
2067}
2068function add(value) {
2069  value = toRaw(value);
2070  const target = toRaw(this);
2071  const proto = getProto(target);
2072  const hadKey = proto.has.call(target, value);
2073  if (!hadKey) {
2074    target.add(value);
2075    trigger(target, "add", value, value);
2076  }
2077  return this;
2078}
2079function set$1(key, value) {
2080  value = toRaw(value);
2081  const target = toRaw(this);
2082  const { has: has2, get: get3 } = getProto(target);
2083  let hadKey = has2.call(target, key);
2084  if (!hadKey) {
2085    key = toRaw(key);
2086    hadKey = has2.call(target, key);
2087  } else if (true) {
2088    checkIdentityKeys(target, has2, key);
2089  }
2090  const oldValue = get3.call(target, key);
2091  target.set(key, value);
2092  if (!hadKey) {
2093    trigger(target, "add", key, value);
2094  } else if (hasChanged(value, oldValue)) {
2095    trigger(target, "set", key, value, oldValue);
2096  }
2097  return this;
2098}
2099function deleteEntry(key) {
2100  const target = toRaw(this);
2101  const { has: has2, get: get3 } = getProto(target);
2102  let hadKey = has2.call(target, key);
2103  if (!hadKey) {
2104    key = toRaw(key);
2105    hadKey = has2.call(target, key);
2106  } else if (true) {
2107    checkIdentityKeys(target, has2, key);
2108  }
2109  const oldValue = get3 ? get3.call(target, key) : void 0;
2110  const result = target.delete(key);
2111  if (hadKey) {
2112    trigger(target, "delete", key, void 0, oldValue);
2113  }
2114  return result;
2115}
2116function clear() {
2117  const target = toRaw(this);
2118  const hadItems = target.size !== 0;
2119  const oldTarget =  true ? isMap(target) ? new Map(target) : new Set(target) : 0;
2120  const result = target.clear();
2121  if (hadItems) {
2122    trigger(target, "clear", void 0, void 0, oldTarget);
2123  }
2124  return result;
2125}
2126function createForEach(isReadonly, isShallow) {
2127  return function forEach(callback, thisArg) {
2128    const observed = this;
2129    const target = observed[
2130      "__v_raw"
2131      /* RAW */
2132    ];
2133    const rawTarget = toRaw(target);
2134    const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
2135    !isReadonly && track(rawTarget, "iterate", ITERATE_KEY);
2136    return target.forEach((value, key) => {
2137      return callback.call(thisArg, wrap(value), wrap(key), observed);
2138    });
2139  };
2140}
2141function createIterableMethod(method, isReadonly, isShallow) {
2142  return function(...args) {
2143    const target = this[
2144      "__v_raw"
2145      /* RAW */
2146    ];
2147    const rawTarget = toRaw(target);
2148    const targetIsMap = isMap(rawTarget);
2149    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
2150    const isKeyOnly = method === "keys" && targetIsMap;
2151    const innerIterator = target[method](...args);
2152    const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
2153    !isReadonly && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
2154    return {
2155      // iterator protocol
2156      next() {
2157        const { value, done } = innerIterator.next();
2158        return done ? { value, done } : {
2159          value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
2160          done
2161        };
2162      },
2163      // iterable protocol
2164      [Symbol.iterator]() {
2165        return this;
2166      }
2167    };
2168  };
2169}
2170function createReadonlyMethod(type) {
2171  return function(...args) {
2172    if (true) {
2173      const key = args[0] ? `on key "${args[0]}" ` : ``;
2174      console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
2175    }
2176    return type === "delete" ? false : this;
2177  };
2178}
2179function createInstrumentations() {
2180  const mutableInstrumentations2 = {
2181    get(key) {
2182      return get$1(this, key);
2183    },
2184    get size() {
2185      return size(this);
2186    },
2187    has: has$1,
2188    add,
2189    set: set$1,
2190    delete: deleteEntry,
2191    clear,
2192    forEach: createForEach(false, false)
2193  };
2194  const shallowInstrumentations2 = {
2195    get(key) {
2196      return get$1(this, key, false, true);
2197    },
2198    get size() {
2199      return size(this);
2200    },
2201    has: has$1,
2202    add,
2203    set: set$1,
2204    delete: deleteEntry,
2205    clear,
2206    forEach: createForEach(false, true)
2207  };
2208  const readonlyInstrumentations2 = {
2209    get(key) {
2210      return get$1(this, key, true);
2211    },
2212    get size() {
2213      return size(this, true);
2214    },
2215    has(key) {
2216      return has$1.call(this, key, true);
2217    },
2218    add: createReadonlyMethod(
2219      "add"
2220      /* ADD */
2221    ),
2222    set: createReadonlyMethod(
2223      "set"
2224      /* SET */
2225    ),
2226    delete: createReadonlyMethod(
2227      "delete"
2228      /* DELETE */
2229    ),
2230    clear: createReadonlyMethod(
2231      "clear"
2232      /* CLEAR */
2233    ),
2234    forEach: createForEach(true, false)
2235  };
2236  const shallowReadonlyInstrumentations2 = {
2237    get(key) {
2238      return get$1(this, key, true, true);
2239    },
2240    get size() {
2241      return size(this, true);
2242    },
2243    has(key) {
2244      return has$1.call(this, key, true);
2245    },
2246    add: createReadonlyMethod(
2247      "add"
2248      /* ADD */
2249    ),
2250    set: createReadonlyMethod(
2251      "set"
2252      /* SET */
2253    ),
2254    delete: createReadonlyMethod(
2255      "delete"
2256      /* DELETE */
2257    ),
2258    clear: createReadonlyMethod(
2259      "clear"
2260      /* CLEAR */
2261    ),
2262    forEach: createForEach(true, true)
2263  };
2264  const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
2265  iteratorMethods.forEach((method) => {
2266    mutableInstrumentations2[method] = createIterableMethod(method, false, false);
2267    readonlyInstrumentations2[method] = createIterableMethod(method, true, false);
2268    shallowInstrumentations2[method] = createIterableMethod(method, false, true);
2269    shallowReadonlyInstrumentations2[method] = createIterableMethod(method, true, true);
2270  });
2271  return [
2272    mutableInstrumentations2,
2273    readonlyInstrumentations2,
2274    shallowInstrumentations2,
2275    shallowReadonlyInstrumentations2
2276  ];
2277}
2278var [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* @__PURE__ */ createInstrumentations();
2279function createInstrumentationGetter(isReadonly, shallow) {
2280  const instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations;
2281  return (target, key, receiver) => {
2282    if (key === "__v_isReactive") {
2283      return !isReadonly;
2284    } else if (key === "__v_isReadonly") {
2285      return isReadonly;
2286    } else if (key === "__v_raw") {
2287      return target;
2288    }
2289    return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
2290  };
2291}
2292var mutableCollectionHandlers = {
2293  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
2294};
2295var readonlyCollectionHandlers = {
2296  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
2297};
2298function checkIdentityKeys(target, has2, key) {
2299  const rawKey = toRaw(key);
2300  if (rawKey !== key && has2.call(target, rawKey)) {
2301    const type = toRawType(target);
2302    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.`);
2303  }
2304}
2305var reactiveMap = /* @__PURE__ */ new WeakMap();
2306var shallowReactiveMap = /* @__PURE__ */ new WeakMap();
2307var readonlyMap = /* @__PURE__ */ new WeakMap();
2308var shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
2309function targetTypeMap(rawType) {
2310  switch (rawType) {
2311    case "Object":
2312    case "Array":
2313      return 1;
2314    case "Map":
2315    case "Set":
2316    case "WeakMap":
2317    case "WeakSet":
2318      return 2;
2319    default:
2320      return 0;
2321  }
2322}
2323function getTargetType(value) {
2324  return value[
2325    "__v_skip"
2326    /* SKIP */
2327  ] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
2328}
2329function reactive2(target) {
2330  if (target && target[
2331    "__v_isReadonly"
2332    /* IS_READONLY */
2333  ]) {
2334    return target;
2335  }
2336  return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
2337}
2338function readonly(target) {
2339  return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
2340}
2341function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
2342  if (!isObject(target)) {
2343    if (true) {
2344      console.warn(`value cannot be made reactive: ${String(target)}`);
2345    }
2346    return target;
2347  }
2348  if (target[
2349    "__v_raw"
2350    /* RAW */
2351  ] && !(isReadonly && target[
2352    "__v_isReactive"
2353    /* IS_REACTIVE */
2354  ])) {
2355    return target;
2356  }
2357  const existingProxy = proxyMap.get(target);
2358  if (existingProxy) {
2359    return existingProxy;
2360  }
2361  const targetType = getTargetType(target);
2362  if (targetType === 0) {
2363    return target;
2364  }
2365  const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
2366  proxyMap.set(target, proxy);
2367  return proxy;
2368}
2369function toRaw(observed) {
2370  return observed && toRaw(observed[
2371    "__v_raw"
2372    /* RAW */
2373  ]) || observed;
2374}
2375function isRef(r) {
2376  return Boolean(r && r.__v_isRef === true);
2377}
2378
2379// packages/alpinejs/src/magics/$nextTick.js
2380magic("nextTick", () => nextTick);
2381
2382// packages/alpinejs/src/magics/$dispatch.js
2383magic("dispatch", (el) => dispatch.bind(dispatch, el));
2384
2385// packages/alpinejs/src/magics/$watch.js
2386magic("watch", (el, { evaluateLater: evaluateLater2, effect: effect3 }) => (key, callback) => {
2387  let evaluate2 = evaluateLater2(key);
2388  let firstTime = true;
2389  let oldValue;
2390  let effectReference = effect3(() => evaluate2((value) => {
2391    JSON.stringify(value);
2392    if (!firstTime) {
2393      queueMicrotask(() => {
2394        callback(value, oldValue);
2395        oldValue = value;
2396      });
2397    } else {
2398      oldValue = value;
2399    }
2400    firstTime = false;
2401  }));
2402  el._x_effects.delete(effectReference);
2403});
2404
2405// packages/alpinejs/src/magics/$store.js
2406magic("store", getStores);
2407
2408// packages/alpinejs/src/magics/$data.js
2409magic("data", (el) => scope(el));
2410
2411// packages/alpinejs/src/magics/$root.js
2412magic("root", (el) => closestRoot(el));
2413
2414// packages/alpinejs/src/magics/$refs.js
2415magic("refs", (el) => {
2416  if (el._x_refs_proxy)
2417    return el._x_refs_proxy;
2418  el._x_refs_proxy = mergeProxies(getArrayOfRefObject(el));
2419  return el._x_refs_proxy;
2420});
2421function getArrayOfRefObject(el) {
2422  let refObjects = [];
2423  let currentEl = el;
2424  while (currentEl) {
2425    if (currentEl._x_refs)
2426      refObjects.push(currentEl._x_refs);
2427    currentEl = currentEl.parentNode;
2428  }
2429  return refObjects;
2430}
2431
2432// packages/alpinejs/src/ids.js
2433var globalIdMemo = {};
2434function findAndIncrementId(name) {
2435  if (!globalIdMemo[name])
2436    globalIdMemo[name] = 0;
2437  return ++globalIdMemo[name];
2438}
2439function closestIdRoot(el, name) {
2440  return findClosest(el, (element) => {
2441    if (element._x_ids && element._x_ids[name])
2442      return true;
2443  });
2444}
2445function setIdRoot(el, name) {
2446  if (!el._x_ids)
2447    el._x_ids = {};
2448  if (!el._x_ids[name])
2449    el._x_ids[name] = findAndIncrementId(name);
2450}
2451
2452// packages/alpinejs/src/magics/$id.js
2453magic("id", (el) => (name, key = null) => {
2454  let root = closestIdRoot(el, name);
2455  let id = root ? root._x_ids[name] : findAndIncrementId(name);
2456  return key ? `${name}-${id}-${key}` : `${name}-${id}`;
2457});
2458
2459// packages/alpinejs/src/magics/$el.js
2460magic("el", (el) => el);
2461
2462// packages/alpinejs/src/magics/index.js
2463warnMissingPluginMagic("Focus", "focus", "focus");
2464warnMissingPluginMagic("Persist", "persist", "persist");
2465function warnMissingPluginMagic(name, magicName, slug) {
2466  magic(magicName, (el) => warn(`You can't use [$${magicName}] without first installing the "${name}" plugin here: https://alpinejs.dev/plugins/${slug}`, el));
2467}
2468
2469// packages/alpinejs/src/directives/x-modelable.js
2470directive("modelable", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2, cleanup: cleanup2 }) => {
2471  let func = evaluateLater2(expression);
2472  let innerGet = () => {
2473    let result;
2474    func((i) => result = i);
2475    return result;
2476  };
2477  let evaluateInnerSet = evaluateLater2(`${expression} = __placeholder`);
2478  let innerSet = (val) => evaluateInnerSet(() => {
2479  }, { scope: { "__placeholder": val } });
2480  let initialValue = innerGet();
2481  innerSet(initialValue);
2482  queueMicrotask(() => {
2483    if (!el._x_model)
2484      return;
2485    el._x_removeModelListeners["default"]();
2486    let outerGet = el._x_model.get;
2487    let outerSet = el._x_model.set;
2488    let releaseEntanglement = entangle(
2489      {
2490        get() {
2491          return outerGet();
2492        },
2493        set(value) {
2494          outerSet(value);
2495        }
2496      },
2497      {
2498        get() {
2499          return innerGet();
2500        },
2501        set(value) {
2502          innerSet(value);
2503        }
2504      }
2505    );
2506    cleanup2(releaseEntanglement);
2507  });
2508});
2509
2510// packages/alpinejs/src/directives/x-teleport.js
2511directive("teleport", (el, { modifiers, expression }, { cleanup: cleanup2 }) => {
2512  if (el.tagName.toLowerCase() !== "template")
2513    warn("x-teleport can only be used on a <template> tag", el);
2514  let target = getTarget(expression);
2515  let clone2 = el.content.cloneNode(true).firstElementChild;
2516  el._x_teleport = clone2;
2517  clone2._x_teleportBack = el;
2518  el.setAttribute("data-teleport-template", true);
2519  clone2.setAttribute("data-teleport-target", true);
2520  if (el._x_forwardEvents) {
2521    el._x_forwardEvents.forEach((eventName) => {
2522      clone2.addEventListener(eventName, (e) => {
2523        e.stopPropagation();
2524        el.dispatchEvent(new e.constructor(e.type, e));
2525      });
2526    });
2527  }
2528  addScopeToNode(clone2, {}, el);
2529  let placeInDom = (clone3, target2, modifiers2) => {
2530    if (modifiers2.includes("prepend")) {
2531      target2.parentNode.insertBefore(clone3, target2);
2532    } else if (modifiers2.includes("append")) {
2533      target2.parentNode.insertBefore(clone3, target2.nextSibling);
2534    } else {
2535      target2.appendChild(clone3);
2536    }
2537  };
2538  mutateDom(() => {
2539    placeInDom(clone2, target, modifiers);
2540    initTree(clone2);
2541    clone2._x_ignore = true;
2542  });
2543  el._x_teleportPutBack = () => {
2544    let target2 = getTarget(expression);
2545    mutateDom(() => {
2546      placeInDom(el._x_teleport, target2, modifiers);
2547    });
2548  };
2549  cleanup2(() => clone2.remove());
2550});
2551var teleportContainerDuringClone = document.createElement("div");
2552function getTarget(expression) {
2553  let target = skipDuringClone(() => {
2554    return document.querySelector(expression);
2555  }, () => {
2556    return teleportContainerDuringClone;
2557  })();
2558  if (!target)
2559    warn(`Cannot find x-teleport element for selector: "${expression}"`);
2560  return target;
2561}
2562
2563// packages/alpinejs/src/directives/x-ignore.js
2564var handler = () => {
2565};
2566handler.inline = (el, { modifiers }, { cleanup: cleanup2 }) => {
2567  modifiers.includes("self") ? el._x_ignoreSelf = true : el._x_ignore = true;
2568  cleanup2(() => {
2569    modifiers.includes("self") ? delete el._x_ignoreSelf : delete el._x_ignore;
2570  });
2571};
2572directive("ignore", handler);
2573
2574// packages/alpinejs/src/directives/x-effect.js
2575directive("effect", (el, { expression }, { effect: effect3 }) => effect3(evaluateLater(el, expression)));
2576
2577// packages/alpinejs/src/utils/on.js
2578function on(el, event, modifiers, callback) {
2579  let listenerTarget = el;
2580  let handler4 = (e) => callback(e);
2581  let options = {};
2582  let wrapHandler = (callback2, wrapper) => (e) => wrapper(callback2, e);
2583  if (modifiers.includes("dot"))
2584    event = dotSyntax(event);
2585  if (modifiers.includes("camel"))
2586    event = camelCase2(event);
2587  if (modifiers.includes("passive"))
2588    options.passive = true;
2589  if (modifiers.includes("capture"))
2590    options.capture = true;
2591  if (modifiers.includes("window"))
2592    listenerTarget = window;
2593  if (modifiers.includes("document"))
2594    listenerTarget = document;
2595  if (modifiers.includes("debounce")) {
2596    let nextModifier = modifiers[modifiers.indexOf("debounce") + 1] || "invalid-wait";
2597    let wait = isNumeric(nextModifier.split("ms")[0]) ? Number(nextModifier.split("ms")[0]) : 250;
2598    handler4 = debounce(handler4, wait);
2599  }
2600  if (modifiers.includes("throttle")) {
2601    let nextModifier = modifiers[modifiers.indexOf("throttle") + 1] || "invalid-wait";
2602    let wait = isNumeric(nextModifier.split("ms")[0]) ? Number(nextModifier.split("ms")[0]) : 250;
2603    handler4 = throttle(handler4, wait);
2604  }
2605  if (modifiers.includes("prevent"))
2606    handler4 = wrapHandler(handler4, (next, e) => {
2607      e.preventDefault();
2608      next(e);
2609    });
2610  if (modifiers.includes("stop"))
2611    handler4 = wrapHandler(handler4, (next, e) => {
2612      e.stopPropagation();
2613      next(e);
2614    });
2615  if (modifiers.includes("self"))
2616    handler4 = wrapHandler(handler4, (next, e) => {
2617      e.target === el && next(e);
2618    });
2619  if (modifiers.includes("away") || modifiers.includes("outside")) {
2620    listenerTarget = document;
2621    handler4 = wrapHandler(handler4, (next, e) => {
2622      if (el.contains(e.target))
2623        return;
2624      if (e.target.isConnected === false)
2625        return;
2626      if (el.offsetWidth < 1 && el.offsetHeight < 1)
2627        return;
2628      if (el._x_isShown === false)
2629        return;
2630      next(e);
2631    });
2632  }
2633  if (modifiers.includes("once")) {
2634    handler4 = wrapHandler(handler4, (next, e) => {
2635      next(e);
2636      listenerTarget.removeEventListener(event, handler4, options);
2637    });
2638  }
2639  handler4 = wrapHandler(handler4, (next, e) => {
2640    if (isKeyEvent(event)) {
2641      if (isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers)) {
2642        return;
2643      }
2644    }
2645    next(e);
2646  });
2647  listenerTarget.addEventListener(event, handler4, options);
2648  return () => {
2649    listenerTarget.removeEventListener(event, handler4, options);
2650  };
2651}
2652function dotSyntax(subject) {
2653  return subject.replace(/-/g, ".");
2654}
2655function camelCase2(subject) {
2656  return subject.toLowerCase().replace(/-(\w)/g, (match, char) => char.toUpperCase());
2657}
2658function isNumeric(subject) {
2659  return !Array.isArray(subject) && !isNaN(subject);
2660}
2661function kebabCase2(subject) {
2662  if ([" ", "_"].includes(
2663    subject
2664  ))
2665    return subject;
2666  return subject.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]/, "-").toLowerCase();
2667}
2668function isKeyEvent(event) {
2669  return ["keydown", "keyup"].includes(event);
2670}
2671function isListeningForASpecificKeyThatHasntBeenPressed(e, modifiers) {
2672  let keyModifiers = modifiers.filter((i) => {
2673    return !["window", "document", "prevent", "stop", "once", "capture"].includes(i);
2674  });
2675  if (keyModifiers.includes("debounce")) {
2676    let debounceIndex = keyModifiers.indexOf("debounce");
2677    keyModifiers.splice(debounceIndex, isNumeric((keyModifiers[debounceIndex + 1] || "invalid-wait").split("ms")[0]) ? 2 : 1);
2678  }
2679  if (keyModifiers.includes("throttle")) {
2680    let debounceIndex = keyModifiers.indexOf("throttle");
2681    keyModifiers.splice(debounceIndex, isNumeric((keyModifiers[debounceIndex + 1] || "invalid-wait").split("ms")[0]) ? 2 : 1);
2682  }
2683  if (keyModifiers.length === 0)
2684    return false;
2685  if (keyModifiers.length === 1 && keyToModifiers(e.key).includes(keyModifiers[0]))
2686    return false;
2687  const systemKeyModifiers = ["ctrl", "shift", "alt", "meta", "cmd", "super"];
2688  const selectedSystemKeyModifiers = systemKeyModifiers.filter((modifier) => keyModifiers.includes(modifier));
2689  keyModifiers = keyModifiers.filter((i) => !selectedSystemKeyModifiers.includes(i));
2690  if (selectedSystemKeyModifiers.length > 0) {
2691    const activelyPressedKeyModifiers = selectedSystemKeyModifiers.filter((modifier) => {
2692      if (modifier === "cmd" || modifier === "super")
2693        modifier = "meta";
2694      return e[`${modifier}Key`];
2695    });
2696    if (activelyPressedKeyModifiers.length === selectedSystemKeyModifiers.length) {
2697      if (keyToModifiers(e.key).includes(keyModifiers[0]))
2698        return false;
2699    }
2700  }
2701  return true;
2702}
2703function keyToModifiers(key) {
2704  if (!key)
2705    return [];
2706  key = kebabCase2(key);
2707  let modifierToKeyMap = {
2708    "ctrl": "control",
2709    "slash": "/",
2710    "space": " ",
2711    "spacebar": " ",
2712    "cmd": "meta",
2713    "esc": "escape",
2714    "up": "arrow-up",
2715    "down": "arrow-down",
2716    "left": "arrow-left",
2717    "right": "arrow-right",
2718    "period": ".",
2719    "equal": "=",
2720    "minus": "-",
2721    "underscore": "_"
2722  };
2723  modifierToKeyMap[key] = key;
2724  return Object.keys(modifierToKeyMap).map((modifier) => {
2725    if (modifierToKeyMap[modifier] === key)
2726      return modifier;
2727  }).filter((modifier) => modifier);
2728}
2729
2730// packages/alpinejs/src/directives/x-model.js
2731directive("model", (el, { modifiers, expression }, { effect: effect3, cleanup: cleanup2 }) => {
2732  let scopeTarget = el;
2733  if (modifiers.includes("parent")) {
2734    scopeTarget = el.parentNode;
2735  }
2736  let evaluateGet = evaluateLater(scopeTarget, expression);
2737  let evaluateSet;
2738  if (typeof expression === "string") {
2739    evaluateSet = evaluateLater(scopeTarget, `${expression} = __placeholder`);
2740  } else if (typeof expression === "function" && typeof expression() === "string") {
2741    evaluateSet = evaluateLater(scopeTarget, `${expression()} = __placeholder`);
2742  } else {
2743    evaluateSet = () => {
2744    };
2745  }
2746  let getValue = () => {
2747    let result;
2748    evaluateGet((value) => result = value);
2749    return isGetterSetter(result) ? result.get() : result;
2750  };
2751  let setValue = (value) => {
2752    let result;
2753    evaluateGet((value2) => result = value2);
2754    if (isGetterSetter(result)) {
2755      result.set(value);
2756    } else {
2757      evaluateSet(() => {
2758      }, {
2759        scope: { "__placeholder": value }
2760      });
2761    }
2762  };
2763  if (typeof expression === "string" && el.type === "radio") {
2764    mutateDom(() => {
2765      if (!el.hasAttribute("name"))
2766        el.setAttribute("name", expression);
2767    });
2768  }
2769  var event = el.tagName.toLowerCase() === "select" || ["checkbox", "radio"].includes(el.type) || modifiers.includes("lazy") ? "change" : "input";
2770  let removeListener = isCloning ? () => {
2771  } : on(el, event, modifiers, (e) => {
2772    setValue(getInputValue(el, modifiers, e, getValue()));
2773  });
2774  if (modifiers.includes("fill")) {
2775    if ([null, ""].includes(getValue()) || el.type === "checkbox" && Array.isArray(getValue())) {
2776      el.dispatchEvent(new Event(event, {}));
2777    }
2778  }
2779  if (!el._x_removeModelListeners)
2780    el._x_removeModelListeners = {};
2781  el._x_removeModelListeners["default"] = removeListener;
2782  cleanup2(() => el._x_removeModelListeners["default"]());
2783  if (el.form) {
2784    let removeResetListener = on(el.form, "reset", [], (e) => {
2785      nextTick(() => el._x_model && el._x_model.set(el.value));
2786    });
2787    cleanup2(() => removeResetListener());
2788  }
2789  el._x_model = {
2790    get() {
2791      return getValue();
2792    },
2793    set(value) {
2794      setValue(value);
2795    }
2796  };
2797  el._x_forceModelUpdate = (value) => {
2798    if (value === void 0 && typeof expression === "string" && expression.match(/\./))
2799      value = "";
2800    window.fromModel = true;
2801    mutateDom(() => bind(el, "value", value));
2802    delete window.fromModel;
2803  };
2804  effect3(() => {
2805    let value = getValue();
2806    if (modifiers.includes("unintrusive") && document.activeElement.isSameNode(el))
2807      return;
2808    el._x_forceModelUpdate(value);
2809  });
2810});
2811function getInputValue(el, modifiers, event, currentValue) {
2812  return mutateDom(() => {
2813    if (event instanceof CustomEvent && event.detail !== void 0)
2814      return event.detail !== null && event.detail !== void 0 ? event.detail : event.target.value;
2815    else if (el.type === "checkbox") {
2816      if (Array.isArray(currentValue)) {
2817        let newValue = modifiers.includes("number") ? safeParseNumber(event.target.value) : event.target.value;
2818        return event.target.checked ? currentValue.concat([newValue]) : currentValue.filter((el2) => !checkedAttrLooseCompare2(el2, newValue));
2819      } else {
2820        return event.target.checked;
2821      }
2822    } else if (el.tagName.toLowerCase() === "select" && el.multiple) {
2823      return modifiers.includes("number") ? Array.from(event.target.selectedOptions).map((option) => {
2824        let rawValue = option.value || option.text;
2825        return safeParseNumber(rawValue);
2826      }) : Array.from(event.target.selectedOptions).map((option) => {
2827        return option.value || option.text;
2828      });
2829    } else {
2830      let rawValue = event.target.value;
2831      return modifiers.includes("number") ? safeParseNumber(rawValue) : modifiers.includes("trim") ? rawValue.trim() : rawValue;
2832    }
2833  });
2834}
2835function safeParseNumber(rawValue) {
2836  let number = rawValue ? parseFloat(rawValue) : null;
2837  return isNumeric2(number) ? number : rawValue;
2838}
2839function checkedAttrLooseCompare2(valueA, valueB) {
2840  return valueA == valueB;
2841}
2842function isNumeric2(subject) {
2843  return !Array.isArray(subject) && !isNaN(subject);
2844}
2845function isGetterSetter(value) {
2846  return value !== null && typeof value === "object" && typeof value.get === "function" && typeof value.set === "function";
2847}
2848
2849// packages/alpinejs/src/directives/x-cloak.js
2850directive("cloak", (el) => queueMicrotask(() => mutateDom(() => el.removeAttribute(prefix("cloak")))));
2851
2852// packages/alpinejs/src/directives/x-init.js
2853addInitSelector(() => `[${prefix("init")}]`);
2854directive("init", skipDuringClone((el, { expression }, { evaluate: evaluate2 }) => {
2855  if (typeof expression === "string") {
2856    return !!expression.trim() && evaluate2(expression, {}, false);
2857  }
2858  return evaluate2(expression, {}, false);
2859}));
2860
2861// packages/alpinejs/src/directives/x-text.js
2862directive("text", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2 }) => {
2863  let evaluate2 = evaluateLater2(expression);
2864  effect3(() => {
2865    evaluate2((value) => {
2866      mutateDom(() => {
2867        el.textContent = value;
2868      });
2869    });
2870  });
2871});
2872
2873// packages/alpinejs/src/directives/x-html.js
2874directive("html", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2 }) => {
2875  let evaluate2 = evaluateLater2(expression);
2876  effect3(() => {
2877    evaluate2((value) => {
2878      mutateDom(() => {
2879        el.innerHTML = value;
2880        el._x_ignoreSelf = true;
2881        initTree(el);
2882        delete el._x_ignoreSelf;
2883      });
2884    });
2885  });
2886});
2887
2888// packages/alpinejs/src/directives/x-bind.js
2889mapAttributes(startingWith(":", into(prefix("bind:"))));
2890var handler2 = (el, { value, modifiers, expression, original }, { effect: effect3 }) => {
2891  if (!value) {
2892    let bindingProviders = {};
2893    injectBindingProviders(bindingProviders);
2894    let getBindings = evaluateLater(el, expression);
2895    getBindings((bindings) => {
2896      applyBindingsObject(el, bindings, original);
2897    }, { scope: bindingProviders });
2898    return;
2899  }
2900  if (value === "key")
2901    return storeKeyForXFor(el, expression);
2902  if (el._x_inlineBindings && el._x_inlineBindings[value] && el._x_inlineBindings[value].extract) {
2903    return;
2904  }
2905  let evaluate2 = evaluateLater(el, expression);
2906  effect3(() => evaluate2((result) => {
2907    if (result === void 0 && typeof expression === "string" && expression.match(/\./)) {
2908      result = "";
2909    }
2910    mutateDom(() => bind(el, value, result, modifiers));
2911  }));
2912};
2913handler2.inline = (el, { value, modifiers, expression }) => {
2914  if (!value)
2915    return;
2916  if (!el._x_inlineBindings)
2917    el._x_inlineBindings = {};
2918  el._x_inlineBindings[value] = { expression, extract: false };
2919};
2920directive("bind", handler2);
2921function storeKeyForXFor(el, expression) {
2922  el._x_keyExpression = expression;
2923}
2924
2925// packages/alpinejs/src/directives/x-data.js
2926addRootSelector(() => `[${prefix("data")}]`);
2927directive("data", (el, { expression }, { cleanup: cleanup2 }) => {
2928  if (shouldSkipRegisteringDataDuringClone(el))
2929    return;
2930  expression = expression === "" ? "{}" : expression;
2931  let magicContext = {};
2932  injectMagics(magicContext, el);
2933  let dataProviderContext = {};
2934  injectDataProviders(dataProviderContext, magicContext);
2935  let data2 = evaluate(el, expression, { scope: dataProviderContext });
2936  if (data2 === void 0 || data2 === true)
2937    data2 = {};
2938  injectMagics(data2, el);
2939  let reactiveData = reactive(data2);
2940  initInterceptors2(reactiveData);
2941  let undo = addScopeToNode(el, reactiveData);
2942  reactiveData["init"] && evaluate(el, reactiveData["init"]);
2943  cleanup2(() => {
2944    reactiveData["destroy"] && evaluate(el, reactiveData["destroy"]);
2945    undo();
2946  });
2947});
2948
2949// packages/alpinejs/src/directives/x-show.js
2950directive("show", (el, { modifiers, expression }, { effect: effect3 }) => {
2951  let evaluate2 = evaluateLater(el, expression);
2952  if (!el._x_doHide)
2953    el._x_doHide = () => {
2954      mutateDom(() => {
2955        el.style.setProperty("display", "none", modifiers.includes("important") ? "important" : void 0);
2956      });
2957    };
2958  if (!el._x_doShow)
2959    el._x_doShow = () => {
2960      mutateDom(() => {
2961        if (el.style.length === 1 && el.style.display === "none") {
2962          el.removeAttribute("style");
2963        } else {
2964          el.style.removeProperty("display");
2965        }
2966      });
2967    };
2968  let hide = () => {
2969    el._x_doHide();
2970    el._x_isShown = false;
2971  };
2972  let show = () => {
2973    el._x_doShow();
2974    el._x_isShown = true;
2975  };
2976  let clickAwayCompatibleShow = () => setTimeout(show);
2977  let toggle = once(
2978    (value) => value ? show() : hide(),
2979    (value) => {
2980      if (typeof el._x_toggleAndCascadeWithTransitions === "function") {
2981        el._x_toggleAndCascadeWithTransitions(el, value, show, hide);
2982      } else {
2983        value ? clickAwayCompatibleShow() : hide();
2984      }
2985    }
2986  );
2987  let oldValue;
2988  let firstTime = true;
2989  effect3(() => evaluate2((value) => {
2990    if (!firstTime && value === oldValue)
2991      return;
2992    if (modifiers.includes("immediate"))
2993      value ? clickAwayCompatibleShow() : hide();
2994    toggle(value);
2995    oldValue = value;
2996    firstTime = false;
2997  }));
2998});
2999
3000// packages/alpinejs/src/directives/x-for.js
3001directive("for", (el, { expression }, { effect: effect3, cleanup: cleanup2 }) => {
3002  let iteratorNames = parseForExpression(expression);
3003  let evaluateItems = evaluateLater(el, iteratorNames.items);
3004  let evaluateKey = evaluateLater(
3005    el,
3006    // the x-bind:key expression is stored for our use instead of evaluated.
3007    el._x_keyExpression || "index"
3008  );
3009  el._x_prevKeys = [];
3010  el._x_lookup = {};
3011  effect3(() => loop(el, iteratorNames, evaluateItems, evaluateKey));
3012  cleanup2(() => {
3013    Object.values(el._x_lookup).forEach((el2) => el2.remove());
3014    delete el._x_prevKeys;
3015    delete el._x_lookup;
3016  });
3017});
3018function loop(el, iteratorNames, evaluateItems, evaluateKey) {
3019  let isObject2 = (i) => typeof i === "object" && !Array.isArray(i);
3020  let templateEl = el;
3021  evaluateItems((items) => {
3022    if (isNumeric3(items) && items >= 0) {
3023      items = Array.from(Array(items).keys(), (i) => i + 1);
3024    }
3025    if (items === void 0)
3026      items = [];
3027    let lookup = el._x_lookup;
3028    let prevKeys = el._x_prevKeys;
3029    let scopes = [];
3030    let keys = [];
3031    if (isObject2(items)) {
3032      items = Object.entries(items).map(([key, value]) => {
3033        let scope2 = getIterationScopeVariables(iteratorNames, value, key, items);
3034        evaluateKey((value2) => keys.push(value2), { scope: { index: key, ...scope2 } });
3035        scopes.push(scope2);
3036      });
3037    } else {
3038      for (let i = 0; i < items.length; i++) {
3039        let scope2 = getIterationScopeVariables(iteratorNames, items[i], i, items);
3040        evaluateKey((value) => keys.push(value), { scope: { index: i, ...scope2 } });
3041        scopes.push(scope2);
3042      }
3043    }
3044    let adds = [];
3045    let moves = [];
3046    let removes = [];
3047    let sames = [];
3048    for (let i = 0; i < prevKeys.length; i++) {
3049      let key = prevKeys[i];
3050      if (keys.indexOf(key) === -1)
3051        removes.push(key);
3052    }
3053    prevKeys = prevKeys.filter((key) => !removes.includes(key));
3054    let lastKey = "template";
3055    for (let i = 0; i < keys.length; i++) {
3056      let key = keys[i];
3057      let prevIndex = prevKeys.indexOf(key);
3058      if (prevIndex === -1) {
3059        prevKeys.splice(i, 0, key);
3060        adds.push([lastKey, i]);
3061      } else if (prevIndex !== i) {
3062        let keyInSpot = prevKeys.splice(i, 1)[0];
3063        let keyForSpot = prevKeys.splice(prevIndex - 1, 1)[0];
3064        prevKeys.splice(i, 0, keyForSpot);
3065        prevKeys.splice(prevIndex, 0, keyInSpot);
3066        moves.push([keyInSpot, keyForSpot]);
3067      } else {
3068        sames.push(key);
3069      }
3070      lastKey = key;
3071    }
3072    for (let i = 0; i < removes.length; i++) {
3073      let key = removes[i];
3074      if (!!lookup[key]._x_effects) {
3075        lookup[key]._x_effects.forEach(dequeueJob);
3076      }
3077      lookup[key].remove();
3078      lookup[key] = null;
3079      delete lookup[key];
3080    }
3081    for (let i = 0; i < moves.length; i++) {
3082      let [keyInSpot, keyForSpot] = moves[i];
3083      let elInSpot = lookup[keyInSpot];
3084      let elForSpot = lookup[keyForSpot];
3085      let marker = document.createElement("div");
3086      mutateDom(() => {
3087        if (!elForSpot)
3088          warn(`x-for ":key" is undefined or invalid`, templateEl);
3089        elForSpot.after(marker);
3090        elInSpot.after(elForSpot);
3091        elForSpot._x_currentIfEl && elForSpot.after(elForSpot._x_currentIfEl);
3092        marker.before(elInSpot);
3093        elInSpot._x_currentIfEl && elInSpot.after(elInSpot._x_currentIfEl);
3094        marker.remove();
3095      });
3096      elForSpot._x_refreshXForScope(scopes[keys.indexOf(keyForSpot)]);
3097    }
3098    for (let i = 0; i < adds.length; i++) {
3099      let [lastKey2, index] = adds[i];
3100      let lastEl = lastKey2 === "template" ? templateEl : lookup[lastKey2];
3101      if (lastEl._x_currentIfEl)
3102        lastEl = lastEl._x_currentIfEl;
3103      let scope2 = scopes[index];
3104      let key = keys[index];
3105      let clone2 = document.importNode(templateEl.content, true).firstElementChild;
3106      let reactiveScope = reactive(scope2);
3107      addScopeToNode(clone2, reactiveScope, templateEl);
3108      clone2._x_refreshXForScope = (newScope) => {
3109        Object.entries(newScope).forEach(([key2, value]) => {
3110          reactiveScope[key2] = value;
3111        });
3112      };
3113      mutateDom(() => {
3114        lastEl.after(clone2);
3115        initTree(clone2);
3116      });
3117      if (typeof key === "object") {
3118        warn("x-for key cannot be an object, it must be a string or an integer", templateEl);
3119      }
3120      lookup[key] = clone2;
3121    }
3122    for (let i = 0; i < sames.length; i++) {
3123      lookup[sames[i]]._x_refreshXForScope(scopes[keys.indexOf(sames[i])]);
3124    }
3125    templateEl._x_prevKeys = keys;
3126  });
3127}
3128function parseForExpression(expression) {
3129  let forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
3130  let stripParensRE = /^\s*\(|\)\s*$/g;
3131  let forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
3132  let inMatch = expression.match(forAliasRE);
3133  if (!inMatch)
3134    return;
3135  let res = {};
3136  res.items = inMatch[2].trim();
3137  let item = inMatch[1].replace(stripParensRE, "").trim();
3138  let iteratorMatch = item.match(forIteratorRE);
3139  if (iteratorMatch) {
3140    res.item = item.replace(forIteratorRE, "").trim();
3141    res.index = iteratorMatch[1].trim();
3142    if (iteratorMatch[2]) {
3143      res.collection = iteratorMatch[2].trim();
3144    }
3145  } else {
3146    res.item = item;
3147  }
3148  return res;
3149}
3150function getIterationScopeVariables(iteratorNames, item, index, items) {
3151  let scopeVariables = {};
3152  if (/^\[.*\]$/.test(iteratorNames.item) && Array.isArray(item)) {
3153    let names = iteratorNames.item.replace("[", "").replace("]", "").split(",").map((i) => i.trim());
3154    names.forEach((name, i) => {
3155      scopeVariables[name] = item[i];
3156    });
3157  } else if (/^\{.*\}$/.test(iteratorNames.item) && !Array.isArray(item) && typeof item === "object") {
3158    let names = iteratorNames.item.replace("{", "").replace("}", "").split(",").map((i) => i.trim());
3159    names.forEach((name) => {
3160      scopeVariables[name] = item[name];
3161    });
3162  } else {
3163    scopeVariables[iteratorNames.item] = item;
3164  }
3165  if (iteratorNames.index)
3166    scopeVariables[iteratorNames.index] = index;
3167  if (iteratorNames.collection)
3168    scopeVariables[iteratorNames.collection] = items;
3169  return scopeVariables;
3170}
3171function isNumeric3(subject) {
3172  return !Array.isArray(subject) && !isNaN(subject);
3173}
3174
3175// packages/alpinejs/src/directives/x-ref.js
3176function handler3() {
3177}
3178handler3.inline = (el, { expression }, { cleanup: cleanup2 }) => {
3179  let root = closestRoot(el);
3180  if (!root._x_refs)
3181    root._x_refs = {};
3182  root._x_refs[expression] = el;
3183  cleanup2(() => delete root._x_refs[expression]);
3184};
3185directive("ref", handler3);
3186
3187// packages/alpinejs/src/directives/x-if.js
3188directive("if", (el, { expression }, { effect: effect3, cleanup: cleanup2 }) => {
3189  if (el.tagName.toLowerCase() !== "template")
3190    warn("x-if can only be used on a <template> tag", el);
3191  let evaluate2 = evaluateLater(el, expression);
3192  let show = () => {
3193    if (el._x_currentIfEl)
3194      return el._x_currentIfEl;
3195    let clone2 = el.content.cloneNode(true).firstElementChild;
3196    addScopeToNode(clone2, {}, el);
3197    mutateDom(() => {
3198      el.after(clone2);
3199      initTree(clone2);
3200    });
3201    el._x_currentIfEl = clone2;
3202    el._x_undoIf = () => {
3203      walk(clone2, (node) => {
3204        if (!!node._x_effects) {
3205          node._x_effects.forEach(dequeueJob);
3206        }
3207      });
3208      clone2.remove();
3209      delete el._x_currentIfEl;
3210    };
3211    return clone2;
3212  };
3213  let hide = () => {
3214    if (!el._x_undoIf)
3215      return;
3216    el._x_undoIf();
3217    delete el._x_undoIf;
3218  };
3219  effect3(() => evaluate2((value) => {
3220    value ? show() : hide();
3221  }));
3222  cleanup2(() => el._x_undoIf && el._x_undoIf());
3223});
3224
3225// packages/alpinejs/src/directives/x-id.js
3226directive("id", (el, { expression }, { evaluate: evaluate2 }) => {
3227  let names = evaluate2(expression);
3228  names.forEach((name) => setIdRoot(el, name));
3229});
3230
3231// packages/alpinejs/src/directives/x-on.js
3232mapAttributes(startingWith("@", into(prefix("on:"))));
3233directive("on", skipDuringClone((el, { value, modifiers, expression }, { cleanup: cleanup2 }) => {
3234  let evaluate2 = expression ? evaluateLater(el, expression) : () => {
3235  };
3236  if (el.tagName.toLowerCase() === "template") {
3237    if (!el._x_forwardEvents)
3238      el._x_forwardEvents = [];
3239    if (!el._x_forwardEvents.includes(value))
3240      el._x_forwardEvents.push(value);
3241  }
3242  let removeListener = on(el, value, modifiers, (e) => {
3243    evaluate2(() => {
3244    }, { scope: { "$event": e }, params: [e] });
3245  });
3246  cleanup2(() => removeListener());
3247}));
3248
3249// packages/alpinejs/src/directives/index.js
3250warnMissingPluginDirective("Collapse", "collapse", "collapse");
3251warnMissingPluginDirective("Intersect", "intersect", "intersect");
3252warnMissingPluginDirective("Focus", "trap", "focus");
3253warnMissingPluginDirective("Mask", "mask", "mask");
3254function warnMissingPluginDirective(name, directiveName, slug) {
3255  directive(directiveName, (el) => warn(`You can't use [x-${directiveName}] without first installing the "${name}" plugin here: https://alpinejs.dev/plugins/${slug}`, el));
3256}
3257
3258// packages/alpinejs/src/index.js
3259alpine_default.setEvaluator(normalEvaluator);
3260alpine_default.setReactivityEngine({ reactive: reactive2, effect: effect2, release: stop, raw: toRaw });
3261var src_default = alpine_default;
3262
3263// packages/alpinejs/builds/module.js
3264var module_default = src_default;
3265
3266
3267
3268/***/ }),
3269