https://mypage.hattatsu.go.jp/js/frontend.js

4/***/ "./node_modules/@alpinejs/collapse/dist/module.esm.js":
5/*!************************************************************!*\
6  !*** ./node_modules/@alpinejs/collapse/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/collapse/src/index.js
16function src_default(Alpine) {
17  Alpine.directive("collapse", collapse);
18  collapse.inline = (el, {modifiers}) => {
19    if (!modifiers.includes("min"))
20      return;
21    el._x_doShow = () => {
22    };
23    el._x_doHide = () => {
24    };
25  };
26  function collapse(el, {modifiers}) {
27    let duration = modifierValue(modifiers, "duration", 250) / 1e3;
28    let floor = modifierValue(modifiers, "min", 0);
29    let fullyHide = !modifiers.includes("min");
30    if (!el._x_isShown)
31      el.style.height = `${floor}px`;
32    if (!el._x_isShown && fullyHide)
33      el.hidden = true;
34    if (!el._x_isShown)
35      el.style.overflow = "hidden";
36    let setFunction = (el2, styles) => {
37      let revertFunction = Alpine.setStyles(el2, styles);
38      return styles.height ? () => {
39      } : revertFunction;
40    };
41    let transitionStyles = {
42      transitionProperty: "height",
43      transitionDuration: `${duration}s`,
44      transitionTimingFunction: "cubic-bezier(0.4, 0.0, 0.2, 1)"
45    };
46    el._x_transition = {
47      in(before = () => {
48      }, after = () => {
49      }) {
50        if (fullyHide)
51          el.hidden = false;
52        if (fullyHide)
53          el.style.display = null;
54        let current = el.getBoundingClientRect().height;
55        el.style.height = "auto";
56        let full = el.getBoundingClientRect().height;
57        if (current === full) {
58          current = floor;
59        }
60        Alpine.transition(el, Alpine.setStyles, {
61          during: transitionStyles,
62          start: {height: current + "px"},
63          end: {height: full + "px"}
64        }, () => el._x_isShown = true, () => {
65          if (el.style.height == `${full}px`) {
66            el.style.overflow = null;
67          }
68        });
69      },
70      out(before = () => {
71      }, after = () => {
72      }) {
73        let full = el.getBoundingClientRect().height;
74        Alpine.transition(el, setFunction, {
75          during: transitionStyles,
76          start: {height: full + "px"},
77          end: {height: floor + "px"}
78        }, () => el.style.overflow = "hidden", () => {
79          el._x_isShown = false;
80          if (el.style.height == `${floor}px` && fullyHide) {
81            el.style.display = "none";
82            el.hidden = true;
83          }
84        });
85      }
86    };
87  }
88}
89function modifierValue(modifiers, key, fallback) {
90  if (modifiers.indexOf(key) === -1)
91    return fallback;
92  const rawValue = modifiers[modifiers.indexOf(key) + 1];
93  if (!rawValue)
94    return fallback;
95  if (key === "duration") {
96    let match = rawValue.match(/([0-9]+)ms/);
97    if (match)
98      return match[1];
99  }
100  if (key === "min") {
101    let match = rawValue.match(/([0-9]+)px/);
102    if (match)
103      return match[1];
104  }
105  return rawValue;
106}
107
108// packages/collapse/builds/module.js
109var module_default = src_default;
110
111
112
113/***/ }),
114

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