https://www.rkh-gesundheit.de/typo3conf/ext/ec_rkh_template/Resources/Public/ReDesign/Scripts/JS/storybook.js

610    let result = value.apply(scope2, params);
611    if (result instanceof Promise) {
612      result.then((i3) => runIfTypeOfFunction(receiver, i3, scope2, params)).catch((error2) => handleError(error2, el, value));
613    } else {
614      receiver(result);
615    }
616  } else if (typeof value === "object" && value instanceof Promise) {
617    value.then((i3) => receiver(i3));
618  } else {
619    receiver(value);
620  }
621}
622var prefixAsString = "x-";
623function prefix(subject = "") {
624  return prefixAsString + subject;
625}
626function setPrefix(newPrefix) {
627  prefixAsString = newPrefix;
628}
629var directiveHandlers = {};
630function directive(name, callback) {
631  directiveHandlers[name] = callback;
632  return {
633    before(directive2) {
634      if (!directiveHandlers[directive2]) {
635        console.warn(
636          "Cannot find directive `${directive}`. `${name}` will use the default order of execution"
637        );
638        return;
639      }
640      const pos = directiveOrder.indexOf(directive2);
641      directiveOrder.splice(pos >= 0 ? pos : directiveOrder.indexOf("DEFAULT"), 0, name);
642    }
643  };
644}
645function directives(el, attributes, originalAttributeOverride) {
646  attributes = Array.from(attributes);
647  if (el._x_virtualDirectives) {
648    let vAttributes = Object.entries(el._x_virtualDirectives).map(([name, value]) => ({ name, value }));
649    let staticAttributes = attributesOnly(vAttributes);
650    vAttributes = vAttributes.map((attribute) => {
651      if (staticAttributes.find((attr) => attr.name === attribute.name)) {
652        return {
653          name: `x-bind:${attribute.name}`,
654          value: `"${attribute.value}"`
655        };
656      }
657      return attribute;
658    });
659    attributes = attributes.concat(vAttributes);
660  }
661  let transformedAttributeMap = {};
662  let directives2 = attributes.map(toTransformedAttributes((newName, oldName) => transformedAttributeMap[newName] = oldName)).filter(outNonAlpineAttributes).map(toParsedDirectives(transformedAttributeMap, originalAttributeOverride)).sort(byPriority);
663  return directives2.map((directive2) => {
664    return getDirectiveHandler(el, directive2);
665  });
666}
667function attributesOnly(attributes) {
668  return Array.from(attributes).map(toTransformedAttributes()).filter((attr) => !outNonAlpineAttributes(attr));
669}
670var isDeferringHandlers = false;
671var directiveHandlerStacks = /* @__PURE__ */ new Map();
672var currentHandlerStackKey = Symbol();
673function deferHandlingDirectives(callback) {
674  isDeferringHandlers = true;
675  let key = Symbol();
676  currentHandlerStackKey = key;
677  directiveHandlerStacks.set(key, []);
678  let flushHandlers = () => {
679    while (directiveHandlerStacks.get(key).length)
680      directiveHandlerStacks.get(key).shift()();
681    directiveHandlerStacks.delete(key);
682  };
683  let stopDeferring = () => {
684    isDeferringHandlers = false;
685    flushHandlers();
686  };
687  callback(flushHandlers);
688  stopDeferring();
689}
690function getElementBoundUtilities(el) {
691  let cleanups = [];
692  let cleanup2 = (callback) => cleanups.push(callback);
693  let [effect3, cleanupEffect] = elementBoundEffect(el);
694  cleanups.push(cleanupEffect);
695  let utilities = {
696    Alpine: alpine_default,
697    effect: effect3,
698    cleanup: cleanup2,
699    evaluateLater: evaluateLater.bind(evaluateLater, el),
700    evaluate: evaluate.bind(evaluate, el)
701  };
702  let doCleanup = () => cleanups.forEach((i3) => i3());
703  return [utilities, doCleanup];
704}
705function getDirectiveHandler(el, directive2) {
706  let noop = () => {
707  };
708  let handler4 = directiveHandlers[directive2.type] || noop;
709  let [utilities, cleanup2] = getElementBoundUtilities(el);
710  onAttributeRemoved(el, directive2.original, cleanup2);
711  let fullHandler = () => {
712    if (el._x_ignore || el._x_ignoreSelf)
713      return;
714    handler4.inline && handler4.inline(el, directive2, utilities);
715    handler4 = handler4.bind(handler4, el, directive2, utilities);
716    isDeferringHandlers ? directiveHandlerStacks.get(currentHandlerStackKey).push(handler4) : handler4();
717  };
718  fullHandler.runCleanups = cleanup2;
719  return fullHandler;
720}
721var startingWith = (subject, replacement) => ({ name, value }) => {
722  if (name.startsWith(subject))
723    name = name.replace(subject, replacement);
724  return { name, value };
725};
726var into = (i3) => i3;
727function toTransformedAttributes(callback = () => {
728}) {
729  return ({ name, value }) => {
730    let { name: newName, value: newValue } = attributeTransformers.reduce((carry, transform) => {
731      return transform(carry);
732    }, { name, value });
733    if (newName !== name)
734      callback(newName, name);
735    return { name: newName, value: newValue };
736  };
737}
738var attributeTransformers = [];
739function mapAttributes(callback) {
740  attributeTransformers.push(callback);
741}
742function outNonAlpineAttributes({ name }) {
743  return alpineAttributeRegex().test(name);
744}
745var alpineAttributeRegex = () => new RegExp(`^${prefixAsString}([^:^.]+)\\b`);
746function toParsedDirectives(transformedAttributeMap, originalAttributeOverride) {
747  return ({ name, value }) => {
748    let typeMatch = name.match(alpineAttributeRegex());
749    let valueMatch = name.match(/:([a-zA-Z0-9\-_:]+)/);
750    let modifiers = name.match(/\.[^.\]]+(?=[^\]]*$)/g) || [];
751    let original = originalAttributeOverride || transformedAttributeMap[name] || name;
752    return {
753      type: typeMatch ? typeMatch[1] : null,
754      value: valueMatch ? valueMatch[1] : null,
755      modifiers: modifiers.map((i3) => i3.replace(".", "")),
756      expression: value,
757      original
758    };
759  };
760}
761var DEFAULT = "DEFAULT";
762var directiveOrder = [
763  "ignore",
764  "ref",
765  "data",
766  "id",
767  "anchor",
768  "bind",
769  "init",
770  "for",
771  "model",
772  "modelable",
773  "transition",
774  "show",
775  "if",
776  DEFAULT,
777  "teleport"
778];
779function byPriority(a, b) {
780  let typeA = directiveOrder.indexOf(a.type) === -1 ? DEFAULT : a.type;
781  let typeB = directiveOrder.indexOf(b.type) === -1 ? DEFAULT : b.type;
782  return directiveOrder.indexOf(typeA) - directiveOrder.indexOf(typeB);
783}
784var tickStack = [];
785var isHolding = false;
786function nextTick(callback = () => {
787}) {
788  queueMicrotask(() => {
789    isHolding || setTimeout(() => {
790      releaseNextTicks();
791    });
792  });
793  return new Promise((res) => {
794    tickStack.push(() => {
795      callback();
796      res();
797    });
798  });
799}
800function releaseNextTicks() {
801  isHolding = false;
802  while (tickStack.length)
803    tickStack.shift()();
804}
805function holdNextTicks() {
806  isHolding = true;
807}
808function setClasses(el, value) {
809  if (Array.isArray(value)) {
810    return setClassesFromString(el, value.join(" "));
811  } else if (typeof value === "object" && value !== null) {
812    return setClassesFromObject(el, value);
813  } else if (typeof value === "function") {
814    return setClasses(el, value());
815  }
816  return setClassesFromString(el, value);
817}
818function setClassesFromString(el, classString) {
819  let missingClasses = (classString2) => classString2.split(" ").filter((i3) => !el.classList.contains(i3)).filter(Boolean);
820  let addClassesAndReturnUndo = (classes) => {
821    el.classList.add(...classes);
822    return () => {
823      el.classList.remove(...classes);
824    };
825  };
826  classString = classString === true ? classString = "" : classString || "";
827  return addClassesAndReturnUndo(missingClasses(classString));
828}
829function setClassesFromObject(el, classObject) {
830  let split = (classString) => classString.split(" ").filter(Boolean);
831  let forAdd = Object.entries(classObject).flatMap(([classString, bool]) => bool ? split(classString) : false).filter(Boolean);
832  let forRemove = Object.entries(classObject).flatMap(([classString, bool]) => !bool ? split(classString) : false).filter(Boolean);
833  let added = [];
834  let removed = [];
835  forRemove.forEach((i3) => {
836    if (el.classList.contains(i3)) {
837      el.classList.remove(i3);
838      removed.push(i3);
839    }
840  });
841  forAdd.forEach((i3) => {
842    if (!el.classList.contains(i3)) {
843      el.classList.add(i3);
844      added.push(i3);
845    }
846  });
847  return () => {
848    removed.forEach((i3) => el.classList.add(i3));
849    added.forEach((i3) => el.classList.remove(i3));
850  };
851}
852function setStyles(el, value) {
853  if (typeof value === "object" && value !== null) {
854    return setStylesFromObject(el, value);
855  }
856  return setStylesFromString(el, value);
857}
858function setStylesFromObject(el, value) {
859  let previousStyles = {};
860  Object.entries(value).forEach(([key, value2]) => {
861    previousStyles[key] = el.style[key];
862    if (!key.startsWith("--")) {
863      key = kebabCase(key);
864    }
865    el.style.setProperty(key, value2);
866  });
867  setTimeout(() => {
868    if (el.style.length === 0) {
869      el.removeAttribute("style");
870    }
871  });
872  return () => {
873    setStyles(el, previousStyles);
874  };
875}
876function setStylesFromString(el, value) {
877  let cache = el.getAttribute("style", value);
878  el.setAttribute("style", value);
879  return () => {
880    el.setAttribute("style", cache || "");
881  };
882}
883function kebabCase(subject) {
884  return subject.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
885}
886function once(callback, fallback = () => {
887}) {
888  let called = false;
889  return function() {
890    if (!called) {
891      called = true;
892      callback.apply(this, arguments);
893    } else {
894      fallback.apply(this, arguments);
895    }
896  };
897}
898directive("transition", (el, { value, modifiers, expression }, { evaluate: evaluate2 }) => {
899  if (typeof expression === "function")
900    expression = evaluate2(expression);
901  if (expression === false)
902    return;
903  if (!expression || typeof expression === "boolean") {
904    registerTransitionsFromHelper(el, modifiers, value);
905  } else {
906    registerTransitionsFromClassString(el, expression, value);
907  }
908});
909function registerTransitionsFromClassString(el, classString, stage) {
910  registerTransitionObject(el, setClasses, "");
911  let directiveStorageMap = {
912    "enter": (classes) => {
913      el._x_transition.enter.during = classes;
914    },
915    "enter-start": (classes) => {
916      el._x_transition.enter.start = classes;
917    },
918    "enter-end": (classes) => {
919      el._x_transition.enter.end = classes;
920    },
921    "leave": (classes) => {
922      el._x_transition.leave.during = classes;
923    },
924    "leave-start": (classes) => {
925      el._x_transition.leave.start = classes;
926    },
927    "leave-end": (classes) => {
928      el._x_transition.leave.end = classes;
929    }
930  };
931  directiveStorageMap[stage](classString);
932}
933function registerTransitionsFromHelper(el, modifiers, stage) {
934  registerTransitionObject(el, setStyles);
935  let doesntSpecify = !modifiers.includes("in") && !modifiers.includes("out") && !stage;
936  let transitioningIn = doesntSpecify || modifiers.includes("in") || ["enter"].includes(stage);
937  let transitioningOut = doesntSpecify || modifiers.includes("out") || ["leave"].includes(stage);
938  if (modifiers.includes("in") && !doesntSpecify) {
939    modifiers = modifiers.filter((i3, index) => index < modifiers.indexOf("out"));
940  }
941  if (modifiers.includes("out") && !doesntSpecify) {
942    modifiers = modifiers.filter((i3, index) => index > modifiers.indexOf("out"));
943  }
944  let wantsAll = !modifiers.includes("opacity") && !modifiers.includes("scale");
945  let wantsOpacity = wantsAll || modifiers.includes("opacity");
946  let wantsScale = wantsAll || modifiers.includes("scale");
947  let opacityValue = wantsOpacity ? 0 : 1;
948  let scaleValue = wantsScale ? modifierValue(modifiers, "scale", 95) / 100 : 1;
949  let delay = modifierValue(modifiers, "delay", 0) / 1e3;
950  let origin = modifierValue(modifiers, "origin", "center");
951  let property = "opacity, transform";
952  let durationIn = modifierValue(modifiers, "duration", 150) / 1e3;
953  let durationOut = modifierValue(modifiers, "duration", 75) / 1e3;
954  let easing = `cubic-bezier(0.4, 0.0, 0.2, 1)`;
955  if (transitioningIn) {
956    el._x_transition.enter.during = {
957      transformOrigin: origin,
958      transitionDelay: `${delay}s`,
959      transitionProperty: property,
960      transitionDuration: `${durationIn}s`,
961      transitionTimingFunction: easing
962    };
963    el._x_transition.enter.start = {
964      opacity: opacityValue,
965      transform: `scale(${scaleValue})`
966    };
967    el._x_transition.enter.end = {
968      opacity: 1,
969      transform: `scale(1)`
970    };
971  }
972  if (transitioningOut) {
973    el._x_transition.leave.during = {
974      transformOrigin: origin,
975      transitionDelay: `${delay}s`,
976      transitionProperty: property,
977      transitionDuration: `${durationOut}s`,
978      transitionTimingFunction: easing
979    };
980    el._x_transition.leave.start = {
981      opacity: 1,
982      transform: `scale(1)`
983    };
984    el._x_transition.leave.end = {
985      opacity: opacityValue,
986      transform: `scale(${scaleValue})`
987    };
988  }
989}
990function registerTransitionObject(el, setFunction, defaultValue = {}) {
991  if (!el._x_transition)
992    el._x_transition = {
993      enter: { during: defaultValue, start: defaultValue, end: defaultValue },
994      leave: { during: defaultValue, start: defaultValue, end: defaultValue },
995      in(before = () => {
996      }, after = () => {
997      }) {
998        transition(el, setFunction, {
999          during: this.enter.during,
1000          start: this.enter.start,
1001          end: this.enter.end
1002        }, before, after);
1003      },
1004      out(before = () => {
1005      }, after = () => {
1006      }) {
1007        transition(el, setFunction, {
1008          during: this.leave.during,
1009          start: this.leave.start,
1010          end: this.leave.end
1011        }, before, after);
1012      }
1013    };
1014}
1015window.Element.prototype._x_toggleAndCascadeWithTransitions = function(el, value, show, hide) {
1016  const nextTick2 = document.visibilityState === "visible" ? requestAnimationFrame : setTimeout;
1017  let clickAwayCompatibleShow = () => nextTick2(show);
1018  if (value) {
1019    if (el._x_transition && (el._x_transition.enter || el._x_transition.leave)) {
1020      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();
1021    } else {
1022      el._x_transition ? el._x_transition.in(show) : clickAwayCompatibleShow();
1023    }
1024    return;
1025  }
1026  el._x_hidePromise = el._x_transition ? new Promise((resolve, reject) => {
1027    el._x_transition.out(() => {
1028    }, () => resolve(hide));
1029    el._x_transitioning && el._x_transitioning.beforeCancel(() => reject({ isFromCancelledTransition: true }));
1030  }) : Promise.resolve(hide);
1031  queueMicrotask(() => {
1032    let closest = closestHide(el);
1033    if (closest) {
1034      if (!closest._x_hideChildren)
1035        closest._x_hideChildren = [];
1036      closest._x_hideChildren.push(el);
1037    } else {
1038      nextTick2(() => {
1039        let hideAfterChildren = (el2) => {
1040          let carry = Promise.all([
1041            el2._x_hidePromise,
1042            ...(el2._x_hideChildren || []).map(hideAfterChildren)
1043          ]).then(([i3]) => i3());
1044          delete el2._x_hidePromise;
1045          delete el2._x_hideChildren;
1046          return carry;
1047        };
1048        hideAfterChildren(el).catch((e3) => {
1049          if (!e3.isFromCancelledTransition)
1050            throw e3;
1051        });
1052      });
1053    }
1054  });
1055};
1056function closestHide(el) {
1057  let parent = el.parentNode;
1058  if (!parent)
1059    return;
1060  return parent._x_hidePromise ? parent : closestHide(parent);
1061}
1062function transition(el, setFunction, { during, start: start2, end } = {}, before = () => {
1063}, after = () => {
1064}) {
1065  if (el._x_transitioning)
1066    el._x_transitioning.cancel();
1067  if (Object.keys(during).length === 0 && Object.keys(start2).length === 0 && Object.keys(end).length === 0) {
1068    before();
1069    after();
1070    return;
1071  }
1072  let undoStart, undoDuring, undoEnd;
1073  performTransition(el, {
1074    start() {
1075      undoStart = setFunction(el, start2);
1076    },
1077    during() {
1078      undoDuring = setFunction(el, during);
1079    },
1080    before,
1081    end() {
1082      undoStart();
1083      undoEnd = setFunction(el, end);
1084    },
1085    after,
1086    cleanup() {
1087      undoDuring();
1088      undoEnd();
1089    }
1090  });
1091}
1092function performTransition(el, stages) {
1093  let interrupted, reachedBefore, reachedEnd;
1094  let finish = once(() => {
1095    mutateDom(() => {
1096      interrupted = true;
1097      if (!reachedBefore)
1098        stages.before();
1099      if (!reachedEnd) {
1100        stages.end();
1101        releaseNextTicks();
1102      }
1103      stages.after();
1104      if (el.isConnected)
1105        stages.cleanup();
1106      delete el._x_transitioning;
1107    });
1108  });
1109  el._x_transitioning = {
1110    beforeCancels: [],
1111    beforeCancel(callback) {
1112      this.beforeCancels.push(callback);
1113    },
1114    cancel: once(function() {
1115      while (this.beforeCancels.length) {
1116        this.beforeCancels.shift()();
1117      }
1118      finish();
1119    }),
1120    finish
1121  };
1122  mutateDom(() => {
1123    stages.start();
1124    stages.during();
1125  });
1126  holdNextTicks();
1127  requestAnimationFrame(() => {
1128    if (interrupted)
1129      return;
1130    let duration = Number(getComputedStyle(el).transitionDuration.replace(/,.*/, "").replace("s", "")) * 1e3;
1131    let delay = Number(getComputedStyle(el).transitionDelay.replace(/,.*/, "").replace("s", "")) * 1e3;
1132    if (duration === 0)
1133      duration = Number(getComputedStyle(el).animationDuration.replace("s", "")) * 1e3;
1134    mutateDom(() => {
1135      stages.before();
1136    });
1137    reachedBefore = true;
1138    requestAnimationFrame(() => {
1139      if (interrupted)
1140        return;
1141      mutateDom(() => {
1142        stages.end();
1143      });
1144      releaseNextTicks();
1145      setTimeout(el._x_transitioning.finish, duration + delay);
1146      reachedEnd = true;
1147    });
1148  });
1149}
1150function modifierValue(modifiers, key, fallback) {
1151  if (modifiers.indexOf(key) === -1)
1152    return fallback;
1153  const rawValue = modifiers[modifiers.indexOf(key) + 1];
1154  if (!rawValue)
1155    return fallback;
1156  if (key === "scale") {
1157    if (isNaN(rawValue))
1158      return fallback;
1159  }
1160  if (key === "duration" || key === "delay") {
1161    let match = rawValue.match(/([0-9]+)ms/);
1162    if (match)
1163      return match[1];
1164  }
1165  if (key === "origin") {
1166    if (["top", "right", "left", "center", "bottom"].includes(modifiers[modifiers.indexOf(key) + 2])) {
1167      return [rawValue, modifiers[modifiers.indexOf(key) + 2]].join(" ");
1168    }
1169  }
1170  return rawValue;
1171}
1172var isCloning = false;
1173function skipDuringClone(callback, fallback = () => {
1174}) {
1175  return (...args) => isCloning ? fallback(...args) : callback(...args);
1176}
1177function onlyDuringClone(callback) {
1178  return (...args) => isCloning && callback(...args);
1179}
1180var interceptors = [];
1181function interceptClone(callback) {
1182  interceptors.push(callback);
1183}
1184function cloneNode(from, to) {
1185  interceptors.forEach((i3) => i3(from, to));
1186  isCloning = true;
1187  dontRegisterReactiveSideEffects(() => {
1188    initTree(to, (el, callback) => {
1189      callback(el, () => {
1190      });
1191    });
1192  });
1193  isCloning = false;
1194}
1195var isCloningLegacy = false;
1196function clone(oldEl, newEl) {
1197  if (!newEl._x_dataStack)
1198    newEl._x_dataStack = oldEl._x_dataStack;
1199  isCloning = true;
1200  isCloningLegacy = true;
1201  dontRegisterReactiveSideEffects(() => {
1202    cloneTree(newEl);
1203  });
1204  isCloning = false;
1205  isCloningLegacy = false;
1206}
1207function cloneTree(el) {
1208  let hasRunThroughFirstEl = false;
1209  let shallowWalker = (el2, callback) => {
1210    walk(el2, (el3, skip) => {
1211      if (hasRunThroughFirstEl && isRoot(el3))
1212        return skip();
1213      hasRunThroughFirstEl = true;
1214      callback(el3, skip);
1215    });
1216  };
1217  initTree(el, shallowWalker);
1218}
1219function dontRegisterReactiveSideEffects(callback) {
1220  let cache = effect;
1221  overrideEffect((callback2, el) => {
1222    let storedEffect = cache(callback2);
1223    release(storedEffect);
1224    return () => {
1225    };
1226  });
1227  callback();
1228  overrideEffect(cache);
1229}
1230function bind(el, name, value, modifiers = []) {
1231  if (!el._x_bindings)
1232    el._x_bindings = reactive({});
1233  el._x_bindings[name] = value;
1234  name = modifiers.includes("camel") ? camelCase(name) : name;
1235  switch (name) {
1236    case "value":
1237      bindInputValue(el, value);
1238      break;
1239    case "style":
1240      bindStyles(el, value);
1241      break;
1242    case "class":
1243      bindClasses(el, value);
1244      break;
1245    case "selected":
1246    case "checked":
1247      bindAttributeAndProperty(el, name, value);
1248      break;
1249    default:
1250      bindAttribute(el, name, value);
1251      break;
1252  }
1253}
1254function bindInputValue(el, value) {
1255  if (el.type === "radio") {
1256    if (el.attributes.value === void 0) {
1257      el.value = value;
1258    }
1259    if (window.fromModel) {
1260      if (typeof value === "boolean") {
1261        el.checked = safeParseBoolean(el.value) === value;
1262      } else {
1263        el.checked = checkedAttrLooseCompare(el.value, value);
1264      }
1265    }
1266  } else if (el.type === "checkbox") {
1267    if (Number.isInteger(value)) {
1268      el.value = value;
1269    } else if (!Array.isArray(value) && typeof value !== "boolean" && ![null, void 0].includes(value)) {

1270      el.value = String(value);
1271    } else {
1272      if (Array.isArray(value)) {
1273        el.checked = value.some((val) => checkedAttrLooseCompare(val, el.value));
1274      } else {
1275        el.checked = !!value;
1276      }
1277    }
1278  } else if (el.tagName === "SELECT") {
1279    updateSelect(el, value);
1280  } else {
1281    if (el.value === value)
1282      return;
1283    el.value = value === void 0 ? "" : value;
1284  }
1285}
1286function bindClasses(el, value) {
1287  if (el._x_undoAddedClasses)
1288    el._x_undoAddedClasses();
1289  el._x_undoAddedClasses = setClasses(el, value);
1290}
1291function bindStyles(el, value) {
1292  if (el._x_undoAddedStyles)
1293    el._x_undoAddedStyles();
1294  el._x_undoAddedStyles = setStyles(el, value);
1295}
1296function bindAttributeAndProperty(el, name, value) {
1297  bindAttribute(el, name, value);
1298  setPropertyIfChanged(el, name, value);
1299}
1300function bindAttribute(el, name, value) {
1301  if ([null, void 0, false].includes(value) && attributeShouldntBePreservedIfFalsy(name)) {
1302    el.removeAttribute(name);
1303  } else {
1304    if (isBooleanAttr(name))
1305      value = name;
1306    setIfChanged(el, name, value);
1307  }
1308}
1309function setIfChanged(el, attrName, value) {
1310  if (el.getAttribute(attrName) != value) {
1311    el.setAttribute(attrName, value);
1312  }
1313}
1314function setPropertyIfChanged(el, propName, value) {
1315  if (el[propName] !== value) {
1316    el[propName] = value;
1317  }
1318}
1319function updateSelect(el, value) {
1320  const arrayWrappedValue = [].concat(value).map((value2) => {
1321    return value2 + "";
1322  });
1323  Array.from(el.options).forEach((option) => {
1324    option.selected = arrayWrappedValue.includes(option.value);
1325  });
1326}
1327function camelCase(subject) {
1328  return subject.toLowerCase().replace(/-(\w)/g, (match, char) => char.toUpperCase());
1329}
1330function checkedAttrLooseCompare(valueA, valueB) {
1331  return valueA == valueB;
1332}
1333function safeParseBoolean(rawValue) {
1334  if ([1, "1", "true", "on", "yes", true].includes(rawValue)) {
1335    return true;
1336  }
1337  if ([0, "0", "false", "off", "no", false].includes(rawValue)) {
1338    return false;
1339  }
1340  return rawValue ? Boolean(rawValue) : null;
1341}
1342function isBooleanAttr(attrName) {
1343  const booleanAttributes = [
1344    "disabled",
1345    "checked",
1346    "required",
1347    "readonly",
1348    "hidden",
1349    "open",
1350    "selected",
1351    "autofocus",
1352    "itemscope",
1353    "multiple",
1354    "novalidate",
1355    "allowfullscreen",
1356    "allowpaymentrequest",
1357    "formnovalidate",
1358    "autoplay",
1359    "controls",
1360    "loop",
1361    "muted",
1362    "playsinline",
1363    "default",
1364    "ismap",
1365    "reversed",
1366    "async",
1367    "defer",
1368    "nomodule"
1369  ];
1370  return booleanAttributes.includes(attrName);
1371}
1372function attributeShouldntBePreservedIfFalsy(name) {
1373  return !["aria-pressed", "aria-checked", "aria-expanded", "aria-selected"].includes(name);
1374}
1375function getBinding(el, name, fallback) {
1376  if (el._x_bindings && el._x_bindings[name] !== void 0)
1377    return el._x_bindings[name];
1378  return getAttributeBinding(el, name, fallback);
1379}
1380function extractProp(el, name, fallback, extract = true) {
1381  if (el._x_bindings && el._x_bindings[name] !== void 0)
1382    return el._x_bindings[name];
1383  if (el._x_inlineBindings && el._x_inlineBindings[name] !== void 0) {
1384    let binding = el._x_inlineBindings[name];
1385    binding.extract = extract;
1386    return dontAutoEvaluateFunctions(() => {
1387      return evaluate(el, binding.expression);
1388    });
1389  }
1390  return getAttributeBinding(el, name, fallback);
1391}
1392function getAttributeBinding(el, name, fallback) {
1393  let attr = el.getAttribute(name);
1394  if (attr === null)
1395    return typeof fallback === "function" ? fallback() : fallback;
1396  if (attr === "")
1397    return true;
1398  if (isBooleanAttr(name)) {
1399    return !![name, "true"].includes(attr);
1400  }
1401  return attr;
1402}
1403function debounce(func, wait) {
1404  var timeout;
1405  return function() {
1406    var context = this, args = arguments;
1407    var later = function() {
1408      timeout = null;
1409      func.apply(context, args);
1410    };
1411    clearTimeout(timeout);
1412    timeout = setTimeout(later, wait);
1413  };
1414}
1415function throttle$1(func, limit) {
1416  let inThrottle;
1417  return function() {

1418    let context = this, args = arguments;
1419    if (!inThrottle) {
1420      func.apply(context, args);
1421      inThrottle = true;
1422      setTimeout(() => inThrottle = false, limit);
1423    }
1424  };
1425}
1426function entangle({ get: outerGet, set: outerSet }, { get: innerGet, set: innerSet }) {
1427  let firstRun = true;
1428  let outerHash;
1429  let reference = effect(() => {
1430    const outer = outerGet();
1431    const inner = innerGet();
1432    if (firstRun) {
1433      innerSet(cloneIfObject(outer));
1434      firstRun = false;
1435      outerHash = JSON.stringify(outer);
1436    } else {
1437      const outerHashLatest = JSON.stringify(outer);
1438      if (outerHashLatest !== outerHash) {
1439        innerSet(cloneIfObject(outer));
1440        outerHash = outerHashLatest;
1441      } else {
1442        outerSet(cloneIfObject(inner));
1443        outerHash = JSON.stringify(inner);
1444      }
1445    }
1446    JSON.stringify(innerGet());
1447    JSON.stringify(outerGet());
1448  });
1449  return () => {
1450    release(reference);
1451  };
1452}
1453function cloneIfObject(value) {
1454  return typeof value === "object" ? JSON.parse(JSON.stringify(value)) : value;
1455}
1456function plugin(callback) {
1457  let callbacks = Array.isArray(callback) ? callback : [callback];
1458  callbacks.forEach((i3) => i3(alpine_default));
1459}
1460var stores = {};
1461var isReactive = false;
1462function store(name, value) {
1463  if (!isReactive) {
1464    stores = reactive(stores);
1465    isReactive = true;
1466  }
1467  if (value === void 0) {
1468    return stores[name];
1469  }
1470  stores[name] = value;
1471  if (typeof value === "object" && value !== null && value.hasOwnProperty("init") && typeof value.init === "function") {
1472    stores[name].init();
1473  }
1474  initInterceptors2(stores[name]);
1475}
1476function getStores() {
1477  return stores;
1478}
1479var binds = {};
1480function bind2(name, bindings) {
1481  let getBindings = typeof bindings !== "function" ? () => bindings : bindings;
1482  if (name instanceof Element) {
1483    return applyBindingsObject(name, getBindings());
1484  } else {
1485    binds[name] = getBindings;
1486  }
1487  return () => {
1488  };
1489}
1490function injectBindingProviders(obj) {
1491  Object.entries(binds).forEach(([name, callback]) => {
1492    Object.defineProperty(obj, name, {
1493      get() {
1494        return (...args) => {
1495          return callback(...args);
1496        };
1497      }
1498    });
1499  });
1500  return obj;
1501}
1502function applyBindingsObject(el, obj, original) {
1503  let cleanupRunners = [];
1504  while (cleanupRunners.length)
1505    cleanupRunners.pop()();
1506  let attributes = Object.entries(obj).map(([name, value]) => ({ name, value }));
1507  let staticAttributes = attributesOnly(attributes);
1508  attributes = attributes.map((attribute) => {
1509    if (staticAttributes.find((attr) => attr.name === attribute.name)) {
1510      return {
1511        name: `x-bind:${attribute.name}`,
1512        value: `"${attribute.value}"`
1513      };
1514    }
1515    return attribute;
1516  });
1517  directives(el, attributes, original).map((handle) => {
1518    cleanupRunners.push(handle.runCleanups);
1519    handle();
1520  });
1521  return () => {
1522    while (cleanupRunners.length)
1523      cleanupRunners.pop()();
1524  };
1525}
1526var datas = {};
1527function data(name, callback) {
1528  datas[name] = callback;
1529}
1530function injectDataProviders(obj, context) {
1531  Object.entries(datas).forEach(([name, callback]) => {
1532    Object.defineProperty(obj, name, {
1533      get() {
1534        return (...args) => {
1535          return callback.bind(context)(...args);
1536        };
1537      },
1538      enumerable: false
1539    });
1540  });
1541  return obj;
1542}
1543var Alpine = {
1544  get reactive() {
1545    return reactive;
1546  },
1547  get release() {
1548    return release;
1549  },
1550  get effect() {
1551    return effect;
1552  },
1553  get raw() {
1554    return raw;
1555  },
1556  version: "3.13.3",
1557  flushAndStopDeferringMutations,
1558  dontAutoEvaluateFunctions,
1559  disableEffectScheduling,
1560  startObservingMutations,
1561  stopObservingMutations,
1562  setReactivityEngine,
1563  onAttributeRemoved,
1564  onAttributesAdded,
1565  closestDataStack,
1566  skipDuringClone,
1567  onlyDuringClone,
1568  addRootSelector,
1569  addInitSelector,
1570  interceptClone,
1571  addScopeToNode,
1572  deferMutations,
1573  mapAttributes,
1574  evaluateLater,
1575  interceptInit,
1576  setEvaluator,
1577  mergeProxies,
1578  extractProp,
1579  findClosest,
1580  onElRemoved,
1581  closestRoot,
1582  destroyTree,
1583  interceptor,
1584  // INTERNAL: not public API and is subject to change without major release.
1585  transition,
1586  // INTERNAL
1587  setStyles,
1588  // INTERNAL
1589  mutateDom,
1590  directive,
1591  entangle,
1592  throttle: throttle$1,
1593  debounce,
1594  evaluate,
1595  initTree,
1596  nextTick,
1597  prefixed: prefix,
1598  prefix: setPrefix,
1599  plugin,
1600  magic,
1601  store,
1602  start,
1603  clone,
1604  // INTERNAL
1605  cloneNode,
1606  // INTERNAL
1607  bound: getBinding,
1608  $data: scope,
1609  walk,
1610  data,
1611  bind: bind2
1612};
1613var alpine_default = Alpine;
1614function makeMap(str, expectsLowerCase) {
1615  const map = /* @__PURE__ */ Object.create(null);
1616  const list = str.split(",");
1617  for (let i3 = 0; i3 < list.length; i3++) {
1618    map[list[i3]] = true;
1619  }
1620  return (val) => !!map[val];
1621}
1622var EMPTY_OBJ = Object.freeze({});
1623var hasOwnProperty = Object.prototype.hasOwnProperty;
1624var hasOwn = (val, key) => hasOwnProperty.call(val, key);
1625var isArray$1 = Array.isArray;
1626var isMap = (val) => toTypeString(val) === "[object Map]";
1627var isString$1 = (val) => typeof val === "string";
1628var isSymbol = (val) => typeof val === "symbol";
1629var isObject$1 = (val) => val !== null && typeof val === "object";
1630var objectToString = Object.prototype.toString;
1631var toTypeString = (value) => objectToString.call(value);
1632var toRawType = (value) => {
1633  return toTypeString(value).slice(8, -1);
1634};
1635var isIntegerKey = (key) =>

