@proyecto-viviana/solidaria 0.0.1

package/dist/index.js

@@ -0,0 +1,2834 @@
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var _shouldStopPropagation;
+import { onCleanup, createSignal, onMount, useContext, createContext, createEffect, createMemo, untrack, createUniqueId } from "solid-js";
+import { isServer } from "solid-js/web";
+class PressEvent {
+  constructor(type, pointerType, originalEvent, target) {
+    __publicField(this, "type");
+    __publicField(this, "pointerType");
+    __publicField(this, "target");
+    __publicField(this, "shiftKey");
+    __publicField(this, "ctrlKey");
+    __publicField(this, "metaKey");
+    __publicField(this, "altKey");
+    __publicField(this, "x");
+    __publicField(this, "y");
+    __privateAdd(this, _shouldStopPropagation, true);
+    this.type = type;
+    this.pointerType = pointerType;
+    this.target = target;
+    const e = originalEvent;
+    this.shiftKey = (e == null ? void 0 : e.shiftKey) ?? false;
+    this.ctrlKey = (e == null ? void 0 : e.ctrlKey) ?? false;
+    this.metaKey = (e == null ? void 0 : e.metaKey) ?? false;
+    this.altKey = (e == null ? void 0 : e.altKey) ?? false;
+    this.x = 0;
+    this.y = 0;
+    if (originalEvent && "clientX" in originalEvent && target) {
+      const rect = target.getBoundingClientRect();
+      this.x = originalEvent.clientX - rect.left;
+      this.y = originalEvent.clientY - rect.top;
+    } else if (target) {
+      const rect = target.getBoundingClientRect();
+      this.x = rect.width / 2;
+      this.y = rect.height / 2;
+    }
+  }
+  /**
+   * Call this to allow the press event to propagate to parent elements.
+   * By default, press events stop propagation.
+   */
+  continuePropagation() {
+    __privateSet(this, _shouldStopPropagation, false);
+  }
+  /**
+   * Whether the event should stop propagation.
+   * Used internally by the press handler.
+   */
+  get shouldStopPropagation() {
+    return __privateGet(this, _shouldStopPropagation);
+  }
+}
+_shouldStopPropagation = new WeakMap();
+function createPressEvent(type, pointerType, originalEvent, target) {
+  return new PressEvent(type, pointerType, originalEvent, target);
+}
+function mergeProps(...args) {
+  var _a;
+  const result = {};
+  for (const props of args) {
+    for (const key in props) {
+      const value = props[key];
+      const existingValue = result[key];
+      if (typeof existingValue === "function" && typeof value === "function" && key.startsWith("on") && key[2] === ((_a = key[2]) == null ? void 0 : _a.toUpperCase())) {
+        result[key] = chainHandlers(existingValue, value);
+      } else if (key === "class" || key === "className") {
+        result[key] = mergeClassNames(existingValue, value);
+      } else if (key === "style" && typeof existingValue === "object" && typeof value === "object") {
+        result[key] = { ...existingValue, ...value };
+      } else if (value !== void 0) {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function chainHandlers(existingHandler, newHandler) {
+  return (...args) => {
+    existingHandler(...args);
+    newHandler(...args);
+  };
+}
+function mergeClassNames(...classes) {
+  return classes.filter(Boolean).join(" ");
+}
+const DOMPropNames = /* @__PURE__ */ new Set(["id"]);
+const labelablePropNames = /* @__PURE__ */ new Set([
+  "aria-label",
+  "aria-labelledby",
+  "aria-describedby",
+  "aria-details"
+]);
+const linkPropNames = /* @__PURE__ */ new Set([
+  "href",
+  "hrefLang",
+  "target",
+  "rel",
+  "download",
+  "ping",
+  "referrerPolicy"
+]);
+const globalAttrs = /* @__PURE__ */ new Set(["dir", "lang", "hidden", "inert", "translate"]);
+const globalEvents = /* @__PURE__ */ new Set([
+  "onClick",
+  "onAuxClick",
+  "onContextMenu",
+  "onDoubleClick",
+  "onMouseDown",
+  "onMouseEnter",
+  "onMouseLeave",
+  "onMouseMove",
+  "onMouseOut",
+  "onMouseOver",
+  "onMouseUp",
+  "onTouchCancel",
+  "onTouchEnd",
+  "onTouchMove",
+  "onTouchStart",
+  "onPointerDown",
+  "onPointerMove",
+  "onPointerUp",
+  "onPointerCancel",
+  "onPointerEnter",
+  "onPointerLeave",
+  "onPointerOver",
+  "onPointerOut",
+  "onGotPointerCapture",
+  "onLostPointerCapture",
+  "onScroll",
+  "onWheel",
+  "onAnimationStart",
+  "onAnimationEnd",
+  "onAnimationIteration",
+  "onTransitionCancel",
+  "onTransitionEnd",
+  "onTransitionRun",
+  "onTransitionStart"
+]);
+const propRe = /^(data-.*)$/;
+function filterDOMProps(props, opts = {}) {
+  const { labelable, isLink, global, events = global, propNames } = opts;
+  const filteredProps = {};
+  for (const prop in props) {
+    if (Object.prototype.hasOwnProperty.call(props, prop) && (DOMPropNames.has(prop) || labelable && labelablePropNames.has(prop) || isLink && linkPropNames.has(prop) || global && globalAttrs.has(prop) || events && (globalEvents.has(prop) || prop.endsWith("Capture") && globalEvents.has(prop.slice(0, -7))) || (propNames == null ? void 0 : propNames.has(prop)) || propRe.test(prop))) {
+      filteredProps[prop] = props[prop];
+    }
+  }
+  return filteredProps;
+}
+function access$1(value) {
+  return typeof value === "function" ? value() : value;
+}
+function isAccessor(value) {
+  return typeof value === "function";
+}
+function testPlatform(re) {
+  var _a;
+  return typeof window !== "undefined" && window.navigator != null ? re.test(window.navigator.platform || ((_a = window.navigator.userAgentData) == null ? void 0 : _a.platform) || "") : false;
+}
+function isMac() {
+  return testPlatform(/^Mac/i);
+}
+function isIPhone() {
+  return testPlatform(/^iPhone/i);
+}
+function isIPad() {
+  return testPlatform(/^iPad/i) || isMac() && navigator.maxTouchPoints > 1;
+}
+function isIOS() {
+  return isIPhone() || isIPad();
+}
+function getOwnerDocument(el) {
+  return (el == null ? void 0 : el.ownerDocument) ?? document;
+}
+function nodeContains(parent, child) {
+  if (!parent || !child) {
+    return false;
+  }
+  if (parent.contains(child)) {
+    return true;
+  }
+  let node = child;
+  while (node) {
+    if (node === parent) {
+      return true;
+    }
+    if (node.host) {
+      node = node.host;
+    } else {
+      node = node.parentNode;
+    }
+  }
+  return false;
+}
+function getEventTarget(event) {
+  if (typeof event.composedPath === "function") {
+    const path = event.composedPath();
+    if (path.length > 0) {
+      return path[0];
+    }
+  }
+  return event.target;
+}
+function isValidKeyboardEvent(event, currentTarget) {
+  const { key, code } = event;
+  const element = currentTarget;
+  const tagName = element.tagName.toLowerCase();
+  const role = element.getAttribute("role");
+  const isActivationKey = key === "Enter" || key === " " || key === "Spacebar" || code === "Space";
+  if (!isActivationKey) {
+    return false;
+  }
+  if (tagName === "textarea") {
+    return false;
+  }
+  if (element.isContentEditable) {
+    return false;
+  }
+  const isLink = tagName === "a" || role === "link";
+  if (isLink && key !== "Enter") {
+    return false;
+  }
+  if (tagName === "input") {
+    return isValidInputKey(element, key);
+  }
+  return true;
+}
+function isValidInputKey(target, key) {
+  const type = target.type.toLowerCase();
+  if (type === "checkbox" || type === "radio") {
+    return key === " " || key === "Spacebar";
+  }
+  const textInputTypes = [
+    "text",
+    "search",
+    "url",
+    "tel",
+    "email",
+    "password",
+    "date",
+    "month",
+    "week",
+    "time",
+    "datetime-local",
+    "number"
+  ];
+  if (textInputTypes.includes(type)) {
+    return false;
+  }
+  return true;
+}
+function isHTMLAnchorLink(target) {
+  return target.tagName === "A" && target.hasAttribute("href");
+}
+function shouldPreventDefaultKeyboard(target, key) {
+  const tagName = target.tagName.toLowerCase();
+  if (tagName === "input" || tagName === "textarea" || tagName === "select") {
+    return false;
+  }
+  if ((tagName === "a" || target.getAttribute("role") === "link") && key === "Enter") {
+    return false;
+  }
+  if (tagName === "button") {
+    const type = target.type;
+    if (type === "submit" || type === "reset") {
+      return false;
+    }
+  }
+  return true;
+}
+function openLink(target, event, allowOpener = false) {
+  const { href, target: linkTarget, rel } = target;
+  const keyEvent = event;
+  const shouldOpenInNewTab = linkTarget === "_blank" || (keyEvent == null ? void 0 : keyEvent.metaKey) || (keyEvent == null ? void 0 : keyEvent.ctrlKey) || (keyEvent == null ? void 0 : keyEvent.shiftKey) || (keyEvent == null ? void 0 : keyEvent.altKey);
+  if (shouldOpenInNewTab) {
+    const features = !allowOpener && (rel == null ? void 0 : rel.includes("noopener")) ? "noopener" : void 0;
+    window.open(href, linkTarget || "_blank", features);
+  } else {
+    window.location.href = href;
+  }
+}
+function areRectanglesOverlapping(a, b) {
+  if (a.left > b.right || b.left > a.right) {
+    return false;
+  }
+  if (a.top > b.bottom || b.top > a.bottom) {
+    return false;
+  }
+  return true;
+}
+function getPointClientRect(point) {
+  let offsetX = 0;
+  let offsetY = 0;
+  if (point.width !== void 0 && point.width > 0) {
+    offsetX = point.width / 2;
+  } else if (point.radiusX !== void 0 && point.radiusX > 0) {
+    offsetX = point.radiusX;
+  }
+  if (point.height !== void 0 && point.height > 0) {
+    offsetY = point.height / 2;
+  } else if (point.radiusY !== void 0 && point.radiusY > 0) {
+    offsetY = point.radiusY;
+  }
+  return {
+    top: point.clientY - offsetY,
+    right: point.clientX + offsetX,
+    bottom: point.clientY + offsetY,
+    left: point.clientX - offsetX
+  };
+}
+function isPointOverTarget(point, target) {
+  const rect = target.getBoundingClientRect();
+  const pointRect = getPointClientRect(point);
+  return areRectanglesOverlapping(
+    {
+      top: rect.top,
+      right: rect.right,
+      bottom: rect.bottom,
+      left: rect.left
+    },
+    pointRect
+  );
+}
+function getTouchFromEvent(event) {
+  const { targetTouches } = event;
+  if (targetTouches.length > 0) {
+    return targetTouches[0];
+  }
+  return null;
+}
+function getTouchById(event, pointerId) {
+  if (pointerId == null) {
+    return null;
+  }
+  const { changedTouches } = event;
+  for (let i = 0; i < changedTouches.length; i++) {
+    const touch = changedTouches[i];
+    if (touch.identifier === pointerId) {
+      return touch;
+    }
+  }
+  return null;
+}
+function isVirtualClick(event) {
+  if (event.mozInputSource === 0 && event.isTrusted) {
+    return true;
+  }
+  if (isAndroidTalkBackClick(event)) {
+    return true;
+  }
+  return event.detail === 0 && !event.pointerType;
+}
+function isAndroidTalkBackClick(event) {
+  return event.detail === 1 && event.offsetX === 0 && event.offsetY === 0;
+}
+function isVirtualPointerEvent(event) {
+  return event.width === 0 && event.height === 0 || // Some screen readers send events with pointerType but no actual pointer
+  event.pointerType === "mouse" && event.width === 1 && event.height === 1 && event.pressure === 0 && event.detail === 0 && event.buttons === 0;
+}
+function setEventTarget(event, target) {
+  Object.defineProperty(event, "target", {
+    value: target,
+    writable: false,
+    configurable: true
+  });
+  Object.defineProperty(event, "currentTarget", {
+    value: target,
+    writable: false,
+    configurable: true
+  });
+}
+let state = "default";
+let savedUserSelect = "";
+let modifiedElementMap = /* @__PURE__ */ new WeakMap();
+function disableTextSelection(target) {
+  if (isIOS()) {
+    if (state === "default") {
+      const documentElement = getOwnerDocument(target).documentElement;
+      savedUserSelect = documentElement.style.webkitUserSelect;
+      documentElement.style.webkitUserSelect = "none";
+    }
+    state = "disabled";
+  } else if (target) {
+    const element = target;
+    if (!modifiedElementMap.has(element)) {
+      modifiedElementMap.set(element, element.style.userSelect);
+      element.style.userSelect = "none";
+    }
+  }
+}
+function restoreTextSelection(target) {
+  if (isIOS()) {
+    if (state !== "disabled") {
+      return;
+    }
+    state = "restoring";
+    setTimeout(() => {
+      runAfterTransition(() => {
+        if (state === "restoring") {
+          const documentElement = getOwnerDocument(target).documentElement;
+          if (savedUserSelect) {
+            documentElement.style.webkitUserSelect = savedUserSelect;
+          } else {
+            documentElement.style.removeProperty("-webkit-user-select");
+          }
+          savedUserSelect = "";
+          state = "default";
+        }
+      });
+    }, 300);
+  } else if (target) {
+    const element = target;
+    const savedValue = modifiedElementMap.get(element);
+    if (savedValue !== void 0) {
+      if (savedValue) {
+        element.style.userSelect = savedValue;
+      } else {
+        element.style.removeProperty("user-select");
+      }
+      modifiedElementMap.delete(element);
+    }
+  }
+}
+const pendingTransitions = /* @__PURE__ */ new Set();
+let transitionTimeout = null;
+function runAfterTransition(callback) {
+  pendingTransitions.add(callback);
+  if (transitionTimeout != null) {
+    clearTimeout(transitionTimeout);
+  }
+  transitionTimeout = setTimeout(() => {
+    for (const cb of pendingTransitions) {
+      cb();
+    }
+    pendingTransitions.clear();
+    transitionTimeout = null;
+  }, 0);
+}
+function focusWithoutScrolling(element) {
+  if (!element) return;
+  try {
+    element.focus({ preventScroll: true });
+  } catch {
+    const scrollableElements = getScrollableAncestors(element);
+    const scrollPositions = scrollableElements.map((el) => ({
+      element: el,
+      scrollTop: el.scrollTop,
+      scrollLeft: el.scrollLeft
+    }));
+    element.focus();
+    for (const { element: el, scrollTop, scrollLeft } of scrollPositions) {
+      el.scrollTop = scrollTop;
+      el.scrollLeft = scrollLeft;
+    }
+  }
+}
+function getScrollableAncestors(element) {
+  const ancestors = [];
+  let parent = element.parentElement;
+  while (parent) {
+    const style = getComputedStyle(parent);
+    const overflowY = style.overflowY;
+    const overflowX = style.overflowX;
+    if (overflowY === "auto" || overflowY === "scroll" || overflowX === "auto" || overflowX === "scroll") {
+      ancestors.push(parent);
+    }
+    parent = parent.parentElement;
+  }
+  const doc = getOwnerDocument(element);
+  ancestors.push(doc.documentElement);
+  return ancestors;
+}
+let ignoreFocus = false;
+let preventFocusTimeout = null;
+function preventFocus(target) {
+  const focusableAncestor = findFocusableAncestor(target);
+  if (!focusableAncestor) return;
+  const document2 = getOwnerDocument(target);
+  const activeElement = document2.activeElement;
+  ignoreFocus = true;
+  const onFocus = (e) => {
+    if (ignoreFocus) {
+      e.stopImmediatePropagation();
+      if (activeElement && activeElement !== document2.body) {
+        activeElement.focus();
+      }
+    }
+  };
+  const onBlur = (e) => {
+    if (ignoreFocus) {
+      e.stopImmediatePropagation();
+    }
+  };
+  const el = focusableAncestor;
+  el.addEventListener("focus", onFocus, true);
+  el.addEventListener("blur", onBlur, true);
+  el.addEventListener("focusin", onFocus, true);
+  el.addEventListener("focusout", onBlur, true);
+  if (preventFocusTimeout != null) {
+    clearTimeout(preventFocusTimeout);
+  }
+  preventFocusTimeout = setTimeout(() => {
+    ignoreFocus = false;
+    el.removeEventListener("focus", onFocus, true);
+    el.removeEventListener("blur", onBlur, true);
+    el.removeEventListener("focusin", onFocus, true);
+    el.removeEventListener("focusout", onBlur, true);
+    preventFocusTimeout = null;
+  }, 0);
+}
+function findFocusableAncestor(element) {
+  let current = element;
+  while (current) {
+    if (current.hasAttribute("tabindex") || ["INPUT", "BUTTON", "SELECT", "TEXTAREA", "A"].includes(current.tagName)) {
+      return current;
+    }
+    current = current.parentElement;
+  }
+  return element;
+}
+const focusSafely = focusWithoutScrolling;
+function createGlobalListeners() {
+  const listeners = [];
+  function addGlobalListener(type, handler, options) {
+    const target = (options == null ? void 0 : options.isWindow) ? window : document;
+    const listenerOptions = options ? {
+      capture: options.capture,
+      passive: options.passive,
+      once: options.once
+    } : void 0;
+    target.addEventListener(type, handler, listenerOptions);
+    listeners.push({ target, type, handler, options: listenerOptions });
+  }
+  function removeGlobalListener(type, handler, options) {
+    const target = (options == null ? void 0 : options.isWindow) ? window : document;
+    const listenerOptions = options ? {
+      capture: options.capture
+    } : void 0;
+    target.removeEventListener(type, handler, listenerOptions);
+    const index = listeners.findIndex(
+      (l) => {
+        var _a;
+        return l.target === target && l.type === type && l.handler === handler && ((_a = l.options) == null ? void 0 : _a.capture) === (listenerOptions == null ? void 0 : listenerOptions.capture);
+      }
+    );
+    if (index !== -1) {
+      listeners.splice(index, 1);
+    }
+  }
+  function removeAllGlobalListeners() {
+    for (const { target, type, handler, options } of listeners) {
+      target.removeEventListener(type, handler, options);
+    }
+    listeners.length = 0;
+  }
+  onCleanup(removeAllGlobalListeners);
+  return {
+    addGlobalListener,
+    removeGlobalListener,
+    removeAllGlobalListeners
+  };
+}
+function isDisabledValue$2(isDisabled) {
+  if (typeof isDisabled === "function") {
+    return isDisabled();
+  }
+  return isDisabled ?? false;
+}
+function isPressedValue(isPressed) {
+  if (typeof isPressed === "function") {
+    return isPressed();
+  }
+  return isPressed ?? false;
+}
+const LINK_CLICKED = Symbol("linkClicked");
+let pressableCSSInjected = false;
+function injectPressableCSS() {
+  if (pressableCSSInjected || typeof document === "undefined") return;
+  const style = document.createElement("style");
+  style.id = "solidaria-pressable-style";
+  style.textContent = `
+    [data-solidaria-pressable] {
+      touch-action: pan-x pan-y pinch-zoom;
+    }
+  `;
+  document.head.appendChild(style);
+  pressableCSSInjected = true;
+}
+function createPress(props = {}) {
+  const [internalIsPressed, setInternalIsPressed] = createSignal(false);
+  const isPressed = () => {
+    const controlledPressed = isPressedValue(props.isPressed);
+    if (controlledPressed) {
+      return controlledPressed;
+    }
+    return internalIsPressed();
+  };
+  let pressState = {
+    isPressed: false,
+    ignoreEmulatedMouseEvents: false,
+    ignoreClickAfterPress: false,
+    didFirePressStart: false,
+    isTriggeringEvent: false,
+    activePointerId: null,
+    target: null,
+    isOverTarget: false,
+    pointerType: null,
+    userSelect: void 0,
+    metaKeyEvents: null,
+    clickCleanup: null
+  };
+  const { addGlobalListener, removeAllGlobalListeners } = createGlobalListeners();
+  injectPressableCSS();
+  const triggerPressStart = (originalEvent, pointerType) => {
+    if (isDisabledValue$2(props.isDisabled) || pressState.didFirePressStart) {
+      return false;
+    }
+    let shouldStopPropagation = true;
+    pressState.isTriggeringEvent = true;
+    if (props.onPressStart) {
+      const event = createPressEvent("pressstart", pointerType, originalEvent, pressState.target);
+      props.onPressStart(event);
+      shouldStopPropagation = event.shouldStopPropagation;
+    }
+    if (props.onPressChange) {
+      props.onPressChange(true);
+    }
+    pressState.isTriggeringEvent = false;
+    pressState.didFirePressStart = true;
+    setInternalIsPressed(true);
+    return shouldStopPropagation;
+  };
+  const triggerPressEnd = (originalEvent, pointerType, wasPressed = true) => {
+    if (!pressState.didFirePressStart) {
+      return;
+    }
+    pressState.ignoreClickAfterPress = true;
+    pressState.didFirePressStart = false;
+    pressState.isTriggeringEvent = true;
+    if (props.onPressEnd) {
+      const event = createPressEvent("pressend", pointerType, originalEvent, pressState.target);
+      props.onPressEnd(event);
+    }
+    if (props.onPressChange) {
+      props.onPressChange(false);
+    }
+    setInternalIsPressed(false);
+    if (wasPressed && !isDisabledValue$2(props.isDisabled)) {
+      if (props.onPress) {
+        const event = createPressEvent("press", pointerType, originalEvent, pressState.target);
+        props.onPress(event);
+      }
+    }
+    pressState.isTriggeringEvent = false;
+  };
+  const triggerPressUp = (originalEvent, pointerType) => {
+    if (isDisabledValue$2(props.isDisabled)) {
+      return;
+    }
+    if (props.onPressUp) {
+      pressState.isTriggeringEvent = true;
+      const event = createPressEvent("pressup", pointerType, originalEvent, pressState.target);
+      props.onPressUp(event);
+      pressState.isTriggeringEvent = false;
+    }
+  };
+  const cancel = (originalEvent) => {
+    if (!pressState.isPressed) {
+      return;
+    }
+    if (pressState.isOverTarget && pressState.target) {
+      triggerPressEnd(originalEvent, pressState.pointerType ?? "mouse", false);
+    }
+    pressState.isPressed = false;
+    pressState.isOverTarget = false;
+    pressState.activePointerId = null;
+    pressState.pointerType = null;
+    removeAllGlobalListeners();
+    if (pressState.clickCleanup) {
+      pressState.clickCleanup();
+      pressState.clickCleanup = null;
+    }
+    if (!props.allowTextSelectionOnPress) {
+      restoreTextSelection(pressState.target);
+    }
+  };
+  const onPointerDown = (e) => {
+    if (e.button !== 0 || !nodeContains(e.currentTarget, getEventTarget(e))) {
+      return;
+    }
+    if (isVirtualPointerEvent(e)) {
+      pressState.pointerType = "virtual";
+      return;
+    }
+    pressState.pointerType = e.pointerType;
+    if (!pressState.isPressed) {
+      pressState.isPressed = true;
+      pressState.isOverTarget = true;
+      pressState.activePointerId = e.pointerId;
+      pressState.target = e.currentTarget;
+      if (!props.allowTextSelectionOnPress) {
+        disableTextSelection(pressState.target);
+      }
+      const shouldStopPropagation = triggerPressStart(e, pressState.pointerType);
+      if (shouldStopPropagation) {
+        e.stopPropagation();
+      }
+      addGlobalListener("pointerup", onPointerUp);
+      addGlobalListener("pointercancel", onPointerCancel);
+    }
+  };
+  const onMouseDownPointer = (e) => {
+    if (!nodeContains(e.currentTarget, getEventTarget(e))) {
+      return;
+    }
+    if (e.button === 0) {
+      if (props.preventFocusOnPress) {
+        preventFocus(e.currentTarget);
+      }
+      e.stopPropagation();
+    }
+  };
+  const onPointerUp = (e) => {
+    if (e.pointerId !== pressState.activePointerId || !pressState.isPressed || e.button !== 0 || !pressState.target) {
+      return;
+    }
+    const isOverTarget = nodeContains(pressState.target, getEventTarget(e));
+    if (isOverTarget && pressState.pointerType != null && pressState.pointerType !== "virtual") {
+      let clickFired = false;
+      const timeout = setTimeout(() => {
+        if (typeof HTMLElement === "undefined") {
+          return;
+        }
+        if (pressState.isPressed && pressState.target instanceof HTMLElement) {
+          if (clickFired) {
+            cancel(e);
+          } else {
+            pressState.target.focus();
+            pressState.target.click();
+          }
+        }
+      }, 80);
+      const doc = pressState.target.ownerDocument ?? document;
+      const clickListener = () => {
+        clickFired = true;
+      };
+      doc.addEventListener("click", clickListener, true);
+      pressState.clickCleanup = () => {
+        clearTimeout(timeout);
+        doc.removeEventListener("click", clickListener, true);
+      };
+      pressState.isOverTarget = false;
+    } else {
+      cancel(e);
+    }
+  };
+  const onPointerCancel = (e) => {
+    if (e.pointerId === pressState.activePointerId) {
+      cancel(e);
+    }
+  };
+  const onPointerEnter = (e) => {
+    if (e.pointerId === pressState.activePointerId && pressState.target && !pressState.isOverTarget && pressState.pointerType != null) {
+      pressState.isOverTarget = true;
+      triggerPressStart(e, pressState.pointerType);
+    }
+  };
+  const onPointerLeave = (e) => {
+    if (e.pointerId === pressState.activePointerId && pressState.target && pressState.isOverTarget && pressState.pointerType != null) {
+      pressState.isOverTarget = false;
+      triggerPressEnd(e, pressState.pointerType, false);
+      if (props.shouldCancelOnPointerExit) {
+        cancel(e);
+      }
+    }
+  };
+  const onTouchStart = (e) => {
+    if (isDisabledValue$2(props.isDisabled)) {
+      return;
+    }
+    if (pressState.isPressed) {
+      return;
+    }
+    const touch = getTouchFromEvent(e);
+    if (!touch) {
+      return;
+    }
+    pressState.activePointerId = touch.identifier;
+    pressState.ignoreEmulatedMouseEvents = true;
+    pressState.isOverTarget = true;
+    pressState.isPressed = true;
+    pressState.target = e.currentTarget;
+    pressState.pointerType = "touch";
+    if (!props.allowTextSelectionOnPress) {
+      disableTextSelection(pressState.target);
+    }
+    const shouldStopPropagation = triggerPressStart(e, "touch");
+    if (shouldStopPropagation) {
+      e.stopPropagation();
+    }
+    addGlobalListener("scroll", onScroll, { capture: true, isWindow: true });
+  };
+  const onTouchMove = (e) => {
+    if (!pressState.isPressed) {
+      return;
+    }
+    const touch = getTouchById(e, pressState.activePointerId);
+    if (!touch) {
+      return;
+    }
+    const target = pressState.target;
+    const isOverTarget = isPointOverTarget(touch, target);
+    if (isOverTarget !== pressState.isOverTarget) {
+      pressState.isOverTarget = isOverTarget;
+      if (isOverTarget) {
+        triggerPressStart(e, "touch");
+      } else {
+        triggerPressEnd(e, "touch", false);
+        if (props.shouldCancelOnPointerExit) {
+          cancel(e);
+        }
+      }
+    }
+  };
+  const onTouchEnd = (e) => {
+    if (!pressState.isPressed) {
+      return;
+    }
+    const touch = getTouchById(e, pressState.activePointerId);
+    if (!touch) {
+      return;
+    }
+    const target = pressState.target;
+    const isOverTarget = isPointOverTarget(touch, target);
+    if (isOverTarget) {
+      triggerPressUp(e, "touch");
+    }
+    triggerPressEnd(e, "touch", isOverTarget && pressState.isOverTarget);
+    pressState.isPressed = false;
+    pressState.isOverTarget = false;
+    pressState.activePointerId = null;
+    pressState.pointerType = null;
+    removeAllGlobalListeners();
+    if (!props.allowTextSelectionOnPress) {
+      restoreTextSelection(target);
+    }
+  };
+  const onTouchCancel = (e) => {
+    cancel(e);
+  };
+  const onScroll = (e) => {
+    if (pressState.isPressed && nodeContains(e.target, pressState.target)) {
+      cancel(e);
+    }
+  };
+  const onMouseDownFallback = (e) => {
+    if (e.button !== 0) {
+      return;
+    }
+    if (pressState.ignoreEmulatedMouseEvents) {
+      e.stopPropagation();
+      return;
+    }
+    pressState.isPressed = true;
+    pressState.isOverTarget = true;
+    pressState.target = e.currentTarget;
+    pressState.pointerType = isVirtualClick(e) ? "virtual" : "mouse";
+    const shouldStopPropagation = triggerPressStart(e, pressState.pointerType);
+    if (shouldStopPropagation) {
+      e.stopPropagation();
+    }
+    addGlobalListener("mouseup", onMouseUpFallback);
+  };
+  const onMouseUpFallback = (e) => {
+    if (e.button !== 0) {
+      return;
+    }
+    if (!pressState.ignoreEmulatedMouseEvents && e.button === 0 && !pressState.isPressed) {
+      triggerPressUp(e, pressState.pointerType || "mouse");
+    }
+  };
+  const onMouseEnterFallback = (e) => {
+    if (!pressState.isPressed || pressState.ignoreEmulatedMouseEvents) {
+      return;
+    }
+    if (pressState.isPressed && !pressState.ignoreEmulatedMouseEvents && pressState.pointerType != null) {
+      pressState.isOverTarget = true;
+      triggerPressStart(e, pressState.pointerType);
+    }
+  };
+  const onMouseLeaveFallback = (e) => {
+    if (!pressState.isPressed || pressState.ignoreEmulatedMouseEvents) {
+      return;
+    }
+    if (pressState.isPressed && !pressState.ignoreEmulatedMouseEvents && pressState.pointerType != null) {
+      pressState.isOverTarget = false;
+      triggerPressEnd(e, pressState.pointerType, false);
+      if (props.shouldCancelOnPointerExit) {
+        cancel(e);
+      }
+    }
+  };
+  const onKeyDown = (e) => {
+    if (isDisabledValue$2(props.isDisabled)) {
+      return;
+    }
+    if (!isValidKeyboardEvent(e, e.currentTarget)) {
+      if (e.key === "Enter") {
+        e.stopPropagation();
+      }
+      return;
+    }
+    if (e.repeat) {
+      e.preventDefault();
+      return;
+    }
+    pressState.target = e.currentTarget;
+    pressState.isPressed = true;
+    pressState.isOverTarget = true;
+    pressState.pointerType = "keyboard";
+    const shouldStopPropagation = triggerPressStart(e, "keyboard");
+    if (shouldStopPropagation) {
+      e.stopPropagation();
+    }
+    if (shouldPreventDefaultKeyboard(e.currentTarget, e.key)) {
+      e.preventDefault();
+    }
+    if (isMac() && e.metaKey && !e.ctrlKey && !e.altKey) {
+      pressState.metaKeyEvents = pressState.metaKeyEvents || /* @__PURE__ */ new Map();
+      pressState.metaKeyEvents.set(e.key, e);
+    }
+    if (e.key === "Enter") {
+      pressState.ignoreClickAfterPress = true;
+    }
+    addGlobalListener("keyup", onKeyUp, { capture: true });
+  };
+  const onKeyUp = (e) => {
+    var _a, _b;
+    if (!pressState.isPressed || pressState.pointerType !== "keyboard") {
+      return;
+    }
+    if (!isValidKeyboardEvent(e, pressState.target)) {
+      return;
+    }
+    if (isMac() && e.key === "Meta" && ((_a = pressState.metaKeyEvents) == null ? void 0 : _a.size)) {
+      for (const [key, event] of pressState.metaKeyEvents) {
+        (_b = pressState.target) == null ? void 0 : _b.dispatchEvent(
+          new KeyboardEvent("keyup", {
+            key,
+            code: event.code,
+            bubbles: true,
+            cancelable: true
+          })
+        );
+      }
+      pressState.metaKeyEvents.clear();
+      return;
+    }
+    const target = pressState.target;
+    triggerPressUp(e, "keyboard");
+    triggerPressEnd(e, "keyboard", pressState.isOverTarget);
+    pressState.isPressed = false;
+    pressState.pointerType = null;
+    removeAllGlobalListeners();
+    e.preventDefault();
+    if (e.key === " " && isHTMLAnchorLink(target) && !target[LINK_CLICKED]) {
+      target[LINK_CLICKED] = true;
+      openLink(target, e);
+      setTimeout(() => {
+        delete target[LINK_CLICKED];
+      }, 0);
+    }
+    if (e.key === " ") {
+      pressState.ignoreClickAfterPress = true;
+    }
+  };
+  const onClick = (e) => {
+    if (!nodeContains(e.currentTarget, e.target)) {
+      return;
+    }
+    if (e.button === 0 && !pressState.isTriggeringEvent) {
+      if (isDisabledValue$2(props.isDisabled)) {
+        e.preventDefault();
+        return;
+      }
+      if (!pressState.ignoreEmulatedMouseEvents && !pressState.isPressed && (pressState.pointerType === "virtual" || isVirtualClick(e))) {
+        pressState.target = e.currentTarget;
+        triggerPressStart(e, "virtual");
+        triggerPressUp(e, "virtual");
+        triggerPressEnd(e, "virtual", true);
+      } else if (pressState.isPressed && pressState.pointerType !== "keyboard") {
+        const pointerType = pressState.pointerType || e.pointerType || "virtual";
+        triggerPressUp(e, pointerType);
+        triggerPressEnd(e, pointerType, true);
+        pressState.isOverTarget = false;
+        cancel(e);
+      }
+      pressState.ignoreEmulatedMouseEvents = false;
+    }
+  };
+  const onDragStart = (e) => {
+    if (pressState.isPressed) {
+      cancel(e);
+    }
+  };
+  const pressProps = typeof PointerEvent !== "undefined" ? {
+    // Keyboard events
+    onKeyDown,
+    onKeyUp,
+    onClick,
+    onDragStart,
+    // Pointer events (preferred when available)
+    onPointerDown,
+    onPointerEnter,
+    onPointerLeave,
+    // Mouse down only for focus prevention when using pointer events
+    onMouseDown: onMouseDownPointer,
+    // Touch events (always included for ignoreEmulatedMouseEvents handling)
+    onTouchStart,
+    onTouchMove,
+    onTouchEnd,
+    onTouchCancel,
+    // Attribute for CSS touch-action
+    "data-solidaria-pressable": ""
+  } : {
+    // Keyboard events
+    onKeyDown,
+    onKeyUp,
+    onClick,
+    onDragStart,
+    // Mouse events (fallback when PointerEvent not available)
+    onMouseDown: onMouseDownFallback,
+    onMouseEnter: onMouseEnterFallback,
+    onMouseLeave: onMouseLeaveFallback,
+    // Touch events (always included)
+    onTouchStart,
+    onTouchMove,
+    onTouchEnd,
+    onTouchCancel,
+    // Attribute for CSS touch-action
+    "data-solidaria-pressable": ""
+  };
+  onCleanup(() => {
+    removeAllGlobalListeners();
+    if (pressState.clickCleanup) {
+      pressState.clickCleanup();
+      pressState.clickCleanup = null;
+    }
+  });
+  return {
+    isPressed,
+    pressProps
+  };
+}
+function createSyntheticBlurHandler(onBlur) {
+  let isFocused = false;
+  let observer = null;
+  return (_e, target) => {
+    if (target instanceof HTMLButtonElement || target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement || target instanceof HTMLSelectElement) {
+      isFocused = true;
+      const onBlurHandler = (blurEvent) => {
+        isFocused = false;
+        if (target.disabled && onBlur) {
+          onBlur(blurEvent);
+        }
+        if (observer) {
+          observer.disconnect();
+          observer = null;
+        }
+      };
+      target.addEventListener("focusout", onBlurHandler, { once: true });
+      observer = new MutationObserver(() => {
+        if (isFocused && target.disabled) {
+          observer == null ? void 0 : observer.disconnect();
+          const relatedTarget = target === document.activeElement ? null : document.activeElement;
+          target.dispatchEvent(new FocusEvent("blur", { relatedTarget }));
+          target.dispatchEvent(new FocusEvent("focusout", { bubbles: true, relatedTarget }));
+        }
+      });
+      observer.observe(target, { attributes: true, attributeFilter: ["disabled"] });
+      return () => {
+        if (observer) {
+          observer.disconnect();
+          observer = null;
+        }
+      };
+    }
+    return void 0;
+  };
+}
+function createFocus(props = {}) {
+  const { isDisabled, onFocus: onFocusProp, onBlur: onBlurProp, onFocusChange } = props;
+  let cleanupRef;
+  const syntheticBlurHandler = createSyntheticBlurHandler(onBlurProp);
+  onCleanup(() => {
+    if (cleanupRef) {
+      cleanupRef();
+    }
+  });
+  const onBlur = (e) => {
+    if (e.target === e.currentTarget) {
+      if (onBlurProp) {
+        onBlurProp(e);
+      }
+      if (onFocusChange) {
+        onFocusChange(false);
+      }
+    }
+  };
+  const onFocus = (e) => {
+    const ownerDocument = getOwnerDocument(e.target);
+    const activeElement = ownerDocument == null ? void 0 : ownerDocument.activeElement;
+    if (e.target === e.currentTarget && activeElement === getEventTarget(e)) {
+      if (onFocusProp) {
+        onFocusProp(e);
+      }
+      if (onFocusChange) {
+        onFocusChange(true);
+      }
+      cleanupRef = syntheticBlurHandler(e, e.target);
+    }
+  };
+  if (isDisabled) {
+    return {
+      focusProps: {}
+    };
+  }
+  const hasHandlers = onFocusProp || onFocusChange || onBlurProp;
+  return {
+    focusProps: {
+      onFocus: hasHandlers ? onFocus : void 0,
+      onBlur: onBlurProp || onFocusChange ? onBlur : void 0
+    }
+  };
+}
+function createFocusWithin(props = {}) {
+  const { isDisabled, onBlurWithin, onFocusWithin, onFocusWithinChange } = props;
+  let isFocusWithin = false;
+  const { addGlobalListener, removeAllGlobalListeners } = createGlobalListeners();
+  onCleanup(() => {
+    removeAllGlobalListeners();
+  });
+  const onBlur = (e) => {
+    if (!e.currentTarget.contains(e.target)) {
+      return;
+    }
+    if (isFocusWithin && !e.currentTarget.contains(e.relatedTarget)) {
+      isFocusWithin = false;
+      removeAllGlobalListeners();
+      if (onBlurWithin) {
+        onBlurWithin(e);
+      }
+      if (onFocusWithinChange) {
+        onFocusWithinChange(false);
+      }
+    }
+  };
+  const onFocus = (e) => {
+    if (!e.currentTarget.contains(e.target)) {
+      return;
+    }
+    const ownerDocument = getOwnerDocument(e.target);
+    const activeElement = ownerDocument == null ? void 0 : ownerDocument.activeElement;
+    if (!isFocusWithin && activeElement === getEventTarget(e)) {
+      if (onFocusWithin) {
+        onFocusWithin(e);
+      }
+      if (onFocusWithinChange) {
+        onFocusWithinChange(true);
+      }
+      isFocusWithin = true;
+      const currentTarget = e.currentTarget;
+      addGlobalListener(
+        "focus",
+        (focusEvent) => {
+          if (isFocusWithin && !nodeContains(currentTarget, focusEvent.target)) {
+            const window2 = ownerDocument == null ? void 0 : ownerDocument.defaultView;
+            if (window2) {
+              const nativeEvent = new window2.FocusEvent("blur", {
+                relatedTarget: focusEvent.target
+              });
+              setEventTarget(nativeEvent, currentTarget);
+              isFocusWithin = false;
+              removeAllGlobalListeners();
+              if (onBlurWithin) {
+                onBlurWithin(nativeEvent);
+              }
+              if (onFocusWithinChange) {
+                onFocusWithinChange(false);
+              }
+            }
+          }
+        },
+        { capture: true }
+      );
+    }
+  };
+  if (isDisabled) {
+    return {
+      focusWithinProps: {
+        onFocus: void 0,
+        onBlur: void 0
+      }
+    };
+  }
+  return {
+    focusWithinProps: {
+      onFocus,
+      onBlur
+    }
+  };
+}
+function createEventHandler(handler) {
+  if (!handler) {
+    return void 0;
+  }
+  return (e) => {
+    let shouldStopPropagation = true;
+    const event = Object.assign(e, {
+      continuePropagation() {
+        shouldStopPropagation = false;
+      }
+    });
+    handler(event);
+    if (shouldStopPropagation) {
+      e.stopPropagation();
+    }
+  };
+}
+function createKeyboard(props = {}) {
+  if (props.isDisabled) {
+    return {
+      keyboardProps: {}
+    };
+  }
+  return {
+    keyboardProps: {
+      onKeyDown: createEventHandler(props.onKeyDown),
+      onKeyUp: createEventHandler(props.onKeyUp)
+    }
+  };
+}
+const FocusableContext = createContext(null);
+function useFocusableContext(setRef) {
+  const context = useContext(FocusableContext) || {};
+  if (context.ref) {
+    context.ref;
+  }
+  const { ref: _, ...otherProps } = context;
+  return otherProps;
+}
+function isDisabledValue$1(isDisabled) {
+  if (typeof isDisabled === "function") {
+    return isDisabled();
+  }
+  return isDisabled ?? false;
+}
+function createFocusable(props = {}, ref) {
+  let elementRef = null;
+  let autoFocusDone = false;
+  const setRef = (el) => {
+    elementRef = el;
+    ref == null ? void 0 : ref(el);
+  };
+  const { focusProps } = createFocus({
+    isDisabled: isDisabledValue$1(props.isDisabled),
+    onFocus: props.onFocus,
+    onBlur: props.onBlur,
+    onFocusChange: props.onFocusChange
+  });
+  const { keyboardProps } = createKeyboard({
+    isDisabled: isDisabledValue$1(props.isDisabled),
+    onKeyDown: props.onKeyDown,
+    onKeyUp: props.onKeyUp
+  });
+  const interactions = mergeProps(focusProps, keyboardProps);
+  const contextProps = useFocusableContext();
+  const interactionProps = isDisabledValue$1(props.isDisabled) ? {} : contextProps;
+  onMount(() => {
+    if (props.autoFocus && elementRef && !autoFocusDone) {
+      focusSafely(elementRef);
+      autoFocusDone = true;
+    }
+  });
+  let tabIndex = props.excludeFromTabOrder ? -1 : 0;
+  if (isDisabledValue$1(props.isDisabled)) {
+    tabIndex = void 0;
+  }
+  const focusableProps = mergeProps(
+    {
+      ...interactions,
+      tabIndex,
+      ref: setRef
+    },
+    interactionProps
+  );
+  return {
+    focusableProps
+  };
+}
+let currentModality = null;
+let hasSetupGlobalListeners = false;
+let changeHandlers = /* @__PURE__ */ new Set();
+function triggerChangeHandlers(modality) {
+  currentModality = modality;
+  for (const handler of changeHandlers) {
+    handler(modality);
+  }
+}
+function handleKeyboardEvent(e) {
+  if (e.metaKey || e.altKey || e.ctrlKey || e.key === "Control" || e.key === "Shift" || e.key === "Meta") {
+    return;
+  }
+  currentModality = "keyboard";
+  triggerChangeHandlers("keyboard");
+}
+function handlePointerEvent(e) {
+  currentModality = "pointer";
+  if (e.type === "mousedown" || e.type === "pointerdown") {
+    triggerChangeHandlers("pointer");
+  }
+}
+function setupGlobalFocusListeners() {
+  if (typeof document === "undefined" || hasSetupGlobalListeners) {
+    return;
+  }
+  hasSetupGlobalListeners = true;
+  document.addEventListener("keydown", handleKeyboardEvent, true);
+  document.addEventListener("keyup", handleKeyboardEvent, true);
+  document.addEventListener("mousedown", handlePointerEvent, true);
+  document.addEventListener("pointerdown", handlePointerEvent, true);
+}
+function createFocusRing(props = {}) {
+  const { isTextInput = false, autoFocus = false } = props;
+  const [isFocused, setIsFocused] = createSignal(false);
+  const [isFocusVisible, setIsFocusVisible] = createSignal(autoFocus);
+  const [modality, setModality] = createSignal(currentModality);
+  createEffect(() => {
+    setupGlobalFocusListeners();
+    const handler = (newModality) => {
+      setModality(newModality);
+    };
+    changeHandlers.add(handler);
+    onCleanup(() => {
+      changeHandlers.delete(handler);
+    });
+  });
+  createEffect(() => {
+    const focused = isFocused();
+    const mod = modality();
+    if (focused) {
+      setIsFocusVisible(isTextInput || mod === "keyboard");
+    } else {
+      setIsFocusVisible(false);
+    }
+  });
+  const focusResult = createFocus({
+    onFocus: () => setIsFocused(true),
+    onBlur: () => setIsFocused(false)
+  });
+  return {
+    isFocused,
+    isFocusVisible,
+    focusProps: focusResult.focusProps
+  };
+}
+let globalIgnoreEmulatedMouseEvents = false;
+let hoverCount = 0;
+function setGlobalIgnoreEmulatedMouseEvents() {
+  globalIgnoreEmulatedMouseEvents = true;
+  setTimeout(() => {
+    globalIgnoreEmulatedMouseEvents = false;
+  }, 50);
+}
+function handleGlobalPointerEvent(e) {
+  if (e.pointerType === "touch") {
+    setGlobalIgnoreEmulatedMouseEvents();
+  }
+}
+function setupGlobalTouchEvents() {
+  if (typeof document === "undefined") {
+    return () => {
+    };
+  }
+  if (hoverCount === 0) {
+    if (typeof PointerEvent !== "undefined") {
+      document.addEventListener("pointerup", handleGlobalPointerEvent);
+    } else if (process.env.NODE_ENV === "test") {
+      document.addEventListener("touchend", setGlobalIgnoreEmulatedMouseEvents);
+    }
+  }
+  hoverCount++;
+  return () => {
+    hoverCount--;
+    if (hoverCount > 0) {
+      return;
+    }
+    if (typeof PointerEvent !== "undefined") {
+      document.removeEventListener("pointerup", handleGlobalPointerEvent);
+    } else if (process.env.NODE_ENV === "test") {
+      document.removeEventListener("touchend", setGlobalIgnoreEmulatedMouseEvents);
+    }
+  };
+}
+function createHover(props = {}) {
+  const getProps = () => access$1(props);
+  const [isHovered, setIsHovered] = createSignal(false);
+  let state2 = {
+    isHovered: false,
+    ignoreEmulatedMouseEvents: false,
+    pointerType: "",
+    target: null
+  };
+  createEffect(() => {
+    const cleanup = setupGlobalTouchEvents();
+    onCleanup(cleanup);
+  });
+  createEffect(() => {
+    const p = getProps();
+    if (p.isDisabled && state2.isHovered) {
+      triggerHoverEnd(state2.target, state2.pointerType);
+    }
+  });
+  function triggerHoverStart(target, pointerType) {
+    var _a, _b;
+    const p = getProps();
+    state2.pointerType = pointerType;
+    if (p.isDisabled || state2.isHovered) {
+      return;
+    }
+    state2.isHovered = true;
+    state2.target = target;
+    (_a = p.onHoverStart) == null ? void 0 : _a.call(p, {
+      type: "hoverstart",
+      target,
+      pointerType
+    });
+    (_b = p.onHoverChange) == null ? void 0 : _b.call(p, true);
+    setIsHovered(true);
+  }
+  function triggerHoverEnd(target, pointerType) {
+    var _a, _b;
+    const p = getProps();
+    state2.pointerType = "";
+    state2.target = null;
+    if (!state2.isHovered || !target) {
+      return;
+    }
+    state2.isHovered = false;
+    (_a = p.onHoverEnd) == null ? void 0 : _a.call(p, {
+      type: "hoverend",
+      target,
+      pointerType
+    });
+    (_b = p.onHoverChange) == null ? void 0 : _b.call(p, false);
+    setIsHovered(false);
+  }
+  const hoverProps = createMemo(() => {
+    if (typeof PointerEvent !== "undefined") {
+      return {
+        onPointerEnter: (e) => {
+          if (globalIgnoreEmulatedMouseEvents && e.pointerType === "mouse") {
+            return;
+          }
+          if (e.pointerType === "touch") {
+            return;
+          }
+          triggerHoverStart(e.currentTarget, e.pointerType);
+        },
+        onPointerLeave: (e) => {
+          const p = getProps();
+          if (!p.isDisabled && e.currentTarget.contains(e.target)) {
+            triggerHoverEnd(e.currentTarget, e.pointerType);
+          }
+        }
+      };
+    }
+    return {
+      onMouseEnter: (e) => {
+        if (!state2.ignoreEmulatedMouseEvents && !globalIgnoreEmulatedMouseEvents) {
+          triggerHoverStart(e.currentTarget, "mouse");
+        }
+        state2.ignoreEmulatedMouseEvents = false;
+      },
+      onMouseLeave: (e) => {
+        const p = getProps();
+        if (!p.isDisabled && e.currentTarget.contains(e.target)) {
+          triggerHoverEnd(e.currentTarget, "mouse");
+        }
+      }
+    };
+  });
+  return {
+    hoverProps: hoverProps(),
+    isHovered
+  };
+}
+function isDisabledValue(isDisabled) {
+  if (typeof isDisabled === "function") {
+    return isDisabled();
+  }
+  return isDisabled ?? false;
+}
+function createButton(props = {}) {
+  const elementType = props.elementType ?? "button";
+  const { pressProps, isPressed } = createPress({
+    isDisabled: props.isDisabled,
+    onPress: props.onPress,
+    onPressStart: props.onPressStart,
+    onPressEnd: props.onPressEnd,
+    onPressUp: props.onPressUp,
+    onPressChange: props.onPressChange,
+    preventFocusOnPress: props.preventFocusOnPress
+  });
+  const { focusableProps } = createFocusable({
+    isDisabled: props.isDisabled,
+    autoFocus: props.autoFocus,
+    excludeFromTabOrder: props.excludeFromTabOrder
+  });
+  const isNativeButton = elementType === "button" || elementType === "input";
+  const isLink = elementType === "a";
+  const disabled = isDisabledValue(props.isDisabled);
+  let additionalProps = {};
+  if (isNativeButton) {
+    additionalProps = {
+      type: props.type ?? "button",
+      disabled,
+      // Form-related attributes
+      ...props.form && { form: props.form },
+      ...props.formAction && { formAction: props.formAction },
+      ...props.formEncType && { formEncType: props.formEncType },
+      ...props.formMethod && { formMethod: props.formMethod },
+      ...props.formNoValidate && { formNoValidate: props.formNoValidate },
+      ...props.formTarget && { formTarget: props.formTarget },
+      ...props.name && { name: props.name },
+      ...props.value && { value: props.value }
+    };
+  } else {
+    additionalProps = {
+      role: "button",
+      tabIndex: disabled ? void 0 : 0,
+      "aria-disabled": disabled ? true : void 0
+    };
+    if (isLink) {
+      additionalProps.href = props.href;
+      additionalProps.target = props.target;
+      additionalProps.rel = props.rel;
+    }
+  }
+  const ariaProps = {};
+  if (props["aria-pressed"] !== void 0) {
+    ariaProps["aria-pressed"] = props["aria-pressed"];
+  }
+  if (props["aria-haspopup"] !== void 0) {
+    ariaProps["aria-haspopup"] = props["aria-haspopup"];
+  }
+  if (props["aria-expanded"] !== void 0) {
+    ariaProps["aria-expanded"] = props["aria-expanded"];
+  }
+  if (props["aria-label"]) {
+    ariaProps["aria-label"] = props["aria-label"];
+  }
+  if (props["aria-labelledby"]) {
+    ariaProps["aria-labelledby"] = props["aria-labelledby"];
+  }
+  if (props["aria-describedby"]) {
+    ariaProps["aria-describedby"] = props["aria-describedby"];
+  }
+  if (props["aria-controls"]) {
+    ariaProps["aria-controls"] = props["aria-controls"];
+  }
+  if (props["aria-current"] !== void 0) {
+    ariaProps["aria-current"] = props["aria-current"];
+  }
+  const buttonProps = mergeProps(
+    filterDOMProps(props, { labelable: true }),
+    additionalProps,
+    ariaProps,
+    focusableProps,
+    pressProps
+  );
+  return {
+    buttonProps,
+    isPressed
+  };
+}
+function getSelectedValue(isSelected) {
+  if (typeof isSelected === "function") {
+    return isSelected();
+  }
+  return isSelected ?? false;
+}
+function createToggleButton(props = {}) {
+  const isControlled = props.isSelected !== void 0;
+  const [uncontrolledSelected, setUncontrolledSelected] = createSignal(
+    props.defaultSelected ?? false
+  );
+  const isSelected = () => {
+    if (isControlled) {
+      return getSelectedValue(props.isSelected);
+    }
+    return uncontrolledSelected();
+  };
+  const toggleSelection = () => {
+    var _a;
+    const newValue = !isSelected();
+    if (!isControlled) {
+      setUncontrolledSelected(newValue);
+    }
+    (_a = props.onChange) == null ? void 0 : _a.call(props, newValue);
+  };
+  const onPress = (e) => {
+    var _a;
+    toggleSelection();
+    (_a = props.onPress) == null ? void 0 : _a.call(props, e);
+  };
+  const { buttonProps: baseButtonProps, isPressed } = createButton(
+    mergeProps(props, {
+      onPress
+    })
+  );
+  const buttonProps = {
+    ...baseButtonProps,
+    get "aria-pressed"() {
+      return isSelected();
+    }
+  };
+  return {
+    buttonProps,
+    isPressed,
+    isSelected
+  };
+}
+function access(value) {
+  return typeof value === "function" ? value() : value;
+}
+function createToggleState(props = {}) {
+  const getProps = () => access(props);
+  const initialProps = getProps();
+  const initialSelected = initialProps.isSelected ?? initialProps.defaultSelected ?? false;
+  const [internalSelected, setInternalSelected] = createSignal(initialSelected);
+  const isControlled = () => getProps().isSelected !== void 0;
+  const isSelected = () => {
+    const p = getProps();
+    return isControlled() ? p.isSelected ?? false : internalSelected();
+  };
+  function setSelected(value) {
+    var _a;
+    const p = getProps();
+    if (p.isReadOnly) {
+      return;
+    }
+    if (!isControlled()) {
+      setInternalSelected(value);
+    }
+    (_a = p.onChange) == null ? void 0 : _a.call(p, value);
+  }
+  function toggle() {
+    const p = getProps();
+    if (p.isReadOnly) {
+      return;
+    }
+    setSelected(!isSelected());
+  }
+  return {
+    isSelected,
+    defaultSelected: initialProps.defaultSelected ?? initialSelected,
+    setSelected,
+    toggle
+  };
+}
+function createCheckboxGroupState(props = {}) {
+  const getProps = () => access(props);
+  const initialProps = getProps();
+  const initialValue = initialProps.value ?? initialProps.defaultValue ?? [];
+  const [internalValue, setInternalValue] = createSignal(initialValue);
+  const isControlled = () => getProps().value !== void 0;
+  const value = () => {
+    const p = getProps();
+    return isControlled() ? p.value ?? [] : internalValue();
+  };
+  const isRequired = () => {
+    const p = getProps();
+    return !!p.isRequired && value().length === 0;
+  };
+  const isInvalid = () => {
+    return getProps().isInvalid ?? false;
+  };
+  function setValue(newValue) {
+    var _a;
+    const p = getProps();
+    if (p.isReadOnly || p.isDisabled) {
+      return;
+    }
+    if (!isControlled()) {
+      setInternalValue(newValue);
+    }
+    (_a = p.onChange) == null ? void 0 : _a.call(p, newValue);
+  }
+  function isSelected(checkValue) {
+    return value().includes(checkValue);
+  }
+  function addValue(addVal) {
+    const p = getProps();
+    if (p.isReadOnly || p.isDisabled) {
+      return;
+    }
+    const current = value();
+    if (!current.includes(addVal)) {
+      setValue([...current, addVal]);
+    }
+  }
+  function removeValue(removeVal) {
+    const p = getProps();
+    if (p.isReadOnly || p.isDisabled) {
+      return;
+    }
+    const current = value();
+    if (current.includes(removeVal)) {
+      setValue(current.filter((v) => v !== removeVal));
+    }
+  }
+  function toggleValue(toggleVal) {
+    const p = getProps();
+    if (p.isReadOnly || p.isDisabled) {
+      return;
+    }
+    const current = value();
+    if (current.includes(toggleVal)) {
+      setValue(current.filter((v) => v !== toggleVal));
+    } else {
+      setValue([...current, toggleVal]);
+    }
+  }
+  return {
+    value,
+    defaultValue: initialProps.defaultValue ?? initialValue,
+    get isDisabled() {
+      return getProps().isDisabled ?? false;
+    },
+    get isReadOnly() {
+      return getProps().isReadOnly ?? false;
+    },
+    get isInvalid() {
+      return isInvalid();
+    },
+    isRequired,
+    isSelected,
+    setValue,
+    addValue,
+    removeValue,
+    toggleValue
+  };
+}
+function createId$1(defaultId) {
+  return `solid-stately-${createUniqueId()}`;
+}
+const radioGroupSyncVersion = /* @__PURE__ */ new WeakMap();
+function createRadioGroupState(props = {}) {
+  const getProps = () => access(props);
+  const initialProps = untrack(() => getProps());
+  const name = initialProps.name || `radio-group-${createId$1()}`;
+  const [internalValue, setInternalValue] = createSignal(
+    initialProps.defaultValue ?? null
+  );
+  const [lastFocusedValue, setLastFocusedValueInternal] = createSignal(null);
+  const [syncVersion, setSyncVersion] = createSignal(0);
+  const isControlled = () => getProps().value !== void 0;
+  const selectedValue = () => {
+    const p = getProps();
+    if (p.value !== void 0) {
+      return p.value ?? null;
+    }
+    return internalValue();
+  };
+  const isInvalid = () => {
+    return getProps().isInvalid ?? false;
+  };
+  function setSelectedValue(value) {
+    var _a;
+    const p = getProps();
+    if (p.isReadOnly || p.isDisabled) {
+      return;
+    }
+    setSyncVersion((v) => v + 1);
+    if (!isControlled()) {
+      setInternalValue(value);
+    }
+    if (value != null) {
+      (_a = p.onChange) == null ? void 0 : _a.call(p, value);
+    }
+  }
+  function setLastFocusedValue(value) {
+    setLastFocusedValueInternal(value);
+  }
+  const state2 = {
+    name,
+    selectedValue,
+    defaultSelectedValue: initialProps.defaultValue ?? null,
+    setSelectedValue,
+    lastFocusedValue,
+    setLastFocusedValue,
+    get isDisabled() {
+      return getProps().isDisabled ?? false;
+    },
+    get isReadOnly() {
+      return getProps().isReadOnly ?? false;
+    },
+    get isRequired() {
+      return getProps().isRequired ?? false;
+    },
+    get isInvalid() {
+      return isInvalid();
+    }
+  };
+  radioGroupSyncVersion.set(state2, syncVersion);
+  return state2;
+}
+function createToggle(props, state2, ref) {
+  const getProps = () => access$1(props);
+  const isDisabled = () => getProps().isDisabled ?? false;
+  const isReadOnly = () => getProps().isReadOnly ?? false;
+  const isInvalid = () => {
+    return getProps().isInvalid ?? false;
+  };
+  const { pressProps, isPressed } = createPress({
+    get onPressStart() {
+      return getProps().onPressStart;
+    },
+    get onPressEnd() {
+      return getProps().onPressEnd;
+    },
+    get onPressChange() {
+      return getProps().onPressChange;
+    },
+    get onPress() {
+      return getProps().onPress;
+    },
+    get onPressUp() {
+      return getProps().onPressUp;
+    },
+    get isDisabled() {
+      return isDisabled();
+    }
+  });
+  const { pressProps: labelPressProps, isPressed: isLabelPressed } = createPress({
+    get onPressStart() {
+      return getProps().onPressStart;
+    },
+    get onPressEnd() {
+      return getProps().onPressEnd;
+    },
+    get onPressChange() {
+      return getProps().onPressChange;
+    },
+    get onPressUp() {
+      return getProps().onPressUp;
+    },
+    onPress(e) {
+      var _a, _b, _c;
+      (_b = (_a = getProps()).onPress) == null ? void 0 : _b.call(_a, e);
+      state2.toggle();
+      (_c = ref()) == null ? void 0 : _c.focus();
+    },
+    get isDisabled() {
+      return isDisabled() || isReadOnly();
+    }
+  });
+  const { focusableProps } = createFocusable({
+    get isDisabled() {
+      return isDisabled();
+    },
+    get autoFocus() {
+      return getProps().autoFocus;
+    },
+    get onFocus() {
+      return getProps().onFocus;
+    },
+    get onBlur() {
+      return getProps().onBlur;
+    },
+    get onFocusChange() {
+      return getProps().onFocusChange;
+    },
+    get onKeyDown() {
+      return getProps().onKeyDown;
+    },
+    get onKeyUp() {
+      return getProps().onKeyUp;
+    },
+    get excludeFromTabOrder() {
+      return getProps().excludeFromTabOrder;
+    }
+  }, ref);
+  const interactions = mergeProps(pressProps, focusableProps);
+  const domProps = () => filterDOMProps(getProps(), { labelable: true });
+  const onChange = (e) => {
+    e.stopPropagation();
+    if (isReadOnly()) {
+      e.currentTarget.checked = state2.isSelected();
+      return;
+    }
+    state2.setSelected(e.currentTarget.checked);
+  };
+  createEffect(() => {
+    const p = getProps();
+    const hasChildren = p.children != null;
+    const hasAriaLabel = p["aria-label"] != null || p["aria-labelledby"] != null;
+    if (!hasChildren && !hasAriaLabel && process.env.NODE_ENV !== "production") {
+      console.warn("If you do not provide children, you must specify an aria-label for accessibility");
+    }
+  });
+  const combinedIsPressed = () => isPressed() || isLabelPressed();
+  return {
+    labelProps: mergeProps(labelPressProps, {
+      onClick: (e) => e.preventDefault()
+    }),
+    get inputProps() {
+      const p = getProps();
+      return mergeProps(domProps(), {
+        "aria-invalid": isInvalid() || void 0,
+        "aria-errormessage": p["aria-errormessage"],
+        "aria-controls": p["aria-controls"],
+        "aria-readonly": isReadOnly() || void 0,
+        onChange,
+        disabled: isDisabled(),
+        ...p.value == null ? {} : { value: p.value },
+        name: p.name,
+        form: p.form,
+        type: "checkbox",
+        ...interactions,
+        // Stop click propagation to prevent labelProps.onClick from calling preventDefault
+        // which would prevent the checkbox from toggling in JSDOM/testing-library environments
+        onClick: (e) => e.stopPropagation()
+      });
+    },
+    isSelected: state2.isSelected,
+    isPressed: combinedIsPressed,
+    isDisabled: isDisabled(),
+    isReadOnly: isReadOnly(),
+    isInvalid: isInvalid()
+  };
+}
+function createCheckbox(props, state2, inputRef) {
+  const getProps = () => access$1(props);
+  const toggleResult = createToggle(props, state2, inputRef);
+  const {
+    labelProps: baseLabelProps,
+    isSelected,
+    isPressed,
+    isDisabled,
+    isReadOnly,
+    isInvalid
+  } = toggleResult;
+  createEffect(() => {
+    const input = inputRef();
+    const isIndeterminate = getProps().isIndeterminate;
+    if (input) {
+      input.indeterminate = !!isIndeterminate;
+    }
+  });
+  const { pressProps } = createPress({
+    get isDisabled() {
+      return isDisabled || isReadOnly;
+    },
+    onPress() {
+    }
+  });
+  return {
+    labelProps: mergeProps(
+      baseLabelProps,
+      pressProps,
+      {
+        // Prevent label from being focused when mouse down on it.
+        // Note, this does not prevent the input from being focused in the `click` event.
+        onMouseDown: (e) => e.preventDefault()
+      }
+    ),
+    get inputProps() {
+      const p = getProps();
+      const { isRequired, validationBehavior = "aria" } = p;
+      return mergeProps(toggleResult.inputProps, {
+        checked: isSelected(),
+        "aria-required": isRequired && validationBehavior === "aria" || void 0,
+        required: isRequired && validationBehavior === "native"
+      });
+    },
+    isSelected,
+    isPressed,
+    isDisabled,
+    isReadOnly,
+    isInvalid
+  };
+}
+function createIsSSR() {
+  return isServer;
+}
+function createId(defaultId) {
+  if (defaultId) {
+    return defaultId;
+  }
+  return `solidaria-${createUniqueId()}`;
+}
+const canUseDOM = !isServer;
+function createLabels(props, defaultLabel) {
+  let {
+    id,
+    "aria-label": label,
+    "aria-labelledby": labelledBy
+  } = props;
+  id = createId(id);
+  if (labelledBy && label) {
+    const ids = /* @__PURE__ */ new Set([id, ...labelledBy.trim().split(/\s+/)]);
+    labelledBy = [...ids].join(" ");
+  } else if (labelledBy) {
+    labelledBy = labelledBy.trim().split(/\s+/).join(" ");
+  }
+  if (!label && !labelledBy && defaultLabel) {
+    label = defaultLabel;
+  }
+  return {
+    id,
+    "aria-label": label,
+    "aria-labelledby": labelledBy
+  };
+}
+function createLabel(props) {
+  const getProps = () => access$1(props);
+  const id = createId(getProps().id);
+  const labelId = createId();
+  const getLabelProps = () => {
+    const { label, labelElementType = "label" } = getProps();
+    if (!label) {
+      return {};
+    }
+    return {
+      id: labelId,
+      ...labelElementType === "label" ? { for: id } : {}
+    };
+  };
+  const getFieldProps = () => {
+    const {
+      label,
+      "aria-labelledby": ariaLabelledby,
+      "aria-label": ariaLabel
+    } = getProps();
+    let labelledBy = ariaLabelledby;
+    if (label) {
+      labelledBy = ariaLabelledby ? `${labelId} ${ariaLabelledby}` : labelId;
+    } else if (!ariaLabelledby && !ariaLabel && process.env.NODE_ENV !== "production") {
+      console.warn(
+        "If you do not provide a visible label, you must specify an aria-label or aria-labelledby attribute for accessibility"
+      );
+    }
+    return createLabels({
+      id,
+      "aria-label": ariaLabel,
+      "aria-labelledby": labelledBy
+    });
+  };
+  return {
+    get labelProps() {
+      return getLabelProps();
+    },
+    get fieldProps() {
+      return getFieldProps();
+    }
+  };
+}
+function createField(props) {
+  const getProps = () => access$1(props);
+  const { labelProps, fieldProps: baseLabelFieldProps } = createLabel(props);
+  const descriptionId = createId();
+  const errorMessageId = createId();
+  const getDescriptionProps = () => {
+    const { description, errorMessage, isInvalid } = getProps();
+    if (!description && !errorMessage && !isInvalid) {
+      return {};
+    }
+    return {
+      id: descriptionId
+    };
+  };
+  const getErrorMessageProps = () => {
+    const { errorMessage, isInvalid } = getProps();
+    if (!errorMessage && !isInvalid) {
+      return {};
+    }
+    return {
+      id: errorMessageId
+    };
+  };
+  const getFieldProps = () => {
+    const { description, errorMessage, isInvalid } = getProps();
+    const describedByIds = [];
+    if (description) {
+      describedByIds.push(descriptionId);
+    }
+    if (isInvalid && errorMessage) {
+      describedByIds.push(errorMessageId);
+    }
+    const existingDescribedBy = getProps()["aria-describedby"];
+    if (existingDescribedBy) {
+      describedByIds.push(existingDescribedBy);
+    }
+    const ariaDescribedBy = describedByIds.length > 0 ? describedByIds.join(" ") : void 0;
+    return mergeProps(baseLabelFieldProps, {
+      "aria-describedby": ariaDescribedBy
+    });
+  };
+  return {
+    get labelProps() {
+      return labelProps;
+    },
+    get fieldProps() {
+      return getFieldProps();
+    },
+    get descriptionProps() {
+      return getDescriptionProps();
+    },
+    get errorMessageProps() {
+      return getErrorMessageProps();
+    }
+  };
+}
+const checkboxGroupData = /* @__PURE__ */ new WeakMap();
+function createCheckboxGroup(props, state2) {
+  const getProps = () => access$1(props);
+  const isInvalid = () => state2.isInvalid;
+  const { labelProps, fieldProps, descriptionProps, errorMessageProps } = createField({
+    get label() {
+      return getProps().label;
+    },
+    get "aria-label"() {
+      return getProps()["aria-label"];
+    },
+    get "aria-labelledby"() {
+      return getProps()["aria-labelledby"];
+    },
+    get "aria-describedby"() {
+      return getProps()["aria-describedby"];
+    },
+    get "aria-details"() {
+      return getProps()["aria-details"];
+    },
+    get description() {
+      return getProps().description;
+    },
+    get errorMessage() {
+      return getProps().errorMessage ?? (isInvalid() ? "Invalid selection" : void 0);
+    },
+    get isInvalid() {
+      return isInvalid();
+    },
+    // Checkbox group is not an HTML input element so it
+    // shouldn't be labeled by a <label> element.
+    labelElementType: "span"
+  });
+  checkboxGroupData.set(state2, {
+    name: getProps().name,
+    form: getProps().form,
+    descriptionId: descriptionProps.id,
+    errorMessageId: errorMessageProps.id,
+    validationBehavior: "aria"
+  });
+  const domProps = () => filterDOMProps(getProps(), { labelable: true });
+  const { focusWithinProps } = createFocusWithin({
+    get onBlurWithin() {
+      return getProps().onBlur;
+    },
+    get onFocusWithin() {
+      return getProps().onFocus;
+    },
+    get onFocusWithinChange() {
+      return getProps().onFocusChange;
+    }
+  });
+  return {
+    get groupProps() {
+      return mergeProps(domProps(), {
+        role: "group",
+        "aria-disabled": state2.isDisabled || void 0,
+        ...fieldProps,
+        ...focusWithinProps
+      });
+    },
+    get labelProps() {
+      return labelProps;
+    },
+    get descriptionProps() {
+      return descriptionProps;
+    },
+    get errorMessageProps() {
+      return errorMessageProps;
+    },
+    get isInvalid() {
+      return isInvalid();
+    }
+  };
+}
+function createCheckboxGroupItem(props, state2, inputRef) {
+  const getProps = () => access$1(props);
+  const toggleState = {
+    isSelected: () => state2.isSelected(getProps().value),
+    defaultSelected: state2.defaultValue.includes(getProps().value),
+    setSelected(isSelected) {
+      var _a, _b;
+      const value = getProps().value;
+      if (isSelected) {
+        state2.addValue(value);
+      } else {
+        state2.removeValue(value);
+      }
+      (_b = (_a = getProps()).onChange) == null ? void 0 : _b.call(_a, isSelected);
+    },
+    toggle() {
+      state2.toggleValue(getProps().value);
+    }
+  };
+  const getGroupData = () => checkboxGroupData.get(state2);
+  const checkboxProps = () => {
+    const p = getProps();
+    const groupData = getGroupData();
+    return {
+      ...p,
+      isReadOnly: p.isReadOnly ?? state2.isReadOnly,
+      isDisabled: p.isDisabled ?? state2.isDisabled,
+      name: p.name ?? (groupData == null ? void 0 : groupData.name),
+      form: p.form ?? (groupData == null ? void 0 : groupData.form),
+      isRequired: p.isRequired ?? state2.isRequired(),
+      validationBehavior: p.validationBehavior ?? (groupData == null ? void 0 : groupData.validationBehavior) ?? "aria"
+    };
+  };
+  const result = createCheckbox(checkboxProps, toggleState, inputRef);
+  return {
+    ...result,
+    get inputProps() {
+      const baseInputProps = result.inputProps;
+      const groupData = getGroupData();
+      const describedByIds = [];
+      const propsDescribedBy = getProps()["aria-describedby"];
+      if (propsDescribedBy) {
+        describedByIds.push(propsDescribedBy);
+      }
+      if (state2.isInvalid && (groupData == null ? void 0 : groupData.errorMessageId)) {
+        describedByIds.push(groupData.errorMessageId);
+      }
+      if (groupData == null ? void 0 : groupData.descriptionId) {
+        describedByIds.push(groupData.descriptionId);
+      }
+      const ariaDescribedBy = describedByIds.length > 0 ? describedByIds.join(" ") : void 0;
+      return {
+        ...baseInputProps,
+        "aria-describedby": ariaDescribedBy
+      };
+    }
+  };
+}
+const radioGroupData = /* @__PURE__ */ new WeakMap();
+function createRadioGroup(props, state2) {
+  const getProps = () => access$1(props);
+  const orientation = () => getProps().orientation ?? "vertical";
+  const isReadOnly = () => getProps().isReadOnly ?? false;
+  const isRequired = () => getProps().isRequired ?? false;
+  const isDisabled = () => getProps().isDisabled ?? false;
+  const validationBehavior = () => getProps().validationBehavior ?? "aria";
+  const { labelProps, fieldProps, descriptionProps, errorMessageProps } = createField({
+    get label() {
+      return getProps().label;
+    },
+    get description() {
+      return getProps().description;
+    },
+    get errorMessage() {
+      return getProps().errorMessage;
+    },
+    get isInvalid() {
+      return state2.isInvalid;
+    },
+    // Radio group is not an HTML input element so it
+    // shouldn't be labeled by a <label> element.
+    labelElementType: "span"
+  });
+  const { focusWithinProps } = createFocusWithin({
+    onBlurWithin(e) {
+      var _a, _b;
+      (_b = (_a = getProps()).onBlur) == null ? void 0 : _b.call(_a, e);
+      if (!state2.selectedValue()) {
+        state2.setLastFocusedValue(null);
+      }
+    },
+    onFocusWithin: (e) => {
+      var _a, _b;
+      return (_b = (_a = getProps()).onFocus) == null ? void 0 : _b.call(_a, e);
+    },
+    onFocusWithinChange: (isFocused) => {
+      var _a, _b;
+      return (_b = (_a = getProps()).onFocusChange) == null ? void 0 : _b.call(_a, isFocused);
+    }
+  });
+  const domProps = () => filterDOMProps(getProps(), { labelable: true });
+  const groupName = getProps().name ?? createId();
+  radioGroupData.set(state2, {
+    name: groupName,
+    form: getProps().form,
+    descriptionId: descriptionProps.id,
+    errorMessageId: errorMessageProps.id,
+    validationBehavior: validationBehavior()
+  });
+  const onKeyDown = (_e) => {
+  };
+  return {
+    get radioGroupProps() {
+      return mergeProps(
+        domProps(),
+        focusWithinProps,
+        {
+          role: "radiogroup",
+          onKeyDown,
+          "aria-invalid": state2.isInvalid || void 0,
+          "aria-errormessage": getProps()["aria-errormessage"],
+          "aria-readonly": isReadOnly() || void 0,
+          "aria-required": isRequired() || void 0,
+          "aria-disabled": isDisabled() || void 0,
+          "aria-orientation": orientation(),
+          ...fieldProps
+        }
+      );
+    },
+    labelProps,
+    descriptionProps,
+    errorMessageProps,
+    get isInvalid() {
+      return state2.isInvalid;
+    },
+    get validationErrors() {
+      return [];
+    },
+    get validationDetails() {
+      return {};
+    }
+  };
+}
+function createRadio(props, state2, ref) {
+  const getProps = () => access$1(props);
+  const isDisabled = () => getProps().isDisabled || state2.isDisabled;
+  const value = () => getProps().value;
+  const isSelected = () => {
+    const selected = state2.selectedValue();
+    const v = value();
+    return selected === v;
+  };
+  createEffect(() => {
+    const p = getProps();
+    const hasChildren = p.children != null;
+    const hasAriaLabel = p["aria-label"] != null || p["aria-labelledby"] != null;
+    if (!hasChildren && !hasAriaLabel && process.env.NODE_ENV !== "production") {
+      console.warn("If you do not provide children, you must specify an aria-label for accessibility");
+    }
+  });
+  createEffect(() => {
+    const inputEl = ref();
+    if (!inputEl) return;
+    const syncVersion = radioGroupSyncVersion.get(state2);
+    syncVersion == null ? void 0 : syncVersion();
+    const shouldBeChecked = isSelected();
+    if (inputEl.checked !== shouldBeChecked) {
+      inputEl.checked = shouldBeChecked;
+    }
+  });
+  const onChange = (e) => {
+    e.stopPropagation();
+    const target = e.target;
+    if (isDisabled()) {
+      target.checked = isSelected();
+      return;
+    }
+    state2.setSelectedValue(value());
+    target.focus();
+    target.checked = isSelected();
+  };
+  const { pressProps, isPressed } = createPress({
+    get onPressStart() {
+      return getProps().onPressStart;
+    },
+    get onPressEnd() {
+      return getProps().onPressEnd;
+    },
+    get onPressChange() {
+      return getProps().onPressChange;
+    },
+    get onPress() {
+      return getProps().onPress;
+    },
+    get onPressUp() {
+      return getProps().onPressUp;
+    },
+    get isDisabled() {
+      return isDisabled();
+    }
+  });
+  const { pressProps: labelPressProps, isPressed: isLabelPressed } = createPress({
+    get onPressStart() {
+      return getProps().onPressStart;
+    },
+    get onPressEnd() {
+      return getProps().onPressEnd;
+    },
+    get onPressChange() {
+      return getProps().onPressChange;
+    },
+    get onPressUp() {
+      return getProps().onPressUp;
+    },
+    onPress(e) {
+      var _a, _b, _c;
+      (_b = (_a = getProps()).onPress) == null ? void 0 : _b.call(_a, e);
+      state2.setSelectedValue(value());
+      (_c = ref()) == null ? void 0 : _c.focus();
+    },
+    get isDisabled() {
+      return isDisabled();
+    }
+  });
+  const { focusableProps } = createFocusable({
+    get isDisabled() {
+      return isDisabled();
+    },
+    get autoFocus() {
+      return getProps().autoFocus;
+    },
+    onFocus(e) {
+      var _a, _b;
+      (_b = (_a = getProps()).onFocus) == null ? void 0 : _b.call(_a, e);
+      state2.setLastFocusedValue(value());
+    },
+    get onBlur() {
+      return getProps().onBlur;
+    },
+    get onFocusChange() {
+      return getProps().onFocusChange;
+    },
+    get onKeyDown() {
+      return getProps().onKeyDown;
+    },
+    get onKeyUp() {
+      return getProps().onKeyUp;
+    }
+  }, ref);
+  const interactions = mergeProps(pressProps, focusableProps);
+  const domProps = () => filterDOMProps(getProps(), { labelable: true });
+  const getTabIndex = () => {
+    if (isDisabled()) {
+      return void 0;
+    }
+    const selected = state2.selectedValue();
+    const lastFocused = state2.lastFocusedValue();
+    const currentValue = value();
+    if (selected != null) {
+      if (selected === currentValue) {
+        return 0;
+      }
+      return -1;
+    } else {
+      if (lastFocused === currentValue || lastFocused == null) {
+        return 0;
+      }
+      return -1;
+    }
+  };
+  const getGroupData = () => radioGroupData.get(state2);
+  const combinedIsPressed = () => isPressed() || isLabelPressed();
+  return {
+    labelProps: mergeProps(labelPressProps, {
+      onClick: (e) => e.preventDefault(),
+      onMouseDown: (e) => e.preventDefault()
+    }),
+    get inputProps() {
+      const p = getProps();
+      const groupData = getGroupData();
+      const describedByIds = [];
+      if (p["aria-describedby"]) {
+        describedByIds.push(p["aria-describedby"]);
+      }
+      if (state2.isInvalid && (groupData == null ? void 0 : groupData.errorMessageId)) {
+        describedByIds.push(groupData.errorMessageId);
+      }
+      if (groupData == null ? void 0 : groupData.descriptionId) {
+        describedByIds.push(groupData.descriptionId);
+      }
+      const ariaDescribedBy = describedByIds.length > 0 ? describedByIds.join(" ") : void 0;
+      return mergeProps(domProps(), interactions, {
+        type: "radio",
+        name: groupData == null ? void 0 : groupData.name,
+        form: groupData == null ? void 0 : groupData.form,
+        tabIndex: getTabIndex(),
+        disabled: isDisabled(),
+        required: state2.isRequired && (groupData == null ? void 0 : groupData.validationBehavior) === "native",
+        checked: isSelected(),
+        value: value(),
+        onChange,
+        "aria-describedby": ariaDescribedBy
+      });
+    },
+    isDisabled: isDisabled(),
+    isSelected,
+    isPressed: combinedIsPressed
+  };
+}
+function createSwitch(props, state2, ref) {
+  const toggle = createToggle(props, state2, ref);
+  return {
+    labelProps: toggle.labelProps,
+    get inputProps() {
+      const baseProps = toggle.inputProps;
+      return {
+        ...baseProps,
+        role: "switch",
+        checked: toggle.isSelected()
+      };
+    },
+    isSelected: toggle.isSelected,
+    isPressed: toggle.isPressed,
+    isDisabled: toggle.isDisabled,
+    isReadOnly: toggle.isReadOnly
+  };
+}
+function createLink(props = {}) {
+  const getProps = () => access$1(props);
+  const isDisabled = () => getProps().isDisabled ?? false;
+  const elementType = () => getProps().elementType ?? "a";
+  const { pressProps, isPressed } = createPress({
+    get isDisabled() {
+      return isDisabled();
+    },
+    get onPress() {
+      return getProps().onPress;
+    },
+    get onPressStart() {
+      return getProps().onPressStart;
+    },
+    get onPressEnd() {
+      return getProps().onPressEnd;
+    }
+  });
+  const { focusableProps } = createFocusable({
+    get isDisabled() {
+      return isDisabled();
+    },
+    get autoFocus() {
+      return getProps().autoFocus;
+    },
+    get onFocus() {
+      return getProps().onFocus;
+    },
+    get onBlur() {
+      return getProps().onBlur;
+    },
+    get onFocusChange() {
+      return getProps().onFocusChange;
+    },
+    get onKeyDown() {
+      return getProps().onKeyDown;
+    },
+    get onKeyUp() {
+      return getProps().onKeyUp;
+    }
+  });
+  const getLinkProps = () => {
+    const p = getProps();
+    const elType = elementType();
+    const disabled = isDisabled();
+    let baseProps = {};
+    if (elType !== "a") {
+      baseProps = {
+        role: "link",
+        tabIndex: disabled ? void 0 : 0
+      };
+    }
+    if (elType === "a") {
+      if (p.href) baseProps.href = p.href;
+      if (p.target) baseProps.target = p.target;
+      if (p.rel) baseProps.rel = p.rel;
+    }
+    const ariaProps = {
+      "aria-disabled": disabled || void 0
+    };
+    if (p["aria-current"] !== void 0) {
+      ariaProps["aria-current"] = p["aria-current"];
+    }
+    if (p["aria-label"]) {
+      ariaProps["aria-label"] = p["aria-label"];
+    }
+    if (p["aria-labelledby"]) {
+      ariaProps["aria-labelledby"] = p["aria-labelledby"];
+    }
+    if (p["aria-describedby"]) {
+      ariaProps["aria-describedby"] = p["aria-describedby"];
+    }
+    const onClick = (e) => {
+      var _a;
+      if (disabled) {
+        e.preventDefault();
+        return;
+      }
+      (_a = p.onClick) == null ? void 0 : _a.call(p, e);
+    };
+    return mergeProps(
+      filterDOMProps(p, { labelable: true }),
+      baseProps,
+      ariaProps,
+      focusableProps,
+      pressProps,
+      { onClick }
+    );
+  };
+  return {
+    get linkProps() {
+      return getLinkProps();
+    },
+    isPressed
+  };
+}
+function createTextField(props, ref) {
+  const getProps = () => access$1(props);
+  const { labelProps, fieldProps, descriptionProps, errorMessageProps } = createField(props);
+  const { focusableProps } = createFocusable(
+    {
+      get isDisabled() {
+        return getProps().isDisabled;
+      },
+      get autoFocus() {
+        return getProps().autoFocus;
+      },
+      onFocus: getProps().onFocus,
+      onBlur: getProps().onBlur,
+      onFocusChange: getProps().onFocusChange,
+      onKeyDown: getProps().onKeyDown,
+      onKeyUp: getProps().onKeyUp
+    },
+    ref
+  );
+  const getDomProps = () => filterDOMProps(getProps(), { labelable: true });
+  const getInputProps = () => {
+    const p = getProps();
+    const isInvalid = p.isInvalid ?? false;
+    const isTextarea = p.inputElementType === "textarea";
+    return mergeProps(
+      getDomProps(),
+      {
+        disabled: p.isDisabled,
+        readOnly: p.isReadOnly,
+        required: p.isRequired,
+        "aria-required": p.isRequired || void 0,
+        "aria-invalid": isInvalid || void 0,
+        value: p.value ?? p.defaultValue ?? "",
+        onChange: (e) => {
+          var _a;
+          const target = e.target;
+          (_a = p.onChange) == null ? void 0 : _a.call(p, target.value);
+        },
+        // Don't include type and pattern for textarea elements
+        type: isTextarea ? void 0 : p.type ?? "text",
+        inputMode: p.inputMode,
+        name: p.name,
+        pattern: isTextarea ? void 0 : p.pattern,
+        maxLength: p.maxLength,
+        minLength: p.minLength,
+        placeholder: p.placeholder,
+        autoComplete: p.autoComplete,
+        autoCorrect: p.autoCorrect,
+        autoCapitalize: p.autoCapitalize,
+        spellCheck: p.spellCheck,
+        // Clipboard events
+        onCopy: p.onCopy,
+        onCut: p.onCut,
+        onPaste: p.onPaste,
+        // Composition events
+        onCompositionStart: p.onCompositionStart,
+        onCompositionEnd: p.onCompositionEnd,
+        onCompositionUpdate: p.onCompositionUpdate,
+        // Selection events
+        onSelect: p.onSelect,
+        // Input events
+        onBeforeInput: p.onBeforeInput,
+        onInput: p.onInput
+      },
+      focusableProps,
+      fieldProps
+    );
+  };
+  const getIsInvalid = () => {
+    return getProps().isInvalid ?? false;
+  };
+  return {
+    get labelProps() {
+      return labelProps;
+    },
+    get inputProps() {
+      return getInputProps();
+    },
+    get descriptionProps() {
+      return descriptionProps;
+    },
+    get errorMessageProps() {
+      return errorMessageProps;
+    },
+    get isInvalid() {
+      return getIsInvalid();
+    }
+  };
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function createProgressBar(props = {}) {
+  const getProps = () => access$1(props);
+  const { labelProps, fieldProps } = createLabel({
+    get label() {
+      return getProps().label;
+    },
+    get "aria-label"() {
+      return getProps()["aria-label"];
+    },
+    get "aria-labelledby"() {
+      return getProps()["aria-labelledby"];
+    },
+    // Progress bar is not an HTML input element so it
+    // shouldn't be labeled by a <label> element.
+    labelElementType: "span"
+  });
+  const getProgressBarProps = () => {
+    const p = getProps();
+    const value = p.value ?? 0;
+    const minValue = p.minValue ?? 0;
+    const maxValue = p.maxValue ?? 100;
+    const isIndeterminate = p.isIndeterminate ?? false;
+    const formatOptions = p.formatOptions ?? { style: "percent" };
+    const clampedValue = clamp(value, minValue, maxValue);
+    const percentage = (clampedValue - minValue) / (maxValue - minValue);
+    let valueLabel = p.valueLabel;
+    if (!isIndeterminate && !valueLabel) {
+      const valueToFormat = formatOptions.style === "percent" ? percentage : clampedValue;
+      try {
+        const formatter = new Intl.NumberFormat(void 0, formatOptions);
+        valueLabel = formatter.format(valueToFormat);
+      } catch {
+        valueLabel = `${Math.round(percentage * 100)}%`;
+      }
+    }
+    const domProps = filterDOMProps(p, { labelable: true });
+    return mergeProps(domProps, fieldProps, {
+      "aria-valuenow": isIndeterminate ? void 0 : clampedValue,
+      "aria-valuemin": minValue,
+      "aria-valuemax": maxValue,
+      "aria-valuetext": isIndeterminate ? void 0 : valueLabel,
+      role: "progressbar"
+    });
+  };
+  return {
+    get progressBarProps() {
+      return getProgressBarProps();
+    },
+    get labelProps() {
+      return labelProps;
+    }
+  };
+}
+function createSeparator(props = {}) {
+  const getSeparatorProps = () => {
+    const p = access$1(props);
+    const domProps = filterDOMProps(p, { labelable: true });
+    let ariaOrientation;
+    if (p.orientation === "vertical") {
+      ariaOrientation = "vertical";
+    }
+    if (p.elementType !== "hr") {
+      return {
+        ...domProps,
+        role: "separator",
+        "aria-orientation": ariaOrientation
+      };
+    }
+    return domProps;
+  };
+  return {
+    get separatorProps() {
+      return getSeparatorProps();
+    }
+  };
+}
+export {
+  access$1 as access,
+  canUseDOM,
+  checkboxGroupData,
+  createButton,
+  createCheckbox,
+  createCheckboxGroup,
+  createCheckboxGroupItem,
+  createCheckboxGroupState,
+  createField,
+  createFocusRing,
+  createFocusable,
+  createHover,
+  createId,
+  createIsSSR,
+  createLabel,
+  createLabels,
+  createLink,
+  createPress,
+  createProgressBar,
+  createRadio,
+  createRadioGroup,
+  createRadioGroupState,
+  createSeparator,
+  createSwitch,
+  createTextField,
+  createToggle,
+  createToggleButton,
+  createToggleState,
+  filterDOMProps,
+  isAccessor,
+  mergeProps,
+  radioGroupData
+};
+//# sourceMappingURL=index.js.map