https://pauljohncaffeine.in/wp-content/plugins/reviewx/resources/js/alpine.js?ver=6.9.9

1(() => {
2  // 

107// packages/alpinejs/src/mutation.js
108  var onAttributeAddeds = [];
109  var onElRemoveds = [];
110  var onElAddeds = [];
111  function onElAdded(callback) {
112    onElAddeds.push(callback);
113  }
114  function onElRemoved(el, callback) {
115    if (typeof callback === "function") {
116      if (!el._x_cleanups)
117        el._x_cleanups = [];
118      el._x_cleanups.push(callback);
119    } else {
120      callback = el;
121      onElRemoveds.push(callback);
122    }
123  }
124  function onAttributesAdded(callback) {
125    onAttributeAddeds.push(callback);
126  }
127  function onAttributeRemoved(el, name, callback) {
128    if (!el._x_attributeCleanups)
129      el._x_attributeCleanups = {};
130    if (!el._x_attributeCleanups[name])
131      el._x_attributeCleanups[name] = [];
132    el._x_attributeCleanups[name].push(callback);
133  }
134  function cleanupAttributes(el, names) {
135    if (!el._x_attributeCleanups)
136      return;
137    Object.entries(el._x_attributeCleanups).forEach(([name, value]) => {
138      if (names === void 0 || names.includes(name)) {
139        value.forEach((i) => i());
140        delete el._x_attributeCleanups[name];
141      }
142    });
143  }
144  function cleanupElement(el) {
145    if (el._x_cleanups) {
146      while (el._x_cleanups.length)
147        el._x_cleanups.pop()();
148    }
149  }
150  var observer = new MutationObserver(onMutate);
151  var currentlyObserving = false;
152  function startObservingMutations() {
153    observer.observe(document, { subtree: true, childList: true, attributes: true, attributeOldValue: true });
154    currentlyObserving = true;
155  }
156  function stopObservingMutations() {
157    flushObserver();
158    observer.disconnect();
159    currentlyObserving = false;
160  }
161  var queuedMutations = [];
162  function flushObserver() {
163    let records = observer.takeRecords();
164    queuedMutations.push(() => records.length > 0 && onMutate(records));
165    let queueLengthWhenTriggered = queuedMutations.length;
166    queueMicrotask(() => {
167      if (queuedMutations.length === queueLengthWhenTriggered) {
168        while (queuedMutations.length > 0)
169          queuedMutations.shift()();
170      }
171    });
172  }
173  function mutateDom(callback) {
174    if (!currentlyObserving)
175      return callback();
176    stopObservingMutations();
177    let result = callback();
178    startObservingMutations();
179    return result;
180  }
181  var isCollecting = false;
182  var deferredMutations = [];
183  function deferMutations() {
184    isCollecting = true;
185  }
186  function flushAndStopDeferringMutations() {
187    isCollecting = false;
188    onMutate(deferredMutations);
189    deferredMutations = [];
190  }
191  function onMutate(mutations) {
192    if (isCollecting) {
193      deferredMutations = deferredMutations.concat(mutations);
194      return;
195    }
196    let addedNodes = /* @__PURE__ */ new Set();
197    let removedNodes = /* @__PURE__ */ new Set();
198    let addedAttributes = /* @__PURE__ */ new Map();
199    let removedAttributes = /* @__PURE__ */ new Map();
200    for (let i = 0; i < mutations.length; i++) {
201      if (mutations[i].target._x_ignoreMutationObserver)
202        continue;
203      if (mutations[i].type === "childList") {
204        mutations[i].addedNodes.forEach((node) => node.nodeType === 1 && addedNodes.add(node));
205        mutations[i].removedNodes.forEach((node) => node.nodeType === 1 && removedNodes.add(node));
206      }
207      if (mutations[i].type === "attributes") {
208        let el = mutations[i].target;
209        let name = mutations[i].attributeName;
210        let oldValue = mutations[i].oldValue;
211        let add2 = () => {
212          if (!addedAttributes.has(el))
213            addedAttributes.set(el, []);
214          addedAttributes.get(el).push({ name, value: el.getAttribute(name) });
215        };
216        let remove = () => {
217          if (!removedAttributes.has(el))
218            removedAttributes.set(el, []);
219          removedAttributes.get(el).push(name);
220        };
221        if (el.hasAttribute(name) && oldValue === null) {
222          add2();
223        } else if (el.hasAttribute(name)) {
224          remove();
225          add2();
226        } else {
227          remove();
228        }
229      }
230    }
231    removedAttributes.forEach((attrs, el) => {
232      cleanupAttributes(el, attrs);
233    });

267// packages/alpinejs/src/scope.js
268  function scope(node) {
269    return mergeProxies(closestDataStack(node));
270  }
271  function addScopeToNode(node, data2, referenceNode) {
272    node._x_dataStack = [data2, ...closestDataStack(referenceNode || node)];
273    return () => {
274      node._x_dataStack = node._x_dataStack.filter((i) => i !== data2);
275    };
276  }
277  function closestDataStack(node) {
278    if (node._x_dataStack)
279      return node._x_dataStack;
280    if (typeof ShadowRoot === "function" && node instanceof ShadowRoot) {
281      return closestDataStack(node.host);
282    }
283    if (!node.parentNode) {
284      return [];
285    }
286    return closestDataStack(node.parentNode);
287  }
288  function mergeProxies(objects) {
289    return new Proxy({ objects }, mergeProxyTrap);
290  }
291  var mergeProxyTrap = {
292    ownKeys({ objects }) {
293      return Array.from(
294        new Set(objects.flatMap((i) => Object.keys(i)))
295      );
296    },
297    has({ objects }, name) {
298      if (name == Symbol.unscopables)
299        return false;
300      return objects.some(
301        (obj) => Object.prototype.hasOwnProperty.call(obj, name) || Reflect.has(obj, name)
302      );
303    },
304    get({ objects }, name, thisProxy) {
305      if (name == "toJSON")
306        return collapseProxies;
307      return Reflect.get(
308        objects.find(
309          (obj) => Reflect.has(obj, name)
310        ) || {},
311        name,
312        thisProxy
313      );
314    },
315    set({ objects }, name, value, thisProxy) {
316      const target = objects.find(
317        (obj) => Object.prototype.hasOwnProperty.call(obj, name)
318      ) || objects[objects.length - 1];
319      const descriptor = Object.getOwnPropertyDescriptor(target, name);
320      if (descriptor?.set && descriptor?.get)
321        return descriptor.set.call(thisProxy, value) || true;
322      return Reflect.set(target, name, value);
323    }
324  };
325  function collapseProxies() {
326    let keys = Reflect.ownKeys(this);
327    return keys.reduce((acc, key) => {
328      acc[key] = Reflect.get(this, key);
329      return acc;
330    }, {});
331  }
332
333  // packages/alpinejs/src/interceptor.js
334  function initInterceptors(data2) {
335    let isObject2 = (val) => typeof val === "object" && !Array.isArray(val) && val !== null;
336    let recurse = (obj, basePath = "") => {
337      Object.entries(Object.getOwnPropertyDescriptors(obj)).forEach(([key, { value, enumerable }]) => {
338        if (enumerable === false || value === void 0)
339          return;
340        if (typeof value === "object" && value !== null && value.__v_skip)
341          return;
342        let path = basePath === "" ? key : `${basePath}.${key}`;
343        if (typeof value === "object" && value !== null && value._x_interceptor) {
344          obj[key] = value.initialize(data2, path, key);
345        } else {
346          if (isObject2(value) && value !== obj && !(value instanceof Element)) {
347            recurse(value, path);
348          }
349        }
350      });
351    };
352    return recurse(data2);
353  }
354  function interceptor(callback, mutateObj = () => {
355  }) {
356    let obj = {
357      initialValue: void 0,
358      _x_interceptor: true,
359      initialize(data2, path, key) {
360        return callback(this.initialValue, () => get(data2, path), (value) => set(data2, path, value), path, key);
361      }
362    };
363    mutateObj(obj);
364    return (initialValue) => {
365      if (typeof initialValue === "object" && initialValue !== null && initialValue._x_interceptor) {
366        let initialize = obj.initialize.bind(obj);
367        obj.initialize = (data2, path, key) => {
368          let innerValue = initialValue.initialize(data2, path, key);
369          obj.initialValue = innerValue;
370          return initialize(data2, path, key);
371        };
372      } else {
373        obj.initialValue = initialValue;
374      }
375      return obj;
376    };
377  }
378  function get(obj, path) {
379    return path.split(".").reduce((carry, segment) => carry[segment], obj);
380  }
381  function set(obj, path, value) {
382    if (typeof path === "string")
383      path = path.split(".");
384    if (path.length === 1)
385      obj[path[0]] = value;
386    else if (path.length === 0)
387      throw error;
388    else {
389      if (obj[path[0]])
390        return set(obj[path[0]], path.slice(1), value);
391      else {
392        obj[path[0]] = {};
393        return set(obj[path[0]], path.slice(1), value);
394      }
395    }
396  }
397
398  

447// packages/alpinejs/src/evaluator.js
448  var shouldAutoEvaluateFunctions = true;
449  function dontAutoEvaluateFunctions(callback) {
450    let cache = shouldAutoEvaluateFunctions;
451    shouldAutoEvaluateFunctions = false;
452    let result = callback();
453    shouldAutoEvaluateFunctions = cache;
454    return result;
455  }
456  function evaluate(el, expression, extras = {}) {
457    let result;
458    evaluateLater(el, expression)((value) => result = value, extras);
459    return result;
460  }
461  function evaluateLater(...args) {
462    return theEvaluatorFunction(...args);
463  }
464  var theEvaluatorFunction = normalEvaluator;
465  function setEvaluator(newEvaluator) {
466    theEvaluatorFunction = newEvaluator;
467  }
468  function normalEvaluator(el, expression) {
469    let overriddenMagics = {};
470    injectMagics(overriddenMagics, el);
471    let dataStack = [overriddenMagics, ...closestDataStack(el)];
472    let evaluator = typeof expression === "function" ? generateEvaluatorFromFunction(dataStack, expression) : generateEvaluatorFromString(dataStack, expression, el);
473    return tryCatch.bind(null, el, expression, evaluator);
474  }
475  function generateEvaluatorFromFunction(dataStack, func) {
476    return (receiver = () => {
477    }, { scope: scope2 = {}, params = [] } = {}) => {
478      let result = func.apply(mergeProxies([scope2, ...dataStack]), params);
479      runIfTypeOfFunction(receiver, result);
480    };
481  }
482  var evaluatorMemo = {};
483  function generateFunctionFromString(expression, el) {
484    if (evaluatorMemo[expression]) {
485      return evaluatorMemo[expression];
486    }
487    let AsyncFunction = Object.getPrototypeOf(async function() {
488    }).constructor;
489    let rightSideSafeExpression = /^[\n\s]*if.*\(.*\)/.test(expression.trim()) || /^(let|const)\s/.test(expression.trim()) ? `(async()=>{ ${expression} })()` : expression;
490    const safeAsyncFunction = () => {
491      try {
492        let func2 = new AsyncFunction(
493          ["__self", "scope"],
494          `with (scope) { __self.result = ${rightSideSafeExpression} }; __self.finished = true; return __self.result;`
495        );
496        Object.defineProperty(func2, "name", {
497          value: `[Alpine] ${expression}`
498        });
499        return func2;
500      } catch (error2) {
501        handleError(error2, el, expression);
502        return Promise.resolve();
503      }
504    };
505    let func = safeAsyncFunction();
506    evaluatorMemo[expression] = func;
507    return func;
508  }
509  function generateEvaluatorFromString(dataStack, expression, el) {
510    let func = generateFunctionFromString(expression, el);
511    return (receiver = () => {
512    }, { scope: scope2 = {}, params = [] } = {}) => {
513      func.result = void 0;
514      func.finished = false;
515      let completeScope = mergeProxies([scope2, ...dataStack]);
516      if (typeof func === "function") {
517        let promise = func(func, completeScope).catch((error2) => handleError(error2, el, expression));
518        if (func.finished) {
519          runIfTypeOfFunction(receiver, func.result, completeScope, params, el);
520          func.result = void 0;
521        } else {
522          promise.then((result) => {
523            runIfTypeOfFunction(receiver, result, completeScope, params, el);
524          }).catch((error2) => handleError(error2, el, expression)).finally(() => func.result = void 0);
525        }
526      }
527    };
528  }
529  function runIfTypeOfFunction(receiver, value, scope2, params, el) {
530    if (shouldAutoEvaluateFunctions && typeof value === "function") {
531      let result = value.apply(scope2, params);
532      if (result instanceof Promise) {
533        result.then((i) => runIfTypeOfFunction(receiver, i, scope2, params)).catch((error2) => handleError(error2, el, value));
534      } else {
535        receiver(result);
536      }
537    } else if (typeof value === "object" && value instanceof Promise) {
538      value.then((i) => receiver(i));
539    } else {
540      receiver(value);
541    }
542  }
543
544  // packages/alpinejs/src/directives.js
545  var prefixAsString = "x-";
546  function prefix(subject = "") {
547    return prefixAsString + subject;
548  }
549  function setPrefix(newPrefix) {
550    prefixAsString = newPrefix;
551  }
552  var directiveHandlers = {};
553  function directive(name, callback) {
554    directiveHandlers[name] = callback;
555    return {
556      before(directive2) {
557        if (!directiveHandlers[directive2]) {
558          console.warn(String.raw`Cannot find directive \`${directive2}\`. \`${name}\` will use the default order of execution`);
559          return;
560        }
561        const pos = directiveOrder.indexOf(directive2);
562        directiveOrder.splice(pos >= 0 ? pos : directiveOrder.indexOf("DEFAULT"), 0, name);
563      }
564    };
565  }
566  function directiveExists(name) {
567    return Object.keys(directiveHandlers).includes(name);
568  }
569  function directives(el, attributes, originalAttributeOverride) {
570    attributes = Array.from(attributes);
571    if (el._x_virtualDirectives) {
572      let vAttributes = Object.entries(el._x_virtualDirectives).map(([name, value]) => ({ name, value }));
573      let staticAttributes = attributesOnly(vAttributes);
574      vAttributes = vAttributes.map((attribute) => {
575        if (staticAttributes.find((attr) => attr.name === attribute.name)) {
576          return {
577            name: `x-bind:${attribute.name}`,
578            value: `"${attribute.value}"`
579          };
580        }
581        return attribute;
582      });
583      attributes = attributes.concat(vAttributes);
584    }
585    let transformedAttributeMap = {};
586    let directives2 = attributes.map(toTransformedAttributes((newName, oldName) => transformedAttributeMap[newName] = oldName)).filter(outNonAlpineAttributes).map(toParsedDirectives(transformedAttributeMap, originalAttributeOverride)).sort(byPriority);
587    return directives2.map((directive2) => {
588      return getDirectiveHandler(el, directive2);
589    });
590  }
591  function attributesOnly(attributes) {
592    return Array.from(attributes).map(toTransformedAttributes()).filter((attr) => !outNonAlpineAttributes(attr));
593  }
594  var isDeferringHandlers = false;
595  var directiveHandlerStacks = /* @__PURE__ */ new Map();
596  var currentHandlerStackKey = Symbol();
597  function deferHandlingDirectives(callback) {
598    isDeferringHandlers = true;
599    let key = Symbol();
600    currentHandlerStackKey = key;
601    directiveHandlerStacks.set(key, []);
602    let flushHandlers = () => {
603      while (directiveHandlerStacks.get(key).length)
604        directiveHandlerStacks.get(key).shift()();
605      directiveHandlerStacks.delete(key);
606    };
607    let stopDeferring = () => {
608      isDeferringHandlers = false;
609      flushHandlers();
610    };
611    callback(flushHandlers);
612    stopDeferring();
613  }
614  function getElementBoundUtilities(el) {
615    let cleanups = [];
616    let cleanup2 = (callback) => cleanups.push(callback);
617    let [effect3, cleanupEffect] = elementBoundEffect(el);
618    cleanups.push(cleanupEffect);
619    let utilities = {
620      Alpine: alpine_default,
621      effect: effect3,
622      cleanup: cleanup2,
623      evaluateLater: evaluateLater.bind(evaluateLater, el),
624      evaluate: evaluate.bind(evaluate, el)
625    };
626    let doCleanup = () => cleanups.forEach((i) => i());
627    return [utilities, doCleanup];
628  }
629  function getDirectiveHandler(el, directive2) {
630    let noop = () => {
631    };
632    let handler4 = directiveHandlers[directive2.type] || noop;
633    let [utilities, cleanup2] = getElementBoundUtilities(el);
634    onAttributeRemoved(el, directive2.original, cleanup2);
635    let fullHandler = () => {
636      if (el._x_ignore || el._x_ignoreSelf)
637        return;
638      handler4.inline && handler4.inline(el, directive2, utilities);
639      handler4 = handler4.bind(handler4, el, directive2, utilities);
640      isDeferringHandlers ? directiveHandlerStacks.get(currentHandlerStackKey).push(handler4) : handler4();
641    };
642    fullHandler.runCleanups = cleanup2;
643    return fullHandler;
644  }
645  var startingWith = (subject, replacement) => ({ name, value }) => {
646    if (name.startsWith(subject))
647      name = name.replace(subject, replacement);
648    return { name, value };
649  };
650  var into = (i) => i;
651  function toTransformedAttributes(callback = () => {
652  }) {
653    return ({ name, value }) => {
654      let { name: newName, value: newValue } = attributeTransformers.reduce((carry, transform) => {
655        return transform(carry);
656      }, { name, value });
657      if (newName !== name)
658        callback(newName, name);
659      return { name: newName, value: newValue };
660    };
661  }
662  var attributeTransformers = [];
663  function mapAttributes(callback) {
664    attributeTransformers.push(callback);
665  }
666  function outNonAlpineAttributes({ name }) {
667    return alpineAttributeRegex().test(name);
668  }
669  var alpineAttributeRegex = () => new RegExp(`^${prefixAsString}([^:^.]+)\\b`);
670  function toParsedDirectives(transformedAttributeMap, originalAttributeOverride) {
671    return ({ name, value }) => {
672      let typeMatch = name.match(alpineAttributeRegex());
673      let valueMatch = name.match(/:([a-zA-Z0-9\-_:]+)/);
674      let modifiers = name.match(/\.[^.\]]+(?=[^\]]*$)/g) || [];
675      let original = originalAttributeOverride || transformedAttributeMap[name] || name;
676      return {
677        type: typeMatch ? typeMatch[1] : null,
678        value: valueMatch ? valueMatch[1] : null,
679        modifiers: modifiers.map((i) => i.replace(".", "")),
680        expression: value,
681        original
682      };
683    };
684  }
685  var DEFAULT = "DEFAULT";
686  var directiveOrder = [
687    "ignore",
688    "ref",
689    "data",
690    "id",
691    "anchor",
692    "bind",
693    "init",
694    "for",
695    "model",
696    "modelable",
697    "transition",
698    "show",
699    "if",
700    DEFAULT,
701    "teleport"
702  ];
703  function byPriority(a, b) {
704    let typeA = directiveOrder.indexOf(a.type) === -1 ? DEFAULT : a.type;
705    let typeB = directiveOrder.indexOf(b.type) === -1 ? DEFAULT : b.type;
706    return directiveOrder.indexOf(typeA) - directiveOrder.indexOf(typeB);
707  }
708
709  

719);
720  }
721
722  // packages/alpinejs/src/utils/walk.js
723  function walk(el, callback) {
724    if (typeof ShadowRoot === "function" && el instanceof ShadowRoot) {
725      Array.from(el.children).forEach((el2) => walk(el2, callback));
726      return;
727    }
728    let skip = false;
729    callback(el, () => skip = true);
730    if (skip)
731      return;
732    let node = el.firstElementChild;
733    while (node) {
734      walk(node, callback, false);
735      node = node.nextElementSibling;
736    }
737  }
738
739  // packages/alpinejs/src/utils/warn.js
740  function warn(message, ...args) {
741    console.warn(`Alpine Warning: ${message}`, ...args);
742  }
743
744  // packages/alpinejs/src/lifecycle.js
745  var started = false;
746  function start() {
747    if (started)
748      warn("Alpine has already been initialized on this page. Calling Alpine.start() more than once can cause problems.");
749    started = true;
750    if (!document.body)
751      warn("Unable to initialize. Trying to load Alpine before `<body>` is available. Did you forget to add `defer` in Alpine's `<script>` tag?");
752    dispatch(document, "alpine:init");
753    dispatch(document, "alpine:initializing");
754    startObservingMutations();
755    onElAdded((el) => initTree(el, walk));
756    onElRemoved((el) => destroyTree(el));
757    onAttributesAdded((el, attrs) => {
758      

758directives(el, attrs).forEach((handle) => handle());
759    });
760    let outNestedComponents = (el) => !closestRoot(el.parentElement, true);
761    Array.from(document.querySelectorAll(allSelectors().join(","))).filter(outNestedComponents).forEach((el) => {
762      initTree(el);
763    });
764    dispatch(document, "alpine:initialized");
765    setTimeout(() => {
766      warnAboutMissingPlugins();
767    });
768  }
769  var rootSelectorCallbacks = [];
770  var initSelectorCallbacks = [];
771  function rootSelectors() {
772    return rootSelectorCallbacks.map((fn) => fn());
773  }
774  function allSelectors() {
775    return rootSelectorCallbacks.concat(initSelectorCallbacks).map((fn) => fn());
776  }
777  function addRootSelector(selectorCallback) {
778    rootSelectorCallbacks.push(selectorCallback);
779  }
780  function addInitSelector(selectorCallback) {
781    initSelectorCallbacks.push(selectorCallback);
782  }
783  function closestRoot(el, includeInitSelectors = false) {
784    return findClosest(el, (element) => {
785      const selectors = includeInitSelectors ? allSelectors() : rootSelectors();
786      if (selectors.some((selector) => element.matches(selector)))
787        return true;
788    });
789  }
790  function findClosest(el, callback) {
791    if (!el)
792      return;
793    if (callback(el))
794      return el;
795    if (el._x_teleportBack)
796      el = el._x_teleportBack;
797    if (!el.parentElement)
798      return;
799    return findClosest(el.parentElement, callback);
800  }
801  function isRoot(el) {
802    return rootSelectors().some((selector) => el.matches(selector));
803  }
804  var initInterceptors2 = [];
805  function interceptInit(callback) {
806    initInterceptors2.push(callback);
807  }
808  function initTree(el, walker = walk, intercept = () => {
809  }) {
810    deferHandlingDirectives(() => {
811      walker(el, (el2, skip) => {
812        intercept(el2, skip);
813        initInterceptors2.forEach((i) => i(el2, skip));
814        directives(el2, el2.attributes).forEach((handle) => handle());
815        el2._x_ignore && skip();
816      });
817    });
818  }
819  function destroyTree(root, walker = walk) {
820    walker(root, (el) => {
821      cleanupAttributes(el);
822      cleanupElement(el)

822;
823    });
824  }
825  function warnAboutMissingPlugins() {
826    let pluginDirectives = [
827      ["ui", "dialog", ["[x-dialog], [x-popover]"]],
828      ["anchor", "anchor", ["[x-anchor]"]],
829      ["sort", "sort", ["[x-sort]"]]
830    ];
831    pluginDirectives.forEach(([plugin2, directive2, selectors]) => {
832      if (directiveExists(directive2))
833        return;
834      selectors.some((selector) => {
835        if (document.querySelector(selector)) {
836          warn(`found "${selector}", but missing ${plugin2} plugin`);
837          return true;
838        }
839      });
840    });
841  }
842
843  // packages/alpinejs/src/nextTick.js
844  var tickStack = [];
845  var isHolding = false;
846  function nextTick(callback = () => {
847  }) {
848    queueMicrotask(() => {
849      isHolding || setTimeout(() => {
850        releaseNextTicks();
851      });
852    });
853    return new Promise((res) => {
854      tickStack.push(() => {
855        callback();
856        res();
857      });
858    });
859  }
860  function releaseNextTicks() {
861    isHolding = false;
862    while (tickStack.length)
863      tickStack.shift()();
864  }
865  function holdNextTicks() {
866    isHolding = true;
867  }
868
869  // packages/alpinejs/src/utils/classes.js
870  function setClasses(el, value) {
871    if (Array.isArray(value)) {
872      return setClassesFromString(el, value.join(" "));
873    } else if (typeof value === "object" && value !== null) {
874      return setClassesFromObject(el, value);
875    } else if (typeof value === "function") {
876      return setClasses(el, value());
877    }
878    return setClassesFromString(el, value);
879  }
880  function s