2325  }));
2326  el._x_effects.delete(effectReference);
2327});
2328magic("store", getStores);
2329magic("data", (el) => scope(el));
2330magic("root", (el) => closestRoot(el));
2331magic("refs", (el) => {
2332  if (el._x_refs_proxy)
2333    return el._x_refs_proxy;
2334  el._x_refs_proxy = mergeProxies(getArrayOfRefObject(el));
2335  return el._x_refs_proxy;
2336});
2337function getArrayOfRefObject(el) {
2338  let refObjects = [];
2339  let currentEl = el;
2340  while (currentEl) {
2341    if (currentEl._x_refs)
2342      refObjects.push(currentEl._x_refs);
2343    currentEl = currentEl.parentNode;
2344  }
2345  return refObjects;
2346}
2347var globalIdMemo = {};
2348function findAndIncrementId(name) {
2349  if (!globalIdMemo[name])
2350    globalIdMemo[name] = 0;
2351  return ++globalIdMemo[name];
2352}
2353function closestIdRoot(el, name) {
2354  return findClosest(el, (element) => {
2355    if (element._x_ids && element._x_ids[name])
2356      return true;
2357  });
2358}
2359function setIdRoot(el, name) {
2360  if (!el._x_ids)
2361    el._x_ids = {};
2362  if (!el._x_ids[name])
2363    el._x_ids[name] = findAndIncrementId(name);
2364}
2365magic("id", (el) => (name, key = null) => {
2366  let root = closestIdRoot(el, name);
2367  let id = root ? root._x_ids[name] : findAndIncrementId(name);
2368  return key ? `${name}-${id}-${key}` : `${name}-${id}`;
2369});
2370magic("el", (el) => el);
2371warnMissingPluginMagic("Focus", "focus", "focus");
2372warnMissingPluginMagic("Persist", "persist", "persist");
2373function warnMissingPluginMagic(name, magicName, slug) {
2374  magic(magicName, (el) => warn$1(`You can't use [$${magicName}] without first installing the "${name}" plugin here: https://alpinejs.dev/plugins/${slug}`, el));
2375}
2376directive("modelable", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2, cleanup: cleanup2 }) => {
2377  let func = evaluateLater2(expression);
2378  let innerGet = () => {
2379    let result;
2380    func((i3) => result = i3);
2381    return result;
2382  };
2383  let evaluateInnerSet = evaluateLater2(`${expression} = __placeholder`);
2384  let innerSet = (val) => evaluateInnerSet(() => {
2385  }, { scope: { "__placeholder": val } });
2386  let initialValue = innerGet();
2387  innerSet(initialValue);
2388  queueMicrotask(() => {
2389    if (!el._x_model)
2390      return;
2391    el._x_removeModelListeners["default"]();
2392    let outerGet = el._x_model.get;
2393    let outerSet = el._x_model.set;
2394    let releaseEntanglement = entangle(
2395      {
2396        get() {
2397          return outerGet();
2398        },
2399        set(value) {
2400          outerSet(value);
2401        }
2402      },
2403      {
2404        get() {
2405          return innerGet();
2406        },
2407        set(value) {
2408          innerSet(value);
2409        }
2410      }
2411    );
2412    cleanup2(releaseEntanglement);
2413  });
2414});
2415directive("teleport", (el, { modifiers, expression }, { cleanup: cleanup2 }) => {
2416  if (el.tagName.toLowerCase() !== "template")
2417    warn$1("x-teleport can only be used on a <template> tag", el);
2418  let target = getTarget(expression);
2419  let clone2 = el.content.cloneNode(true).firstElementChild;
2420  el._x_teleport = clone2;
2421  clone2._x_teleportBack = el;
2422  el.setAttribute("data-teleport-template", true);
2423  clone2.setAttribute("data-teleport-target", true);
2424  if (el._x_forwardEvents) {
2425    el._x_forwardEvents.forEach((eventName) => {
2426      clone2.addEventListener(eventName, (e3) => {
2427        e3.stopPropagation();
2428        el.dispatchEvent(new e3.constructor(e3.type, e3));
2429      });
2430    });
2431  }
2432  addScopeToNode(clone2, {}, el);
2433  let placeInDom = (clone3, target2, modifiers2) => {
2434    if (modifiers2.includes("prepend")) {
2435      target2.parentNode.insertBefore(clone3, target2);
2436    } else if (modifiers2.includes("append")) {
2437      target2.parentNode.insertBefore(clone3, target2.nextSibling);
2438    } else {
2439      target2.appendChild(clone3);
2440    }
2441  };
2442  mutateDom(() => {
2443    placeInDom(clone2, target, modifiers);
2444    initTree(clone2);
2445    clone2._x_ignore = true;
2446  });
2447  el._x_teleportPutBack = () => {
2448    let target2 = getTarget(expression);
2449    mutateDom(() => {
2450      placeInDom(el._x_teleport, target2, modifiers);
2451    });
2452  };
2453  cleanup2(() => clone2.remove());
2454});
2455var teleportContainerDuringClone = document.createElement("div");
2456function getTarget(expression) {
2457  let target = skipDuringClone(() => {
2458    return document.querySelector(expression);
2459  }, () => {
2460    return teleportContainerDuringClone;
2461  })();
2462  if (!target)
2463    warn$1(`Cannot find x-teleport element for selector: "${expression}"`);
2464  return target;
2465}
2466var handler = () => {
2467};
2468handler.inline = (el, { modifiers }, { cleanup: cleanup2 }) => {
2469  modifiers.includes("self") ? el._x_ignoreSelf = true : el._x_ignore = true;
2470  cleanup2(() => {
2471    modifiers.includes("self") ? delete el._x_ignoreSelf : delete el._x_ignore;
2472  });
2473};
2474directive("ignore", handler);
2475directive("effect", skipDuringClone((el, { expression }, { effect: effect3 }) => {
2476  effect3(evaluateLater(el, expression));
2477}));
2478function on(el, event, modifiers, callback) {
2479  let listenerTarget = el;
2480  let handler4 = (e3) => callback(e3);
2481  let options = {};
2482  let wrapHandler = (callback2, wrapper) => (e3) => wrapper(callback2, e3);
2483  if (modifiers.includes("dot"))
2484    event = dotSyntax(event);
2485  if (modifiers.includes("camel"))
2486    event = camelCase2(event);
2487  if (modifiers.includes("passive"))
2488    options.passive = true;
2489  if (modifiers.includes("capture"))
2490    options.capture = true;
2491  if (modifiers.includes("window"))
2492    listenerTarget = window;
2493  if (modifiers.includes("document"))
2494    listenerTarget = document;
2495  if (modifiers.includes("debounce")) {
2496    let nextModifier = modifiers[modifiers.indexOf("debounce") + 1] || "invalid-wait";
2497    let wait = isNumeric(nextModifier.split("ms")[0]) ? Number(nextModifier.split("ms")[0]) : 250;
2498    handler4 = debounce(handler4, wait);
2499  }
2500  if (modifiers.includes("throttle")) {
2501    let nextModifier = modifiers[modifiers.indexOf("throttle") + 1] || "invalid-wait";
2502    let wait = isNumeric(nextModifier.split("ms")[0]) ? Number(nextModifier.split("ms")[0]) : 250;
2503    handler4 = throttle$1(handler4, wait);
2504  }
2505  if (modifiers.includes("prevent"))
2506    handler4 = wrapHandler(handler4, (next, e3) => {
2507      e3.preventDefault();
2508      next(e3);
2509    });
2510  if (modifiers.includes("stop"))
2511    handler4 = wrapHandler(handler4, (next, e3) => {
2512      e3.stopPropagation();
2513      next(e3);
2514    });
2515  if (modifiers.includes("self"))
2516    handler4 = wrapHandler(handler4, (next, e3) => {
2517      e3.target === el && next(e3);
2518    });
2519  if (modifiers.includes("away") || modifiers.includes("outside")) {
2520    listenerTarget = document;
2521    handler4 = wrapHandler(handler4, (next, e3) => {
2522      if (el.contains(e3.target))
2523        return;
2524      if (e3.target.isConnected === false)
2525        return;
2526      if (el.offsetWidth < 1 && el.offsetHeight < 1)
2527        return;
2528      if (el._x_isShown === false)
2529        return;
2530      next(e3);
2531    });
2532  }
2533  if (modifiers.includes("once")) {
2534    handler4 = wrapHandler(handler4, (next, e3) => {
2535      next(e3);
2536      listenerTarget.removeEventListener(event, handler4, options);
2537    });
2538  }
2539  handler4 = wrapHandler(handler4, (next, e3) => {
2540    if (isKeyEvent(event)) {
2541      if (isListeningForASpecificKeyThatHasntBeenPressed(e3, modifiers)) {
2542        return;
2543      }
2544    }
2545    next(e3);
2546  });
2547  listenerTarget.addEventListener(event, handler4, options);
2548  return () => {
2549    listenerTarget.removeEventListener(event, handler4, options);
2550  };
2551}
2552function dotSyntax(subject) {
2553  return subject.replace(/-/g, ".");
2554}