895(classString) : false).filter(Boolean);
896    let added = [];
897    let removed = [];
898    forRemove.forEach((i) => {
899      if (el.classList.contains(i)) {
900        el.classList.remove(i);
901        removed.push(i);
902      }
903    });
904    forAdd.forEach((i) => {
905      if (!el.classList.contains(i)) {
906        el.classList.add(i);
907        added.push(i);
908      }
909    });
910    return () => {
911      removed.forEach((i) => el.classList.add(i));
912      added.forEach((i) => el.classList.remove(i));
913    };
914  }
915
916  // packages/alpinejs/src/utils/styles.js
917  function setStyles(el, value) {
918    if (typeof value === "object" && value !== null) {
919      return setStylesFromObject(el, value);
920    }
921    return setStylesFromString(el, value);
922  }
923  function setStylesFromObject(el, value) {
924    let previousStyles = {};
925    Object.entries(value).forEach(([key, value2]) => {
926      previousStyles[key] = el.style[key];
927      if (!key.startsWith("--")) {
928        key = kebabCase(key);
929      }
930      el.style.setProperty(key, value2);
931    });
932    setTimeout(() => {
933      if (el.style.length === 0) {
934        el.removeAttribute("style");
935      }
936    });
937    return () => {
938      setStyles(el, previousStyles);
939    };
940  }
941  function setStylesFromString(el, value) {
942    let cache = el.getAttribute("style", value);
943    el.setAttribute("style", value);
944    return () => {
945      el.setAttribute("style", cache || "");
946    };
947  }
948  function kebabCase(subject) {
949    return subject.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
950  }
951
952  // packages/alpinejs/src/utils/once.js
953  function once(callback, fallback = () => {
954  }) {
955    let called = false;
956    return function() {
957      if (!called) {
958        called = true;
959        callback.apply(this, arguments);
960      } else {
961        fallback.apply(this, arguments);
962      }
963    };
964  }
965
966  // packages/alpinejs/src/directives/x-transition.js
967  directive("transition", (el, { value, modifiers, expression }, { evaluate: evaluate2 }) => {
968    if (typeof expression === "function")
969      expression = evaluate2(expression);
970    if (expression === false)
971      return;
972    if (!expression || typeof expression === "boolean") {
973      registerTransitionsFromHelper(el, modifiers, value);
974    } else {
975      registerTransitionsFromClassString(el, expression, value);
976    }
977  });
978  function registerTransitionsFromClassString(el, classString, stage) {
979    registerTransitionObject(el, setClasses, "");
980    let directiveStorageMap = {
981      "enter": (classes) => {
982        el._x_transition.enter.during = classes;
983      },
984      "enter-start": (classes) => {
985        el._x_transition.enter.start = classes;
986      },
987      "enter-end": (classes) => {
988        el._x_transition.enter.end = classes;
989      },
990      "leave": (classes) => {
991        el._x_transition.leave.during = classes;
992      },
993      "leave-start": (classes) => {
994        el._x_transition.leave.start = classes;
995      },
996      "leave-end": (classes) => {
997        el._x_transition.leave.end = classes;
998      }
999    };
1000    directiveStorageMap[stage](classString);
1001  }
1002  function registerTransitionsFromHelper(el, modifiers, stage) {
1003    registerTransitionObject(el, setStyles);
1004    let doesntSpecify = !modifiers.includes("in") && !modifiers.includes("out") && !stage;
1005    let transitioningIn = doesntSpecify || modifiers.includes("in") || ["enter"].includes(stage);
1006    let transitioningOut = doesntSpecify || modifiers.includes("out") || ["leave"].includes(stage);
1007    if (modifiers.includes("in") && !doesntSpecify) {
1008      modifiers = modifiers.filter((i, index) => index < modifiers.indexOf("out"));
1009    }
1010    if (modifiers.includes("out") && !doesntSpecify) {
1011      modifiers = modifiers.filter((i, index) => index > modifiers.indexOf("out"));
1012    }
1013    let wantsAll = !modifiers.includes("opacity") && !modifiers.includes("scale");
1014    let wantsOpacity = wantsAll || modifiers.includes("opacity");
1015    let wantsScale = wantsAll || modifiers.includes("scale");
1016    let opacityValue = wantsOpacity ? 0 : 1;
1017    let scaleValue = wantsScale ? modifierValue(modifiers, "scale", 95) / 100 : 1;
1018    let delay = modifierValue(modifiers, "delay", 0) / 1e3;
1019    let origin = modifierValue(modifiers, "origin", "center");
1020    let property = "opacity, transform";
1021    let durationIn = modifierValue(modifiers, "duration", 150) / 1e3;
1022    let durationOut = modifierValue(modifiers, "duration", 75) / 1e3;
1023    let easing = `cubic-bezier(0.4, 0.0, 0.2, 1)`;
1024    if (transitioningIn) {
1025      el._x_transition.enter.during = {
1026        transformOrigin: origin,
1027        transitionDelay: `${delay}s`,
1028        transitionProperty: property,
1029        transitionDuration: `${durationIn}s`,
1030        transitionTimingFunction: easing
1031      };
1032      el._x_transition.enter.start = {
1033        opacity: opacityValue,
1034        transform: `scale(${scaleValue})`
1035      };
1036      el._x_transition.enter.end = {
1037        opacity: 1,
1038        transform: `scale(1)`
1039      };
1040    }
1041    if (transitioningOut) {
1042      el._x_transition.leave.during = {
1043        transformOrigin: origin,
1044        transitionDelay: `${delay}s`,
1045        transitionProperty: property,
1046        transitionDuration: `${durationOut}s`,
1047        transitionTimingFunction: easing
1048      };
1049      el._x_transition.leave.start = {
1050        opacity: 1,
1051        transform: `scale(1)`
1052      };
1053      el._x_transition.leave.end = {
1054        opacity: opacityValue,
1055        transform: `scale(${scaleValue})`
1056      };
1057    }
1058  }
1059  function registerTransitionObject(el, setFunction, defaultValue = {}) {
1060    if (!el._x_transition)
1061      el._x_transition = {
1062        enter: { during: defaultValue, start: defaultValue, end: defaultValue },
1063        leave: { during: defaultValue, start: defaultValue, end: defaultValue },
1064        in(before = () => {
1065        }, after = () => {
1066        }) {
1067          transition(el, setFunction, {
1068            during: this.enter.during,
1069            start: this.enter.start,
1070            end: this.enter.end
1071          }, before, after);
1072        },
1073        out(before = () => {
1074        }, after = () => {
1075        }) {
1076          transition(el, setFunction, {
1077            during: this.leave.during,
1078            start: this.leave.start,
1079            end: this.leave.end
1080          }, before, after);
1081        }
1082      };
1083  }
1084  window.Element.prototype._x_toggleAndCascadeWithTransitions = function(el, value, show, hide) {
1085    const nextTick2 = document.visibilityState === "visible" ? requestAnimationFrame : setTimeout;
1086    let clickAwayCompatibleShow = () => nextTick2(show);
1087    if (value) {
1088      if (el._x_transition && (el._x_transition.enter || el._x_transition.leave)) {
1089        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();
1090      } else {
1091        el._x_transition ? el._x_transition.in(show) : clickAwayCompatibleShow();
1092      }
1093      return;
1094    }
1095    el._x_hidePromise = el._x_transition ? new Promise((resolve, reject) => {
1096      el._x_transition.out(() => {
1097      }, () => resolve(hide));
1098      el._x_transitioning && el._x_transitioning.beforeCancel(() => reject({ isFromCancelledTransition: true }));
1099    }) : Promise.resolve(hide);
1100    queueMicrotask(() => {
1101      let closest = closestHide(el);
1102      if (closest) {
1103        if (!closest._x_hideChildren)
1104          closest._x_hideChildren = [];
1105        closest._x_hideChildren.push(el);
1106      } else {
1107        nextTick2(() => {
1108          let hideAfterChildren = (el2) => {
1109            let carry = Promise.all([
1110              el2._x_hidePromise,
1111              ...(el2._x_hideChildren || []).map(hideAfterChildren)
1112            ]).then(([i]) => i?.());
1113            delete el2._x_hidePromise;
1114            delete el2._x_hideChildren;
1115            return carry;
1116          };
1117          hideAfterChildren(el).catch((e) => {
1118            if (!e.isFromCancelledTransition)
1119              throw e;
1120          });
1121        });
1122      }
1123    });
1124  };
1125  function closestHide(el) {
1126    let parent = el.parentNode;
1127    if (!parent)
1128      return;
1129    return parent._x_hidePromise ? parent : closestHide(parent);
1130  }
1131  function transition(el, setFunction, { during, start: start2, end } = {}, before = () => {
1132  }, after = () => {
1133  }) {
1134    if (el._x_transitioning)
1135      el._x_transitioning.cancel();
1136    if (Object.keys(during).length === 0 && Object.keys(start2).length === 0 && Object.keys(end).length === 0) {
1137      before();
1138      after();
1139      return;
1140    }
1141    let undoStart, undoDuring, undoEnd;
1142    performTransition(el, {
1143      start() {
1144        undoStart = setFunction(el, start2);
1145      },
1146      during() {
1147        undoDuring = setFunction(el, during);
1148      },
1149      before,
1150      end() {
1151        undoStart();
1152        undoEnd = setFunction(el, end);
1153      },
1154      after,
1155      cleanup() {
1156        undoDuring();
1157        undoEnd();
1158      }
1159    });
1160  }
1161  function performTransition(el, stages) {
1162    let interrupted, reachedBefore, reachedEnd;
1163    let finish = once(() => {
1164      mutateDom(() => {
1165        interrupted = true;
1166        if (!reachedBefore)
1167          stages.before();
1168        if (!reachedEnd) {
1169          stages.end();
1170          releaseNextTicks();
1171        }
1172        stages.after();
1173        if (el.isConnected)
1174          stages.cleanup();
1175        delete el._x_transitioning;
1176      });
1177    });
1178    el._x_transitioning = {
1179      beforeCancels: [],
1180      beforeCancel(callback) {
1181        this.beforeCancels.push(callback);
1182      },
1183      cancel: once(function() {
1184        while (this.beforeCancels.length) {
1185          this.beforeCancels.shift()();
1186        }
1187        ;
1188        finish();
1189      }),
1190      finish
1191    };
1192    mutateDom(() => {
1193      stages.start();
1194      stages.during();
1195    });
1196    holdNextTicks();
1197    requestAnimationFrame(() => {
1198      if (interrupted)
1199        return;
1200      let duration = Number(getComputedStyle(el).transitionDuration.replace(/,.*/, "").replace("s", "")) * 1e3;
1201      let delay = Number(getComputedStyle(el).transitionDelay.replace(/,.*/, "").replace("s", "")) * 1e3;
1202      if (duration === 0)
1203        duration = Number(getComputedStyle(el).animationDuration.replace("s", "")) * 1e3;
1204      mutateDom(() => {
1205        stages.before();
1206      });
1207      reachedBefore = true;
1208      requestAnimationFrame(() => {
1209        if (interrupted)
1210          return;
1211        mutateDom(() => {
1212          stages.end();
1213        });
1214        releaseNextTicks();
1215        setTimeout(el._x_transitioning.finish, duration + delay);
1216        reachedEnd = true;
1217      });
1218    });
1219  }
1220  function modifierValue(modifiers, key, fallback) {
1221    if (modifiers.indexOf(key) === -1)
1222      return fallback;
1223    const rawValue = modifiers[modifiers.indexOf(key) + 1];
1224    if (!rawValue)
1225      return fallback;
1226    if (key === "scale") {
1227      if (isNaN(rawValue))
1228        return fallback;
1229    }
1230    if (key === "duration" || key === "delay") {
1231      let match = rawValue.match(/([0-9]+)ms/);
1232      if (match)
1233        return match[1];
1234    }
1235    if (key === "origin") {
1236      if (["top", "right", "left", "center", "bottom"].includes(modifiers[modifiers.indexOf(key) + 2])) {
1237        return [rawValue, modifiers[modifiers.indexOf(key) + 2]].join(" ");
1238      }
1239    }
1240    return rawValue;
1241  }
1242
1243  // packages/alpinejs/src/clone.js
1244  var isCloning = false;
1245  function skipDuringClone(callback, fallback = () => {
1246  }) {
1247    return (...args) => isCloning ? fallback(...args) : callback(...args);
1248  }
1249  function onlyDuringClone(callback) {
1250    return (...args) => isCloning && callback(...args);
1251  }
1252  var interceptors = [];
1253  function interceptClone(callback) {
1254    interceptors.push(callback);
1255  }
1256  function cloneNode(from, to) {
1257    interceptors.forEach((i) => i(from, to));
1258    isCloning = true;
1259    dontRegisterReactiveSideEffects(() => {
1260      initTree(to, (el, callback) => {
1261        callback(el, () => {
1262        });
1263      });
1264    });
1265    isCloning = false;
1266  }
1267  var isCloningLegacy = false;
1268  function clone(oldEl, newEl) {
1269    if (!newEl._x_dataStack)
1270      newEl._x_dataStack = oldEl._x_dataStack;
1271    isCloning = true;
1272    isCloningLegacy = true;
1273    dontRegisterReactiveSideEffects(() => {
1274      cloneTree(newEl);
1275    });
1276    isCloning = false;
1277    isCloningLegacy = false;
1278  }
1279  function cloneTree(el) {
1280    let hasRunThroughFirstEl = false;
1281    let shallowWalker = (el2, callback) => {
1282      walk(el2, (el3, skip) => {
1283        if (hasRunThroughFirstEl && isRoot(el3))
1284          return skip();
1285        hasRunThroughFirstEl = true;
1286        callback(el3, skip);
1287      });
1288    };
1289    initTree(el, shallowWalker);
1290  }
1291  function dontRegisterReactiveSideEffects(callback) {
1292    let cache = effect;
1293    overrideEffect((callback2, el) => {
1294      let storedEffect = cache(callback2);
1295      release(storedEffect);
1296      return () => {
1297      };
1298    });
1299    callback();
1300    overrideEffect(cache);
1301  }
1302
1303  // packages/alpinejs/src/

1303utils/bind.js
1304  function bind(el, name, value, modifiers = []) {
1305    if (!el._x_bindings)
1306      el._x_bindings = reactive({});
1307    el._x_bindings[name] = value;
1308    name = modifiers.includes("camel") ? camelCase(name) : name;
1309    switch (name) {
1310      case "value":
1311        bindInputValue(el, value);
1312        break;
1313      case "style":
1314        bindStyles(el, value);
1315        break;
1316      case "class":
1317        bindClasses(el, value);
1318        break;
1319      case "selected":
1320      case "checked":
1321        bindAttributeAndProperty(el, name, value);
1322        break;
1323      default:
1324        bindAttribute(el, name, value);
1325        break;
1326    }
1327  }
1328  function bindInputValue(el, value) {
1329    if (el.type === "radio") {
1330      if (el.attributes.value === void 0) {
1331        el.value = value;
1332      }
1333      if (window.fromModel) {
1334        if (typeof value === "boolean") {
1335          el.checked = safeParseBoolean(el.value) === value;
1336        } else {
1337          el.checked = checkedAttrLooseCompare(el.value, value);
1338        }
1339      }
1340    } else if (el.type === "checkbox") {
1341      if (Number.isInteger(value)) {
1342        el.value = value;
1343      } else if (!Array.isArray(value) && typeof value !== "boolean" && ![null, void 0].includes(value)) {

1344        el.value = String(value);
1345      } else {
1346        if (Array.isArray(value)) {
1347          el.checked = value.some((val) => checkedAttrLooseCompare(val, el.value));
1348        } else {
1349          el.checked = !!value;
1350        }
1351      }
1352    } else if (el.tagName === "SELECT") {
1353      updateSelect(el, value);
1354    } else {
1355      if (el.value === value)
1356        return;
1357      el.value = value === void 0 ? "" : value;
1358    }
1359  }
1360  function bindClasses(el, value) {
1361    if (el._x_undoAddedClasses)
1362      el._x_undoAddedClasses();
1363    el._x_undoAddedClasses = setClasses(el, value);
1364  }
1365  function bindStyles(el, value) {
1366    if (el._x_undoAddedStyles)
1367      el._x_undoAddedStyles();
1368    el._x_undoAddedStyles = setStyles(el, value);
1369  }
1370  function bindAttributeAndProperty(el, name, value) {
1371    bindAttribute(el, name, value);
1372    setPropertyIfChanged(el, name, value);
1373  }
1374  function bindAttribute(el, name, value) {
1375    if ([null, void 0, false].includes(value) && attributeShouldntBePreservedIfFalsy(name)) {
1376      el.removeAttribute(name);
1377    } else {
1378      if (isBooleanAttr(name))
1379        value = name;
1380      setIfChanged(el, name, value);
1381    }
1382  }
1383  function setIfChanged(el, attrName, value) {
1384    if (el.getAttribute(attrName) != value) {
1385      el.setAttribute(attrName, value);
1386    }
1387  }
1388  function setPropertyIfChanged(el, propName, value) {
1389    if (el[propName] !== value) {
1390      el[propName] = value;
1391    }
1392  }
1393  function updateSelect(el, value) {
1394    const arrayWrappedValue = [].concat(value).map((value2) => {
1395      return value2 + "";
1396    });
1397    Array.from(el.options).forEach((option) => {
1398      option.selected = arrayWrappedValue.includes(option.value);
1399    });
1400  }
1401  function camelCase(subject) {
1402    return subject.toLowerCase().replace(/-(\w)/g, (match, char) => char.toUpperCase());
1403  }
1404  function checkedAttrLooseCompare(valueA, valueB) {
1405    return valueA == valueB;
1406  }
1407  function safeParseBoolean(rawValue) {
1408    if ([1, "1", "true", "on", "yes", true].includes(rawValue)) {
1409      return true;
1410    }
1411    if ([0, "0", "false", "off", "no", false].includes(rawValue)) {
1412      return false;
1413    }
1414    return rawValue ? Boolean(rawValue) : null;
1415  }
1416  function isBooleanAttr(attrName) {
1417    const booleanAttributes = [
1418      "disabled",
1419      "checked",
1420      "required",
1421      "readonly",
1422      "open",
1423      "selected",
1424      "autofocus",
1425      "itemscope",
1426      "multiple",
1427      "novalidate",
1428      "allowfullscreen",
1429      "allowpaymentrequest",
1430      "formnovalidate",
1431      "autoplay",
1432      "controls",
1433      "loop",
1434      "muted",
1435      "playsinline",
1436      "default",
1437      "ismap",
1438      "reversed",
1439      "async",
1440      "defer",
1441      "nomodule"
1442    ];
1443    return booleanAttributes.includes(attrName);
1444  }
1445  function attributeShouldntBePreservedIfFalsy(name) {
1446    return !["aria-pressed", "aria-checked", "aria-expanded", "aria-selected"].includes(name);
1447  }
1448  function getBinding(el, name, fallback) {
1449    if (el._x_bindings && el._x_bindings[name] !== void 0)
1450      return el._x_bindings[name];
1451    return getAttributeBinding(el, name, fallback);
1452  }
1453  function extractProp(el, name, fallback, extract = true) {
1454    if (el._x_bindings && el._x_bindings[name] !== void 0)
1455      return el._x_bindings[name];
1456    if (el._x_inlineBindings && el._x_inlineBindings[name] !== void 0) {
1457      let binding = el._x_inlineBindings[name];
1458      binding.extract = extract;
1459      return dontAutoEvaluateFunctions(() => {
1460        return evaluate(el, binding.expression);
1461      });
1462    }
1463    return getAttributeBinding(el, name, fallback);
1464  }
1465  function getAttributeBinding(el, name, fallback) {
1466    let attr = el.getAttribute(name);
1467    if (attr === null)
1468      return typeof fallback === "function" ? fallback() : fallback;
1469    if (attr === "")
1470      return true;
1471    if (isBooleanAttr(name)) {
1472      return !![name, "true"].includes(attr);
1473    }
1474    return attr;
1475  }
1476
1477  