2555function camelCase2(subject) {
2556  return subject.toLowerCase().replace(/-(\w)/g, (match, char) => char.toUpperCase());
2557}
2558function isNumeric(subject) {
2559  return !Array.isArray(subject) && !isNaN(subject);
2560}
2561function kebabCase2(subject) {
2562  if ([" ", "_"].includes(
2563    subject
2564  ))
2565    return subject;
2566  return subject.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[_\s]/, "-").toLowerCase();
2567}
2568function isKeyEvent(event) {
2569  return ["keydown", "keyup"].includes(event);
2570}
2571function isListeningForASpecificKeyThatHasntBeenPressed(e3, modifiers) {
2572  let keyModifiers = modifiers.filter((i3) => {
2573    return !["window", "document", "prevent", "stop", "once", "capture"].includes(i3);
2574  });
2575  if (keyModifiers.includes("debounce")) {
2576    let debounceIndex = keyModifiers.indexOf("debounce");
2577    keyModifiers.splice(debounceIndex, isNumeric((keyModifiers[debounceIndex + 1] || "invalid-wait").split("ms")[0]) ? 2 : 1);
2578  }
2579  if (keyModifiers.includes("throttle")) {
2580    let debounceIndex = keyModifiers.indexOf("throttle");
2581    keyModifiers.splice(debounceIndex, isNumeric((keyModifiers[debounceIndex + 1] || "invalid-wait").split("ms")[0]) ? 2 : 1);
2582  }
2583  if (keyModifiers.length === 0)
2584    return false;
2585  if (keyModifiers.length === 1 && keyToModifiers(e3.key).includes(keyModifiers[0]))
2586    return false;
2587  const systemKeyModifiers = ["ctrl", "shift", "alt", "meta", "cmd", "super"];
2588  const selectedSystemKeyModifiers = systemKeyModifiers.filter((modifier) => keyModifiers.includes(modifier));
2589  keyModifiers = keyModifiers.filter((i3) => !selectedSystemKeyModifiers.includes(i3));
2590  if (selectedSystemKeyModifiers.length > 0) {
2591    const activelyPressedKeyModifiers = selectedSystemKeyModifiers.filter((modifier) => {
2592      if (modifier === "cmd" || modifier === "super")
2593        modifier = "meta";
2594      return e3[`${modifier}Key`];
2595    });
2596    if (activelyPressedKeyModifiers.length === selectedSystemKeyModifiers.length) {
2597      if (keyToModifiers(e3.key).includes(keyModifiers[0]))
2598        return false;
2599    }
2600  }
2601  return true;
2602}
2603function keyToModifiers(key) {
2604  if (!key)
2605    return [];
2606  key = kebabCase2(key);
2607  let modifierToKeyMap = {
2608    "ctrl": "control",
2609    "slash": "/",
2610    "space": " ",
2611    "spacebar": " ",
2612    "cmd": "meta",
2613    "esc": "escape",
2614    "up": "arrow-up",
2615    "down": "arrow-down",
2616    "left": "arrow-left",
2617    "right": "arrow-right",
2618    "period": ".",
2619    "equal": "=",
2620    "minus": "-",
2621    "underscore": "_"
2622  };
2623  modifierToKeyMap[key] = key;
2624  return Object.keys(modifierToKeyMap).map((modifier) => {
2625    if (modifierToKeyMap[modifier] === key)
2626      return modifier;
2627  }).filter((modifier) => modifier);
2628}
2629directive("model", (el, { modifiers, expression }, { effect: effect3, cleanup: cleanup2 }) => {
2630  let scopeTarget = el;
2631  if (modifiers.includes("parent")) {
2632    scopeTarget = el.parentNode;
2633  }
2634  let evaluateGet = evaluateLater(scopeTarget, expression);
2635  let evaluateSet;
2636  if (typeof expression === "string") {
2637    evaluateSet = evaluateLater(scopeTarget, `${expression} = __placeholder`);
2638  } else if (typeof expression === "function" && typeof expression() === "string") {
2639    evaluateSet = evaluateLater(scopeTarget, `${expression()} = __placeholder`);
2640  } else {
2641    evaluateSet = () => {
2642    };
2643  }
2644  let getValue = () => {
2645    let result;
2646    evaluateGet((value) => result = value);
2647    return isGetterSetter(result) ? result.get() : result;
2648  };
2649  let setValue = (value) => {
2650    let result;
2651    evaluateGet((value2) => result = value2);
2652    if (isGetterSetter(result)) {
2653      result.set(value);
2654    } else {
2655      evaluateSet(() => {
2656      }, {
2657        scope: { "__placeholder": value }
2658      });
2659    }
2660  };
2661  if (typeof expression === "string" && el.type === "radio") {
2662    mutateDom(() => {
2663      if (!el.hasAttribute("name"))
2664        el.setAttribute("name", expression);
2665    });
2666  }
2667  var event = el.tagName.toLowerCase() === "select" || ["checkbox", "radio"].includes(el.type) || modifiers.includes("lazy") ? "change" : "input";
2668  let removeListener = isCloning ? () => {
2669  } : on(el, event, modifiers, (e3) => {
2670    setValue(getInputValue(el, modifiers, e3, getValue()));
2671  });
2672  if (modifiers.includes("fill")) {
2673    if ([null, ""].includes(getValue()) || el.type === "checkbox" && Array.isArray(getValue())) {
2674      el.dispatchEvent(new Event(event, {}));
2675    }
2676  }
2677  if (!el._x_removeModelListeners)
2678    el._x_removeModelListeners = {};
2679  el._x_removeModelListeners["default"] = removeListener;
2680  cleanup2(() => el._x_removeModelListeners["default"]());
2681  if (el.form) {
2682    let removeResetListener = on(el.form, "reset", [], (e3) => {
2683      nextTick(() => el._x_model && el._x_model.set(el.value));
2684    });
2685    cleanup2(() => removeResetListener());
2686  }
2687  el._x_model = {
2688    get() {
2689      return getValue();
2690    },
2691    set(value) {
2692      setValue(value);
2693    }
2694  };
2695  el._x_forceModelUpdate = (value) => {
2696    if (value === void 0 && typeof expression === "string" && expression.match(/\./))
2697      value = "";
2698    window.fromModel = true;
2699    mutateDom(() => bind(el, "value", value));
2700    delete window.fromModel;
2701  };
2702  effect3(() => {
2703    let value = getValue();
2704    if (modifiers.includes("unintrusive") && document.activeElement.isSameNode(el))
2705      return;
2706    el._x_forceModelUpdate(value);
2707  });
2708});
2709function getInputValue(el, modifiers, event, currentValue) {
2710  return mutateDom(() => {
2711    if (event instanceof CustomEvent && event.detail !== void 0)
2712      return event.detail !== null && event.detail !== void 0 ? event.detail : event.target.value;
2713    else if (el.type === "checkbox") {
2714      if (Array.isArray(currentValue)) {
2715        let newValue = null;
2716        if (modifiers.includes("number")) {
2717          newValue = safeParseNumber(event.target.value);
2718        } else if (modifiers.includes("boolean")) {
2719          newValue = safeParseBoolean(event.target.value);
2720        } else {
2721          newValue = event.target.value;
2722        }
2723        return event.target.checked ? currentValue.concat([newValue]) : currentValue.filter((el2) => !checkedAttrLooseCompare2(el2, newValue));
2724      } else {
2725        return event.target.checked;
2726      }
2727    } else if (el.tagName.toLowerCase() === "select" && el.multiple) {
2728      if (modifiers.includes("number")) {
2729        return Array.from(event.target.selectedOptions).map((option) => {
2730          let rawValue = option.value || option.text;
2731          return safeParseNumber(rawValue);
2732        });
2733      } else if (modifiers.includes("boolean")) {
2734        return Array.from(event.target.selectedOptions).map((option) => {
2735          let rawValue = option.value || option.text;
2736          return safeParseBoolean(rawValue);
2737        });
2738      }
2739      return Array.from(event.target.selectedOptions).map((option) => {
2740        return option.value || option.text;
2741      });
2742    } else {
2743      if (modifiers.includes("number")) {
2744        return safeParseNumber(event.target.value);
2745      } else if (modifiers.includes("boolean")) {
2746        return safeParseBoolean(event.target.value);
2747      }
2748      return modifiers.includes("trim") ? event.target.value.trim() : event.target.value;
2749    }
2750  });
2751}
2752function safeParseNumber(rawValue) {
2753  let number = rawValue ? parseFloat(rawValue) : null;
2754  return isNumeric2(number) ? number : rawValue;
2755}
2756function checkedAttrLooseCompare2(valueA, valueB) {
2757  return valueA == valueB;
2758}
2759function isNumeric2(subject) {
2760  return !Array.isArray(subject) && !isNaN(subject);
2761}
2762function isGetterSetter(value) {
2763  return value !== null && typeof value === "object" && typeof value.get === "function" && typeof value.set === "function";
2764}
2765directive("cloak", (el) => queueMicrotask(() => mutateDom(() => el.removeAttribute(prefix("cloak")))));
2766addInitSelector(() => `[${prefix("init")}]`);
2767directive("init", skipDuringClone((el, { expression }, { evaluate: evaluate2 }) => {
2768  if (typeof expression === "string") {
2769    return !!expression.trim() && evaluate2(expression, {}, false);
2770  }
2771  return evaluate2(expression, {}, false);
2772}));
2773directive("text", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2 }) => {
2774  let evaluate2 = evaluateLater2(expression);
2775  effect3(() => {
2776    evaluate2((value) => {
2777      mutateDom(() => {
2778        el.textContent = value;
2779      });
2780    });
2781  });
2782});
2783directive("html", (el, { expression }, { effect: effect3, evaluateLater: evaluateLater2 }) => {
2784  let evaluate2 = evaluateLater2(expression);
2785  effect3(() => {
2786    evaluate2((value) => {
2787      mutateDom(() => {
2788        el.innerHTML = value;
2789        el._x_ignoreSelf = true;
2790        initTree(el);
2791        delete el._x_ignoreSelf;
2792      });
2793    });
2794  });
2795});
2796mapAttributes(startingWith(":", into(prefix("bind:"))));
2797var handler2 = (el, { value, modifiers, expression, original }, { effect: effect3 }) => {
2798  if (!value) {
2799    let bindingProviders = {};
2800    injectBindingProviders(bindingProviders);
2801    let getBindings = evaluateLater(el, expression);
2802    getBindings((bindings) => {
2803      applyBindingsObject(el, bindings, original);
2804    }, { scope: bindingProviders });
2805    return;
2806  }
2807  if (value === "key")
2808    return storeKeyForXFor(el, expression);
2809  if (el._x_inlineBindings && el._x_inlineBindings[value] && el._x_inlineBindings[value].extract) {
2810    return;
2811  }
2812  let evaluate2 = evaluateLater(el, expression);
2813  effect3(() => evaluate2((result) => {
2814    if (result === void 0 && typeof expression === "string" && expression.match(/\./)) {
2815      result = "";
2816    }
2817    mutateDom(() => bind(el, value, result, modifiers));
2818  }));
2819};
2820handler2.inline = (el, { value, modifiers, expression }) => {
2821  if (!value)
2822    return;
2823  if (!el._x_inlineBindings)
2824    el._x_inlineBindings = {};
2825  el._x_inlineBindings[value] = { expression, extract: false };
2826};
2827directive("bind", handler2);
2828function storeKeyForXFor(el, expression) {
2829  el._x_keyExpression = expression;
2830}
2831addRootSelector(() => `[${prefix("data")}]`);
2832directive("data", (el, { expression }, { cleanup: cleanup2 }) => {
2833  if (shouldSkipRegisteringDataDuringClone(el))
2834    return;
2835  expression = expression === "" ? "{}" : expression;
2836  let magicContext = {};
2837  injectMagics(magicContext, el);
2838  let dataProviderContext = {};
2839  injectDataProviders(dataProviderContext, magicContext);
2840  let data2 = evaluate(el, expression, { scope: dataProviderContext });
2841  if (data2 === void 0 || data2 === true)
2842    data2 = {};
2843  injectMagics(data2, el);
2844  let reactiveData = reactive(data2);
2845  initInterceptors2(reactiveData);
2846  let undo = addScopeToNode(el, reactiveData);
2847  reactiveData["init"] && evaluate(el, reactiveData["init"]);
2848  cleanup2(() => {
2849    reactiveData["destroy"] && evaluate(el, reactiveData["destroy"]);
2850    undo();
2851  });
2852});
2853interceptClone((from, to) => {
2854  if (from._x_dataStack) {
2855    to._x_dataStack = from._x_dataStack;
2856    to.setAttribute("data-has-alpine-state", true);
2857  }
2858});
2859function shouldSkipRegisteringDataDuringClone(el) {
2860  if (!isCloning)
2861    return false;