1482 later = function() {
1483        timeout = null;
1484        func.apply(context, args);
1485      };
1486      clearTimeout(timeout);
1487      timeout = setTimeout(later, wait);
1488    };
1489  }
1490
1491  // packages/alpinejs/src/utils/throttle.js
1492  function throttle(func, limit) {
1493    let inThrottle;
1494    return function() {
1495      let context = this, args = arguments;
1496      if (!inThrottle) {
1497        func.apply(context, args);
1498        inThrottle = true;
1499        setTimeout(() => inThrottle = false, limit);
1500      }
1501    };
1502  }
1503
1504  // packages/alpinejs/src/entangle.js
1505  function entangle({ get: outerGet, set: outerSet }, { get: innerGet, set: innerSet }) {
1506    let firstRun = true;
1507    let outerHash;
1508    let innerHash;
1509    let reference = effect(() => {
1510      let outer = outerGet();
1511      let inner = innerGet();
1512      if (firstRun) {
1513        innerSet(cloneIfObject(outer));
1514        firstRun = false;
1515      } else {
1516        let outerHashLatest = JSON.stringify(outer);
1517        let innerHashLatest = JSON.stringify(inner);
1518        if (outerHashLatest !== outerHash) {
1519          innerSet(cloneIfObject(outer));
1520        } else if (outerHashLatest !== innerHashLatest) {
1521          outerSet(cloneIfObject(inner));
1522        } else {
1523        }
1524      }
1525      outerHash = JSON.stringify(outerGet());
1526      innerHash = JSON.stringify(innerGet());
1527    });
1528    return () => {
1529      release(reference);
1530    };
1531  }
1532  function cloneIfObject(value) {
1533    return typeof value === "object" ? JSON.parse(JSON.stringify(value)) : value;
1534  }
1535
1536  // packages/alpinejs/src/plugin.js
1537  function plugin(callback) {
1538    let callbacks = Array.isArray(callback) ? callback : [callback];
1539    callbacks.forEach((i) => i(alpine_default));
1540  }
1541
1542  // packages/alpinejs/src/store.js
1543  var stores = {};
1544  var isReactive = false;
1545  function store(name, value) {
1546    if (!isReactive) {
1547      stores = reactive(stores);
1548      isReactive = true;
1549    }
1550    if (value === void 0) {
1551      return stores[name];
1552    }
1553    stores[name] = value;
1554    if (typeof value === "object" && value !== null && value.

1557
1558  }
1559  function getStores() {
1560    return stores;
1561  }
1562
1563  // packages/alpinejs/src/binds.js
1564  var binds = {};
1565  function bind2(name, bindings) {
1566    let getBindings = typeof bindings !== "function" ? () => bindings : bindings;
1567    if (name instanceof Element) {
1568      return applyBindingsObject(name, getBindings());
1569    } else {
1570      binds[name] = getBindings;
1571    }
1572    return () => {
1573    };
1574  }
1575  function injectBindingProviders(obj) {
1576    Object.entries(binds).forEach(([name, callback]) => {
1577      Object.defineProperty(obj, name, {
1578        get() {
1579          return (...args) => {
1580            return callback(...args);
1581          };
1582        }
1583      });
1584    });
1585    return obj;
1586  }
1587  function applyBindingsObject(el, obj, original) {
1588    let cleanupRunners = [];
1589    while (cleanupRunners.length)
1590      cleanupRunners.pop()();
1591    let attributes = Object.entries(obj).map(([name, value]) => ({ name, value }));
1592    let staticAttributes = attributesOnly(attributes);
1593    attributes = attributes.map((attribute) => {
1594      if (staticAttributes.find((attr) => attr.name === attribute.name)) {
1595        return {
1596          name: `x-bind:${attribute.name}`,
1597          value: `"${attribute.value}"`
1598        };
1599      }
1600      return attribute;
1601    });
1602    directives(el, attributes, original).map((handle) => {
1603      cleanupRunners.push(handle.runCleanups);
1604      handle();
1605    });
1606    return () => {
1607      while (cleanupRunners.length)
1608        cleanupRunners.pop()();
1609    };
1610  }
1611
1612  // packages/alpinejs/src/datas.js
1613  var datas = {};
1614  function data(name, callback) {
1615    datas[name] = callback;
1616  }
1617  function injectDataProviders(obj, context) {
1618    Object.entries(datas).forEach(([name, callback]) => {
1619      Object.defineProperty(obj, name, {
1620        get() {
1621          return (...args) => {
1622            return callback.bind(context)(...args);
1623          };
1624        },
1625        enumerable: false
1626      });
1627    });
1628    return obj;
1629  }
1630
1631  // packages/alpinejs/src/alpine.js
1632  var Alpine = {
1633    get reactive() {
1634      return reactive;
1635    },
1636    get release() {
1637      return release;
1638    },
1639    get effect() {
1640      return effect;
1641    },
1642    get raw() {
1643      return raw;
1644    },
1645    

1705// node_modules/@vue/shared/dist/shared.esm-bundler.js
1706  function makeMap(str, expectsLowerCase) {
1707    const map = /* @__PURE__ */ Object.create(null);
1708    const list = str.split(",");
1709    for (let i = 0; i < list.length; i++) {
1710      map[list[i]] = true;
1711    }
1712    return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];
1713  }
1714  var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
1715  var isBooleanAttr2 = /* @__PURE__ */ makeMap(specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`);
1716  var EMPTY_OBJ = true ? Object.freeze({}) : {};
1717  var EMPTY_ARR = true ? Object.freeze([]) : [];
1718  var hasOwnProperty = Object.prototype.hasOwnProperty;
1719  var hasOwn = (val, key) => hasOwnProperty.call(val, key);
1720  var isArray = Array.isArray;
1721  var isMap = (val) => toTypeString(val) === "[object Map]";
1722  var isString = (val) => typeof val === "string";
1723  var isSymbol = (val) => typeof val === "symbol";
1724  var isObject = (val) => val !== null && typeof val === "object";
1725  var objectToString = Object.prototype.toString;
1726  var toTypeString = (value) => objectToString.call(value);
1727  var toRawType = (value) => {
1728    return toTypeString(value).slice(8, -1);
1729  };
1730  var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
1731  var cacheStringFunction = (fn) => {
1732    const cache = /* @__PURE__ */ Object.create(null);
1733    return (str) => {
1734      const hit = cache[str];
1735      return hit || (cache[str] = fn(str));
1736    };
1737  };
1738  var camelizeRE = /-(\w)/g;
1739  var camelize = cacheStringFunction((str) => {
1740    return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
1741  });
1742  var hyphenateRE = /\B([A-Z])/g;
1743  var hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
1744  var capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
1745  var toHandlerKey = cacheStringFunction((str) => str ? `on${capitalize(str)}` : ``);
1746  var hasChanged = (value, oldValue) => value !== oldValue && (value === value || oldValue === oldValue);
1747
1748  

1748// node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
1749  var targetMap = /* @__PURE__ */ new WeakMap();
1750  var effectStack = [];
1751  var activeEffect;
1752  var ITERATE_KEY = Symbol(true ? "iterate" : "");
1753  var MAP_KEY_ITERATE_KEY = Symbol(true ? "Map key iterate" : "");
1754  function isEffect(fn) {
1755    return fn && fn._isEffect === true;
1756  }
1757  function effect2(fn, options = EMPTY_OBJ) {
1758    if (isEffect(fn)) {
1759      fn = fn.raw;
1760    }
1761    const effect3 = createReactiveEffect(fn, options);
1762    if (!options.lazy) {
1763      effect3();
1764    }
1765    return effect3;
1766  }
1767  function stop(effect3) {
1768    if (effect3.active) {
1769      cleanup(effect3);
1770      if (effect3.options.onStop) {
1771        effect3.options.onStop();
1772      }
1773      effect3.active = false;
1774    }
1775  }
1776  var uid = 0;
1777  function createReactiveEffect(fn, options) {
1778    const effect3 = function reactiveEffect() {
1779      if (!effect3.active) {
1780        return fn();
1781      }
1782      if (!effectStack.includes(effect3)) {
1783        cleanup(effect3);
1784        try {
1785          enableTracking();
1786          effectStack.push(effect3);
1787          activeEffect = effect3;
1788          return fn();
1789        } finally {
1790          effectStack.pop();
1791          resetTracking();
1792          activeEffect = effectStack[effectStack.length - 1];
1793        }
1794      }
1795    };
1796    effect3.id = uid++;
1797    effect3.allowRecurse = !!options.allowRecurse;
1798    effect3._isEffect = true;
1799    effect3.active = true;
1800    effect3.raw = fn;
1801    effect3.deps = [];
1802    effect3.options = options;
1803    return effect3;
1804  }
1805  function cleanup(effect3) {
1806    const { deps } = effect3;
1807    if (deps.length) {
1808      for (let i = 0; i < deps.length; i++) {
1809        deps[i].delete(effect3);
1810      }
1811      deps.length = 0;
1812    }
1813  }
1814  var shouldTrack = true;
1815  var trackStack = [];
1816  function pauseTracking() {
1817    trackStack.push(shouldTrack);
1818    shouldTrack = false;
1819  }
1820  function enableTracking() {
1821    trackStack.push(shouldTrack);
1822    shouldTrack = true;
1823  }
1824  function resetTracking() {
1825    const last = trackStack.pop();
1826    shouldTrack = last === void 0 ? true : last;
1827  }
1828  function track(target, type, key) {
1829    if (!shouldTrack || activeEffect === void 0) {
1830      return;
1831    }
1832    let depsMap = targetMap.get(target);
1833    if (!depsMap) {
1834      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
1835    }
1836    let dep = depsMap.get(key);
1837    if (!dep) {
1838      depsMap.set(key, dep = /* @__PURE__ */ new Set());
1839    }
1840    if (!dep.has(activeEffect)) {
1841      dep.add(activeEffect);
1842      activeEffect.deps.push(dep);
1843      if (activeEffect.options.onTrack) {
1844        activeEffect.options.onTrack({
1845          effect: activeEffect,
1846          target,
1847          type,
1848          key
1849        });
1850      }
1851    }
1852  }
1853  function trigger(target, type, key, newValue, oldValue, oldTarget) {
1854    const depsMap = targetMap.get(target);
1855    if (!depsMap) {
1856      return;
1857    }
1858    const effects = /* @__PURE__ */ new Set();
1859    const add2 = (effectsToAdd) => {
1860      if (effectsToAdd) {
1861        effectsToAdd.forEach((effect3) => {
1862          if (effect3 !== activeEffect || effect3.allowRecurse) {
1863            effects.add(effect3);
1864          }
1865        });
1866      }
1867    };
1868    if (type === "clear") {
1869      depsMap.forEach(add2);
1870    } else if (key === "length" && isArray(target)) {
1871      depsMap.forEach((dep, key2) => {
1872        if (key2 === "length" || key2 >= newValue) {
1873          add2(dep);
1874        }
1875      });
1876    } else {
1877      if (key !== void 0) {
1878        add2(depsMap.get(key));
1879      }
1880      switch (type) {
1881        case "add":
1882          if (!isArray(target)) {
1883            add2(depsMap.get(ITERATE_KEY));
1884            if (isMap(target)) {
1885              add2(depsMap.get(MAP_KEY_ITERATE_KEY));
1886            }
1887          } else if (isIntegerKey(key)) {
1888            add2(depsMap.get("length"));
1889          }
1890          break;
1891        case "delete":
1892          if (!isArray(target)) {
1893            add2(depsMap.get(ITERATE_KEY));
1894            if (isMap(target)) {
1895              add2(depsMap.get(MAP_KEY_ITERATE_KEY));
1896            }
1897          }
1898          break;
1899        case "set":
1900          if (isMap(target)) {
1901            add2(depsMap.get(ITERATE_KEY));
1902          }
1903          break;
1904      }
1905    }
1906    const run = (effect3) => {
1907      if (effect3.options.onTrigger) {
1908        effect3.options.onTrigger({
1909          effect: effect3,
1910          target,
1911          key,
1912          type,
1913          newValue,
1914          oldValue,
1915          oldTarget
1916        });
1917      }
1918      if (effect3.options.scheduler) {
1919        effect3.options.scheduler(effect3);
1920      } else {
1921        effect3();
1922      }
1923    };
1924    effects.forEach(run);
1925  }
1926  var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
1927  var builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map((key) => Symbol[key]).filter(isSymbol));
1928  var get2 = /* @__PURE__ */ createGetter();
1929  var readonlyGet = /* @__PURE__ */ createGetter(true);
1930  var arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
1931  function createArrayInstrumentations() {
1932    const instrumentations = {};
1933    ["includes", "indexOf", "lastIndexOf"].forEach((key) => {
1934      instrumentations[key] = function(...args) {
1935        const arr = toRaw(this);
1936        for (let i = 0, l = this.length; i < l; i++) {
1937          track(arr, "get", i + "");
1938        }
1939        const res = arr[key](...args);
1940        if (res === -1 || res === false) {
1941          return arr[key](...args.map(toRaw));
1942        } else {
1943          return res;
1944        }
1945      };
1946    });
1947    ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
1948      instrumentations[key] = function(...args) {
1949        pauseTracking();
1950        const res = toRaw(this)[key].apply(this, args);
1951        resetTracking();
1952        return res;
1953      };
1954    });
1955    return instrumentations;
1956  }
1957  function createGetter(isReadonly = false, shallow = false) {
1958    return function get3(target, key, receiver) {
1959      if (key === "__v_isReactive") {
1960        return !isReadonly;
1961      } else if (key === "__v_isReadonly") {
1962        return isReadonly;
1963      } else if (key === "__v_raw" && receiver === (isReadonly ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
1964        return target;
1965      }
1966      const targetIsArray = isArray(target);
1967      if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
1968        return Reflect.get(arrayInstrumentations, key, receiver);
1969      }
1970      const res = Reflect.get(target, key, receiver);
1971      if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
1972        return res;
1973      }
1974      if (!isReadonly) {
1975        track(target, "get", key);
1976      }
1977      if (shallow) {
1978        return res;
1979      }
1980      if (isRef(res)) {
1981        const shouldUnwrap = !targetIsArray || !isIntegerKey(key);
1982        return shouldUnwrap ? res.value : res;
1983      }
1984      if (isObject(res)) {
1985        return isReadonly ? readonly(res) : reactive2(res);
1986      }
1987      return res;
1988    };
1989  }
1990  var set2 = /* @__PURE__ */ createSetter();
1991  function createSetter(shallow = false) {
1992    return function set3(target, key, value, receiver) {
1993      let oldValue = target[key];
1994      if (!shallow) {
1995        value = toRaw(value);
1996        oldValue = toRaw(oldValue);
1997        if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
1998          oldValue.value = value;
1999          return true;
2000        }
2001      }
2002      const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
2003      const result = Reflect.set(target, key, value, receiver);
2004      if (target === toRaw(receiver)) {
2005        if (!hadKey) {
2006          trigger(target, "add", key, value);
2007        } else if (hasChanged(value, oldValue)) {
2008          trigger(target, "set", key, value, oldValue);
2009        }
2010      }
2011      return result;
2012    };
2013  }
2014  function deleteProperty(target, key) {
2015    const hadKey = hasOwn(target, key);
2016    const oldValue = target[key];
2017    const result = Reflect.deleteProperty(target, key);
2018    if (result && hadKey) {
2019      trigger(target, "delete", key, void 0, oldValue);
2020    }
2021    return result;
2022  }
2023  function has(target, key) {
2024    const result = Reflect.has(target, key);
2025    if (!isSymbol(key) || !builtInSymbols.has(key)) {
2026      track(target, "has", key);
2027    }
2028    return result;
2029  }
2030  function ownKeys(target) {
2031    track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
2032    return Reflect.ownKeys(target);
2033  }
2034  var mutableHandlers = {
2035    get: get2,
2036    set: set2,
2037    deleteProperty,
2038    has,
2039    ownKeys
2040  };
2041  var readonlyHandlers = {
2042    get: readonlyGet,
2043    set(target, key) {
2044      if (true) {
2045        console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
2046      }
2047      return true;
2048    },
2049    deleteProperty(target, key) {
2050      if (true) {
2051        console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
2052      }
2053      return true;
2054    }
2055  };
2056  var toReactive = (value) => isObject(value) ? reactive2(value) : value;
2057  var toReadonly = (value) => isObject(value) ? readonly(value) : value;
2058  var toShallow = (value) => value;
2059  var getProto = (v) => Reflect.getPrototypeOf(v);
2060  function get$1(target, key, isReadonly = false, isShallow = false) {
2061    target = target[
2062      "__v_raw"
2063      /* RAW */
2064    ];
2065    const rawTarget = toRaw(target);
2066    const rawKey = toRaw(key);
2067    if (key !== rawKey) {
2068      !isReadonly && track(rawTarget, "get", key);
2069    }
2070    !isReadonly && track(rawTarget, "get", rawKey);
2071    const { has: has2 } = getProto(rawTarget);
2072    const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
2073    if (has2.call(rawTarget, key)) {
2074      return wrap(target.get(key));
2075    } else if (has2.call(rawTarget, rawKey)) {
2076      return wrap(target.get(rawKey));
2077    } else if (target !== rawTarget) {
2078      target.get(key);
2079    }
2080  }
2081  function has$1(key, isReadonly = false) {
2082    const target = this[
2083      "__v_raw"
2084      /* RAW */
2085    ];
2086    const rawTarget = toRaw(target);
2087    const rawKey = toRaw(key);
2088    if (key !== rawKey) {
2089      !isReadonly && track(rawTarget, "has", key);
2090    }
2091    !isReadonly && track(rawTarget, "has", rawKey);
2092    return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
2093  }
2094  function size(target, isReadonly = false) {
2095    target = target[
2096      "__v_raw"
2097      /* RAW */
2098    ];
2099    !isReadonly && track(toRaw(target), "iterate", ITERATE_KEY);
2100    return Reflect.get(target, "size", target);
2101  }
2102  function add(value) {
2103    value = toRaw(value);
2104    const target = toRaw(this);
2105    const proto = getProto(target);
2106    const hadKey = proto.has.call(target, value);
2107    if (!hadKey) {
2108      target.add(value);
2109      trigger(target, "add", value, value);
2110    }
2111    return this;
2112  }
2113  function set$1(key, value) {
2114    value = toRaw(value);
2115    const target = toRaw(this);
2116    const { has: has2, get: get3 } = getProto(target);
2117    let hadKey = has2.call(target, key);
2118    if (!hadKey) {
2119      key = toRaw(key);
2120      hadKey = has2.call(target, key);
2121    } else if (true) {
2122      checkIdentityKeys(target, has2, key);
2123    }
2124    const oldValue = get3.call(target, key);
2125    target.set(key, value);
2126    if (!hadKey) {
2127      trigger(target, "add", key, value);
2128    } else if (hasChanged(value, oldValue)) {
2129      trigger(target, "set", key, value, oldValue);
2130    }
2131    return this;
2132  }
2133  function deleteEntry(key) {
2134    const target = toRaw(this);
2135    const { has: has2, get: get3 } = getProto(target);
2136    let hadKey = has2.call(target, key);
2137    if (!hadKey) {
2138      key = toRaw(key);
2139      hadKey = has2.call(target, key);
2140    } else if (true) {
2141      checkIdentityKeys(target, has2, key);
2142    }
2143    const oldValue = get3 ? get3.call(target, key) : void 0;
2144    const result = target.delete(key);
2145    if (hadKey) {
2146      trigger(target, "delete", key, void 0, oldValue);
2147    }
2148    return result;
2149  }
2150  function clear() {
2151    const target = toRaw(this);
2152    const hadItems = target.size !== 0;
2153    const oldTarget = true ? isMap(target) ? new Map(target) : new Set(target) : void 0;
2154    const result = target.clear();
2155    if (hadItems) {
2156      trigger(target, "clear", void 0, void 0, oldTarget);
2157    }
2158    return result;
2159  }
2160  function createForEach(isReadonly, isShallow) {
2161    return function forEach(callback, thisArg) {
2162      const observed = this;
2163      const target = observed[
2164        "__v_raw"
2165        /* RAW */
2166      ];
2167      const rawTarget = toRaw(target);
2168      const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
2169      !isReadonly && track(rawTarget, "iterate", ITERATE_KEY);
2170      return target.forEach((value, key) => {
2171        return callback.call(thisArg, wrap(value), wrap(key), observed);
2172      });
2173    };
2174  }
2175  function createIterableMethod(method, isReadonly, isShallow) {
2176    return function(...args) {
2177      const target = this[
2178        "__v_raw"
2179        /* RAW */
2180      ];
2181      const rawTarget = toRaw(target);
2182      const targetIsMap = isMap(rawTarget);
2183      const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
2184      const isKeyOnly = method === "keys" && targetIsMap;
2185      const innerIterator = target[method](...args);
2186      const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
2187      !isReadonly && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
2188      return {
2189        // iterator protocol
2190        next() {
2191          const { value, done } = innerIterator.next();
2192          return done ? { value, done } : {
2193            value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
2194            done
2195          };
2196        },
2197        // iterable protocol
2198        [Symbol.iterator]() {
2199          return this;
2200        }
2201      };
2202    };
2203  }
2204  function createReadonlyMethod(type) {
2205    return function(...args) {
2206      if (true) {
2207        const key = args[0] ? `on key "${args[0]}" ` : ``;
2208        console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
2209      }
2210      return type === "delete" ? false : this;
2211    };
2212  }
2213  function createInstrumentations() {
2214    const mutableInstrumentations2 = {
2215      get(key) {
2216        return get$1(this, key);
2217      },
2218      get size() {
2219        return size(this);
2220      },
2221      has: has$1,
2222      add,
2223      set: set$1,
2224      delete: deleteEntry,
2225      clear,
2226      forEach: createForEach(false, false)
2227    };
2228    const shallowInstrumentations2 = {
2229      get(key) {
2230        return get$1(this, key, false, true);
2231      },
2232      get size() {
2233        return size(this);
2234      },
2235      has: has$1,
2236      add,
2237      set: set$1,
2238      delete: deleteEntry,
2239      clear,
2240      forEach: createForEach(false, true)
2241    };
2242    const readonlyInstrumentations2 = {
2243      get(key) {
2244        return get$1(this, key, true);
2245      },
2246      get size() {
2247        return size(this, true);
2248      },
2249      has(key) {
2250        return has$1.call(this, key, true);
2251      },
2252      add: createReadonlyMethod(
2253        "add"
2254        /* ADD */
2255      ),
2256      set: createReadonlyMethod(
2257        "set"
2258        /* SET */
2259      ),
2260      delete: createReadonlyMethod(
2261        "delete"
2262        /* DELETE */
2263      ),
2264      clear: createReadonlyMethod(
2265        "clear"
2266        /* CLEAR */
2267      ),
2268      forEach: createForEach(true, false)
2269    };
2270    const shallowReadonlyInstrumentations2 = {
2271      get(key) {
2272        return get$1(this, key, true, true);
2273      },
2274      get size() {
2275        return size(this, true);
2276      },
2277      has(key) {
2278        return has$1.call(this, key, true);
2279      },
2280      add: createReadonlyMethod(
2281        "add"
2282        /* ADD */
2283      ),
2284      set: createReadonlyMethod(
2285        "set"
2286        /* SET */
2287      ),
2288      delete: createReadonlyMethod(
2289        "delete"
2290        /* DELETE */
2291      ),
2292      clear: createReadonlyMethod(
2293        "clear"
2294        /* CLEAR */
2295      ),
2296      forEach: createForEach(true, true)
2297    };
2298    const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
2299    iteratorMethods.forEach((method) => {
2300      mutableInstrumentations2[method] = createIterableMethod(method, false, false);
2301      readonlyInstrumentations2[method] = createIterableMethod(method, true, false);
2302      shallowInstrumentations2[method] = createIterableMethod(method, false, true);
2303      shallowReadonlyInstrumentations2[method] = createIterableMethod(method, true, true);
2304    });
2305    return [
2306      mutableInstrumentations2,
2307      readonlyInstrumentations2,
2308      shallowInstrumentations2,
2309      shallowReadonlyInstrumentations2
2310    ];
2311  }
2312  var [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* @__PURE__ */ createInstrumentations();
2313  function createInstrumentationGetter(isReadonly, shallow) {
2314    const instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations;
2315    return (target, key, receiver) => {
2316      if (key === "__v_isReactive") {
2317        return !isReadonly;
2318      } else if (key === "__v_isReadonly") {
2319        return isReadonly;
2320      } else if (key === "__v_raw") {
2321        return target;
2322      }
2323      return Reflect.get(hasOwn(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
2324    };
2325  }
2326  var mutableCollectionHandlers = {
2327    get: /* @__PURE__ */ createInstrumentationGetter(false, false)
2328  };
2329  var readonlyCollectionHandlers = {
2330    get: /* @__PURE__ */ createInstrumentationGetter(true, false)
2331  };
2332  function checkIdentityKeys(target, has2, key) {
2333    const rawKey = toRaw(key);
2334    if (rawKey !== key && has2.call(target, rawKey)) {
2335      const type = toRawType(target);
2336      console.warn(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`);
2337    }
2338  }
2339  var reactiveMap = /* @__PURE__ */ new WeakMap();
2340  var shallowReactiveMap = /* @__PURE__ */ new WeakMap();
2341  var readonlyMap = /* @__PURE__ */ new WeakMap();
2342  var shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
2343  function targetTypeMap(rawType) {
2344    switch (rawType) {
2345      case "Object":
2346      case "Array":
2347        return 1;
2348      case "Map":
2349      case "Set":
2350      case "WeakMap":
2351      case "WeakSet":
2352        return 2;
2353      default:
2354        return 0;
2355    }
2356  }
2357  function getTargetType(value) {
2358    return value[
2359      "__v_skip"
2360      /* SKIP */
2361    ] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
2362  }
2363  function reactive2(target) {
2364    if (target && target[
2365      "__v_isReadonly"
2366      /* IS_READONLY */
2367    ]) {
2368      return target;
2369    }
2370    return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
2371  }
2372  function readonly(target) {
2373    return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
2374  }
2375  function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
2376    if (!isObject(target)) {
2377      if (true) {
2378        console.warn(`value cannot be made reactive: ${String(target)}`);
2379      }
2380      return target;
2381    }
2382    if (target[
2383      "__v_raw"
2384      /* RAW */
2385    ] && !(isReadonly && target[
2386      "__v_isReactive"
2387      /* IS_REACTIVE */
2388    ])) {
2389      return target;
2390    }
2391    const existingProxy = proxyMap.get(target);
2392    if (existingProxy) {
2393      return existingProxy;
2394    }
2395    const targetType = getTargetType(target);
2396    if (targetType === 0) {
2397      return target;
2398    }
2399    const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
2400    proxyMap.set(target, proxy);
2401    return proxy;
2402  }
2403  function toRaw(observed) {
2404    return observed && toRaw(observed[
2405      "__v_raw"
2406      /* RAW */
2407    ]) || observed;
2408  }
2409  function isRef(r) {
2410    return Boolean(r && r.__v_isRef === true);
2411  }
2412
2413  // packages/alpinejs/src/magics/$nextTick.js
2414  magic("nextTick", () => nextTick);
2415
2416  // packages/alpinejs/src/magics/$dispatch.js
2417  magic("dispatch", (el) => dispatch.bind(dispatch, el));
2418
2419  // packages/alpinejs/src/magics/$watch.js
2420  magic("watch", (el, { evaluateLater: evaluateLater2, cleanup: cleanup2 }) => (key, callback) => {
2421    let evaluate2 = evaluateLater2(key);
2422    let getter = () => {
2423      let value;
2424      evaluate2((i) => value = i);
2425      return value;
2426    };
2427    let unwatch = watch(getter, callback);
2428    cleanup2(unwatch);
2429  });
2430
2431  // packages/alpinejs/src/magics/$store.js
2432  magic("store", getStores);
2433
2434  // packages/alpinejs/src/magics/$data.js
2435  magic("data", (el) => scope(el));
2436
2437  // packages/alpinejs/src/magics/$root.js
2438  magic("root", (el) => closestRoot(el));
2439
2440  // packages/alpinejs/src/magics/$refs.js
2441  magic("refs", (el) => {
2442    if (el._x_refs_proxy)
2443      return el._x_refs_proxy;
2444    el._x_refs_proxy = mergeProxies(getArrayOfRefObject(el));
2445    return el._x_refs_proxy;
2446  });
2447  function getArrayOfRefObject(el) {
2448    let refObjects = [];
2449    findClosest(el, (i) => {
2450      if (i._x_refs)
2451        refObjects.push(i._x_refs);
2452    });
2453    return refObjects;
2454  }
2455
2456  

2456// packages/alpinejs/src/ids.js
2457  var globalIdMemo = {};
2458  function findAndIncrementId(name) {
2459    if (!globalIdMemo[name])
2460      globalIdMemo[name] = 0;
2461    return ++globalIdMemo[name];
2462  }
2463  function closestIdRoot(el, name) {
2464    return findClosest(el, (element) => {
2465      if (element._x_ids && element._x_ids[name])
2466        return true;
2467    });
2468  }
2469  function setIdRoot(el, name) {
2470    if (!el._x_ids)
2471      el._x_ids = {};
2472    if (!el._x_ids[name])
2473      el._x_ids[name] = findAndIncrementId(name);
2474  }
2475
2476  // packages/alpinejs/src/magics/$id.js
2477  magic("id", (el, { cleanup: cleanup2 }) => (name, key = null) => {
2478    let cacheKey = `${name}${key ? `-${key}` : ""}`;
2479    return cacheIdByNameOnElement(el, cacheKey, cleanup2, () => {
2480      let root = closestIdRoot(el, name);
2481      let id = root ? root._x_ids[name] : findAndIncrementId(name);
2482      return key ? `${name}-${id}-${key}` : `${name}-${id}`;
2483    });
2484  });
2485  interceptClone((from, to) => {
2486    if (from._x_id) {
2487      to._x_id = from._x_id;
2488    }
2489  });
2490  function cacheIdByNameOnElement(el, cacheKey, cleanup2, callback) {
2491    if (!el._x_id)
2492      el._x_id = {};
2493    if (el._x_id[cacheKey])
2494      return el._x_id[cacheKey];
2495    let output = callback();
2496    el._x_id[cacheKey] = output;
2497    cleanup2

2497(() => {
2498      delete el._x_id[cacheKey];
2499    });
2500    return output;
2501  }
2502
2503  // packages/alpinejs/src/magics/$el.js
2504  magic("el", (el) => el);
2505
2506  // packages/alpinejs/src/magics/index.js
2507  warnMissingPluginMagic("Focus", "focus", "focus");
2508  warnMissingPluginMagic("Persist", "persist", "persist");
2509  function warnMissingPluginMagic(name, magicName, slug) {
2510    magic(magicName, (el) => warn(`You can't use [$${magicName}] without first installing the "${name}" plugin here: https://alpinejs.dev/plugins/${slug}`, el));
2511  }
2512
2513  // packages/alpinejs/src/directives/x-modelable.js
2514  directive("modelable", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2, cleanup

2514: cleanup2 }) => {
2515    let func = evaluateLater2(expression);
2516    let innerGet = () => {
2517      let result;
2518      func((i) => result = i);
2519      return result;
2520    };
2521    let evaluateInnerSet = evaluateLater2(`${expression} = __placeholder`);
2522    let innerSet = (val) => evaluateInnerSet(() => {
2523    }, { scope: { "__placeholder": val } });
2524    let initialValue = innerGet();
2525    innerSet(initialValue);
2526    queueMicrotask(() => {
2527      if (!el._x_model)
2528        return;
2529      el._x_removeModelListeners["default"]();
2530      let outerGet = el._x_model.get;
2531      let outerSet = el._x_model.set;
2532      let releaseEntanglement = entangle(
2533        {
2534          get() {
2535            return outerGet();
2536          },
2537          set(value) {
2538            outerSet(value);
2539          }
2540        },
2541        {
2542          get() {
2543            return innerGet();
2544          },
2545          set(value) {
2546            innerSet(value);
2547          }
2548        }
2549      );
2550      cleanup2(releaseEntanglement);
2551    });
2552  });
2553
2554  // packages/alpinejs/src/directives/x-teleport.js
2555  directive("teleport", (el, { modifiers, expression }, { cleanup: cleanup2 }) => {
2556    if (el.tagName.toLowerCase() !== "template")
2557      warn("x-teleport can only be used on a <template> tag", el);
2558    let target = getTarget(expression);
2559    let clone2 = el.content.cloneNode(true).firstElementChild;
2560    el._x_teleport = clone2;
2561    clone2._x_teleportBack = el;
2562    el.setAttribute("data-teleport-template", true);
2563    clone2.setAttribute("data-teleport-target", true);
2564    if (el._x_forwardEvents) {
2565      el._x_forwardEvents.forEach((eventName) => {
2566        clone2.addEventListener(eventName, (e) => {
2567          e.stopPropagation();
2568          el.dispatchEvent(new e.constructor(e.type, e));
2569        });
2570      });
2571    }
2572    addScopeToNode(clone2, {}, el);
2573    let placeInDom = (clone3, target2, modifiers2) => {
2574      if (modifiers2.includes("prepend")) {
2575        target2.parentNode.insertBefore(clone3, target2);
2576      } else if (modifiers2.includes("append")) {
2577        target2.parentNode.insertBefore(clone3, target2.nextSibling);
2578      } else {
2579        target2.appendChild(clone3);
2580      }
2581    };
2582    mutateDom(() => {
2583      placeInDom(clone2, target, modifiers);
2584      skipDuringClone(() => {
2585        initTree(clone2);
2586        clone2._x_ignore = true;
2587      })();
2588    });
2589    el._x_teleportPutBack = () => {
2590      let target2 = getTarget(expression);
2591      mutateDom(() => {
2592        placeInDom(el._x_teleport, target2, modifiers);
2593      });
2594    };
2595    cleanup2(() => clone2.remove());
2596  });
2597  var teleportContainerDuringClone = document.createElement("div");
2598  function getTarget(expression) {
2599    let target = skipDuringClone(() => {
2600      return document.querySelector(expression);
2601    }, () => {
2602      return teleportContainerDuringClone;
2603    })();
2604    if (!target)
2605      warn(`Cannot find x-teleport element for selector: "${expression}"`);
2606    return target;
2607  }
2608
2609  

2614(() => {
2615      modifiers.includes("self") ? delete el._x_ignoreSelf : delete el._x_ignore;
2616    });
2617  };
2618  directive("ignore", handler);
2619
2620  // packages/alpinejs/src/directives/x-effect.js
2621  directive("effect", skipDuringClone((el, { expression }, { effect: effect3 }) => {
2622    effect3(evaluateLater(el, expression));
2623  }));
2624
2625  // packages/alpinejs/src/utils/on.js
2626  function on(el, event, modifiers, callback) {
2627    let listenerTarget = el;
2628    let handler4 = (e) => callback(e);
2629    let options = {};
2630    let wrapHandler = (callback2, wrapper) => (e) => wrapper(callback2, e);
2631    if (modifiers.includes("dot"))
2632      event = dotSyntax(event);
2633    if (modifiers.includes("camel"))
2634      event = camelCase2(event);
2635    if (modifiers.includes("