@proyecto-viviana/solidaria 0.0.3 → 0.0.4

package/dist/index.jsx

@@ -1,2717 +0,0 @@
-// src/interactions/createPress.ts
-import { createSignal, onCleanup as onCleanup2 } from "solid-js";
-
-// src/interactions/PressEvent.ts
-var PressEvent = class {
-  type;
-  pointerType;
-  target;
-  shiftKey;
-  ctrlKey;
-  metaKey;
-  altKey;
-  x;
-  y;
-  #shouldStopPropagation = true;
-  constructor(type, pointerType, originalEvent, target) {
-    this.type = type;
-    this.pointerType = pointerType;
-    this.target = target;
-    const e = originalEvent;
-    this.shiftKey = e?.shiftKey ?? false;
-    this.ctrlKey = e?.ctrlKey ?? false;
-    this.metaKey = e?.metaKey ?? false;
-    this.altKey = 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() {
-    this.#shouldStopPropagation = false;
-  }
-  /**
-   * Whether the event should stop propagation.
-   * Used internally by the press handler.
-   */
-  get shouldStopPropagation() {
-    return this.#shouldStopPropagation;
-  }
-};
-function createPressEvent(type, pointerType, originalEvent, target) {
-  return new PressEvent(type, pointerType, originalEvent, target);
-}
-
-// src/utils/mergeProps.ts
-function mergeProps(...args) {
-  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] === key[2]?.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(" ");
-}
-
-// src/utils/filterDOMProps.ts
-var DOMPropNames = /* @__PURE__ */ new Set(["id"]);
-var labelablePropNames = /* @__PURE__ */ new Set([
-  "aria-label",
-  "aria-labelledby",
-  "aria-describedby",
-  "aria-details"
-]);
-var linkPropNames = /* @__PURE__ */ new Set([
-  "href",
-  "hrefLang",
-  "target",
-  "rel",
-  "download",
-  "ping",
-  "referrerPolicy"
-]);
-var globalAttrs = /* @__PURE__ */ new Set(["dir", "lang", "hidden", "inert", "translate"]);
-var 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"
-]);
-var 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?.has(prop) || propRe.test(prop))) {
-      filteredProps[prop] = props[prop];
-    }
-  }
-  return filteredProps;
-}
-
-// src/utils/reactivity.ts
-function access(value) {
-  return typeof value === "function" ? value() : value;
-}
-function isAccessor(value) {
-  return typeof value === "function";
-}
-
-// src/utils/platform.ts
-function testPlatform(re) {
-  return typeof window !== "undefined" && window.navigator != null ? re.test(window.navigator.platform || window.navigator.userAgentData?.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();
-}
-
-// src/utils/dom.ts
-function getOwnerDocument(el) {
-  return 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?.metaKey || keyEvent?.ctrlKey || keyEvent?.shiftKey || keyEvent?.altKey;
-  if (shouldOpenInNewTab) {
-    const features = !allowOpener && rel?.includes("noopener") ? "noopener" : void 0;
-    window.open(href, linkTarget || "_blank", features);
-  } else {
-    window.location.href = href;
-  }
-}
-
-// src/utils/geometry.ts
-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;
-}
-
-// src/utils/events.ts
-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
-  });
-}
-
-// src/utils/textSelection.ts
-var state = "default";
-var savedUserSelect = "";
-var 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);
-    }
-  }
-}
-var pendingTransitions = /* @__PURE__ */ new Set();
-var 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);
-}
-
-// src/utils/focus.ts
-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;
-}
-var ignoreFocus = false;
-var 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;
-}
-var focusSafely = focusWithoutScrolling;
-
-// src/utils/globalListeners.ts
-import { onCleanup } from "solid-js";
-function createGlobalListeners() {
-  const listeners = [];
-  function addGlobalListener(type, handler, options) {
-    const target = 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?.isWindow ? window : document;
-    const listenerOptions = options ? {
-      capture: options.capture
-    } : void 0;
-    target.removeEventListener(type, handler, listenerOptions);
-    const index = listeners.findIndex(
-      (l) => l.target === target && l.type === type && l.handler === handler && l.options?.capture === 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
-  };
-}
-
-// src/interactions/createPress.ts
-function isDisabledValue(isDisabled) {
-  if (typeof isDisabled === "function") {
-    return isDisabled();
-  }
-  return isDisabled ?? false;
-}
-function isPressedValue(isPressed) {
-  if (typeof isPressed === "function") {
-    return isPressed();
-  }
-  return isPressed ?? false;
-}
-var LINK_CLICKED = Symbol("linkClicked");
-var 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(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(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(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(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(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) => {
-    if (!pressState.isPressed || pressState.pointerType !== "keyboard") {
-      return;
-    }
-    if (!isValidKeyboardEvent(e, pressState.target)) {
-      return;
-    }
-    if (isMac() && e.key === "Meta" && pressState.metaKeyEvents?.size) {
-      for (const [key, event] of pressState.metaKeyEvents) {
-        pressState.target?.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(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": ""
-  };
-  onCleanup2(() => {
-    removeAllGlobalListeners();
-    if (pressState.clickCleanup) {
-      pressState.clickCleanup();
-      pressState.clickCleanup = null;
-    }
-  });
-  return {
-    isPressed,
-    pressProps
-  };
-}
-
-// src/interactions/createFocus.ts
-import { onCleanup as onCleanup3 } from "solid-js";
-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?.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);
-  onCleanup3(() => {
-    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?.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
-    }
-  };
-}
-
-// src/interactions/createFocusWithin.ts
-import { onCleanup as onCleanup4 } from "solid-js";
-function createFocusWithin(props = {}) {
-  const { isDisabled, onBlurWithin, onFocusWithin, onFocusWithinChange } = props;
-  let isFocusWithin = false;
-  const { addGlobalListener, removeAllGlobalListeners } = createGlobalListeners();
-  onCleanup4(() => {
-    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?.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?.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
-    }
-  };
-}
-
-// src/interactions/createFocusable.ts
-import { createContext, useContext, onMount } from "solid-js";
-
-// src/interactions/createKeyboard.ts
-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)
-    }
-  };
-}
-
-// src/interactions/createFocusable.ts
-var FocusableContext = createContext(null);
-function useFocusableContext(setRef) {
-  const context = useContext(FocusableContext) || {};
-  if (context.ref) {
-    const contextRef = context.ref;
-    const originalSetRef = setRef;
-    setRef = (el) => {
-      originalSetRef(el);
-      contextRef(el);
-    };
-  }
-  const { ref: _, ...otherProps } = context;
-  return otherProps;
-}
-function isDisabledValue2(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?.(el);
-  };
-  const { focusProps } = createFocus({
-    isDisabled: isDisabledValue2(props.isDisabled),
-    onFocus: props.onFocus,
-    onBlur: props.onBlur,
-    onFocusChange: props.onFocusChange
-  });
-  const { keyboardProps } = createKeyboard({
-    isDisabled: isDisabledValue2(props.isDisabled),
-    onKeyDown: props.onKeyDown,
-    onKeyUp: props.onKeyUp
-  });
-  const interactions = mergeProps(focusProps, keyboardProps);
-  const contextProps = useFocusableContext(setRef);
-  const interactionProps = isDisabledValue2(props.isDisabled) ? {} : contextProps;
-  onMount(() => {
-    if (props.autoFocus && elementRef && !autoFocusDone) {
-      focusSafely(elementRef);
-      autoFocusDone = true;
-    }
-  });
-  let tabIndex = props.excludeFromTabOrder ? -1 : 0;
-  if (isDisabledValue2(props.isDisabled)) {
-    tabIndex = void 0;
-  }
-  const focusableProps = mergeProps(
-    {
-      ...interactions,
-      tabIndex,
-      ref: setRef
-    },
-    interactionProps
-  );
-  return {
-    focusableProps
-  };
-}
-
-// src/interactions/createFocusRing.ts
-import { createSignal as createSignal2, createEffect, onCleanup as onCleanup5 } from "solid-js";
-var currentModality = null;
-var hasSetupGlobalListeners = false;
-var 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] = createSignal2(false);
-  const [isFocusVisible, setIsFocusVisible] = createSignal2(autoFocus);
-  const [modality, setModality] = createSignal2(currentModality);
-  createEffect(() => {
-    setupGlobalFocusListeners();
-    const handler = (newModality) => {
-      setModality(newModality);
-    };
-    changeHandlers.add(handler);
-    onCleanup5(() => {
-      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
-  };
-}
-
-// src/interactions/createHover.ts
-import { createSignal as createSignal3, createEffect as createEffect2, onCleanup as onCleanup6, createMemo } from "solid-js";
-var globalIgnoreEmulatedMouseEvents = false;
-var 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 (false) {
-      document.addEventListener("touchend", setGlobalIgnoreEmulatedMouseEvents);
-    }
-  }
-  hoverCount++;
-  return () => {
-    hoverCount--;
-    if (hoverCount > 0) {
-      return;
-    }
-    if (typeof PointerEvent !== "undefined") {
-      document.removeEventListener("pointerup", handleGlobalPointerEvent);
-    } else if (false) {
-      document.removeEventListener("touchend", setGlobalIgnoreEmulatedMouseEvents);
-    }
-  };
-}
-function createHover(props = {}) {
-  const getProps = () => access(props);
-  const [isHovered, setIsHovered] = createSignal3(false);
-  let state2 = {
-    isHovered: false,
-    ignoreEmulatedMouseEvents: false,
-    pointerType: "",
-    target: null
-  };
-  createEffect2(() => {
-    const cleanup = setupGlobalTouchEvents();
-    onCleanup6(cleanup);
-  });
-  createEffect2(() => {
-    const p = getProps();
-    if (p.isDisabled && state2.isHovered) {
-      triggerHoverEnd(state2.target, state2.pointerType);
-    }
-  });
-  function triggerHoverStart(target, pointerType) {
-    const p = getProps();
-    state2.pointerType = pointerType;
-    if (p.isDisabled || state2.isHovered) {
-      return;
-    }
-    state2.isHovered = true;
-    state2.target = target;
-    p.onHoverStart?.({
-      type: "hoverstart",
-      target,
-      pointerType
-    });
-    p.onHoverChange?.(true);
-    setIsHovered(true);
-  }
-  function triggerHoverEnd(target, pointerType) {
-    const p = getProps();
-    state2.pointerType = "";
-    state2.target = null;
-    if (!state2.isHovered || !target) {
-      return;
-    }
-    state2.isHovered = false;
-    p.onHoverEnd?.({
-      type: "hoverend",
-      target,
-      pointerType
-    });
-    p.onHoverChange?.(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
-  };
-}
-
-// src/button/createButton.ts
-function isDisabledValue3(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 = isDisabledValue3(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
-  };
-}
-
-// src/button/createToggleButton.ts
-import { createSignal as createSignal4 } from "solid-js";
-function getSelectedValue(isSelected) {
-  if (typeof isSelected === "function") {
-    return isSelected();
-  }
-  return isSelected ?? false;
-}
-function createToggleButton(props = {}) {
-  const isControlled = props.isSelected !== void 0;
-  const [uncontrolledSelected, setUncontrolledSelected] = createSignal4(
-    props.defaultSelected ?? false
-  );
-  const isSelected = () => {
-    if (isControlled) {
-      return getSelectedValue(props.isSelected);
-    }
-    return uncontrolledSelected();
-  };
-  const toggleSelection = () => {
-    const newValue = !isSelected();
-    if (!isControlled) {
-      setUncontrolledSelected(newValue);
-    }
-    props.onChange?.(newValue);
-  };
-  const onPress = (e) => {
-    toggleSelection();
-    props.onPress?.(e);
-  };
-  const { buttonProps: baseButtonProps, isPressed } = createButton(
-    mergeProps(props, {
-      onPress
-    })
-  );
-  const buttonProps = {
-    ...baseButtonProps,
-    get "aria-pressed"() {
-      return isSelected();
-    }
-  };
-  return {
-    buttonProps,
-    isPressed,
-    isSelected
-  };
-}
-
-// src/checkbox/createCheckbox.ts
-import { createEffect as createEffect4 } from "solid-js";
-
-// src/toggle/index.ts
-import { createToggleState } from "@proyecto-viviana/solid-stately";
-
-// src/toggle/createToggle.ts
-import { createEffect as createEffect3 } from "solid-js";
-function createToggle(props, state2, ref) {
-  const getProps = () => access(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) {
-      getProps().onPress?.(e);
-      state2.toggle();
-      ref()?.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);
-  };
-  createEffect3(() => {
-    const p = getProps();
-    const hasChildren = p.children != null;
-    const hasAriaLabel = p["aria-label"] != null || p["aria-labelledby"] != null;
-    if (!hasChildren && !hasAriaLabel && true) {
-      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()
-  };
-}
-
-// src/checkbox/createCheckbox.ts
-function createCheckbox(props, state2, inputRef) {
-  const getProps = () => access(props);
-  const toggleResult = createToggle(props, state2, inputRef);
-  const {
-    labelProps: baseLabelProps,
-    isSelected,
-    isPressed,
-    isDisabled,
-    isReadOnly,
-    isInvalid
-  } = toggleResult;
-  createEffect4(() => {
-    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
-  };
-}
-
-// src/checkbox/index.ts
-import { createCheckboxGroupState } from "@proyecto-viviana/solid-stately";
-
-// src/ssr/index.ts
-import { createUniqueId } from "solid-js";
-import { isServer } from "solid-js/web";
-function createIsSSR() {
-  return isServer;
-}
-function createId(defaultId) {
-  if (defaultId) {
-    return defaultId;
-  }
-  return `solidaria-${createUniqueId()}`;
-}
-var canUseDOM = !isServer;
-
-// src/label/createLabels.ts
-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
-  };
-}
-
-// src/label/createLabel.ts
-function createLabel(props) {
-  const getProps = () => access(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 && true) {
-      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();
-    }
-  };
-}
-
-// src/label/createField.ts
-function createField(props) {
-  const getProps = () => access(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();
-    }
-  };
-}
-
-// src/checkbox/createCheckboxGroup.ts
-var checkboxGroupData = /* @__PURE__ */ new WeakMap();
-function createCheckboxGroup(props, state2) {
-  const getProps = () => access(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();
-    }
-  };
-}
-
-// src/checkbox/createCheckboxGroupItem.ts
-function createCheckboxGroupItem(props, state2, inputRef) {
-  const getProps = () => access(props);
-  const toggleState = {
-    isSelected: () => state2.isSelected(getProps().value),
-    defaultSelected: state2.defaultValue.includes(getProps().value),
-    setSelected(isSelected) {
-      const value = getProps().value;
-      if (isSelected) {
-        state2.addValue(value);
-      } else {
-        state2.removeValue(value);
-      }
-      getProps().onChange?.(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?.name,
-      form: p.form ?? groupData?.form,
-      isRequired: p.isRequired ?? state2.isRequired(),
-      validationBehavior: p.validationBehavior ?? 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?.errorMessageId) {
-        describedByIds.push(groupData.errorMessageId);
-      }
-      if (groupData?.descriptionId) {
-        describedByIds.push(groupData.descriptionId);
-      }
-      const ariaDescribedBy = describedByIds.length > 0 ? describedByIds.join(" ") : void 0;
-      return {
-        ...baseInputProps,
-        "aria-describedby": ariaDescribedBy
-      };
-    }
-  };
-}
-
-// src/radio/index.ts
-import {
-  createRadioGroupState,
-  radioGroupSyncVersion as radioGroupSyncVersion2
-} from "@proyecto-viviana/solid-stately";
-
-// src/radio/createRadioGroup.ts
-var radioGroupData = /* @__PURE__ */ new WeakMap();
-function createRadioGroup(props, state2) {
-  const getProps = () => access(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) {
-      getProps().onBlur?.(e);
-      if (!state2.selectedValue()) {
-        state2.setLastFocusedValue(null);
-      }
-    },
-    onFocusWithin: (e) => getProps().onFocus?.(e),
-    onFocusWithinChange: (isFocused) => getProps().onFocusChange?.(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 {};
-    }
-  };
-}
-
-// src/radio/createRadio.ts
-import { createEffect as createEffect5 } from "solid-js";
-import { radioGroupSyncVersion } from "@proyecto-viviana/solid-stately";
-function createRadio(props, state2, ref) {
-  const getProps = () => access(props);
-  const isDisabled = () => getProps().isDisabled || state2.isDisabled;
-  const value = () => getProps().value;
-  const isSelected = () => {
-    const selected = state2.selectedValue();
-    const v = value();
-    return selected === v;
-  };
-  createEffect5(() => {
-    const p = getProps();
-    const hasChildren = p.children != null;
-    const hasAriaLabel = p["aria-label"] != null || p["aria-labelledby"] != null;
-    if (!hasChildren && !hasAriaLabel && true) {
-      console.warn("If you do not provide children, you must specify an aria-label for accessibility");
-    }
-  });
-  createEffect5(() => {
-    const inputEl = ref();
-    if (!inputEl) return;
-    const syncVersion = radioGroupSyncVersion.get(state2);
-    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) {
-      getProps().onPress?.(e);
-      state2.setSelectedValue(value());
-      ref()?.focus();
-    },
-    get isDisabled() {
-      return isDisabled();
-    }
-  });
-  const { focusableProps } = createFocusable({
-    get isDisabled() {
-      return isDisabled();
-    },
-    get autoFocus() {
-      return getProps().autoFocus;
-    },
-    onFocus(e) {
-      getProps().onFocus?.(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?.errorMessageId) {
-        describedByIds.push(groupData.errorMessageId);
-      }
-      if (groupData?.descriptionId) {
-        describedByIds.push(groupData.descriptionId);
-      }
-      const ariaDescribedBy = describedByIds.length > 0 ? describedByIds.join(" ") : void 0;
-      return mergeProps(domProps(), interactions, {
-        type: "radio",
-        name: groupData?.name,
-        form: groupData?.form,
-        tabIndex: getTabIndex(),
-        disabled: isDisabled(),
-        required: state2.isRequired && groupData?.validationBehavior === "native",
-        checked: isSelected(),
-        value: value(),
-        onChange,
-        "aria-describedby": ariaDescribedBy
-      });
-    },
-    isDisabled: isDisabled(),
-    isSelected,
-    isPressed: combinedIsPressed
-  };
-}
-
-// src/switch/createSwitch.ts
-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
-  };
-}
-
-// src/link/createLink.ts
-function createLink(props = {}) {
-  const getProps = () => access(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) => {
-      if (disabled) {
-        e.preventDefault();
-        return;
-      }
-      p.onClick?.(e);
-    };
-    return mergeProps(
-      filterDOMProps(p, { labelable: true }),
-      baseProps,
-      ariaProps,
-      focusableProps,
-      pressProps,
-      { onClick }
-    );
-  };
-  return {
-    get linkProps() {
-      return getLinkProps();
-    },
-    isPressed
-  };
-}
-
-// src/textfield/createTextField.ts
-function createTextField(props, ref) {
-  const getProps = () => access(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) => {
-          const target = e.target;
-          p.onChange?.(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();
-    }
-  };
-}
-
-// src/progress/createProgressBar.ts
-function clamp(value, min, max) {
-  return Math.min(Math.max(value, min), max);
-}
-function createProgressBar(props = {}) {
-  const getProps = () => access(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;
-    }
-  };
-}
-
-// src/separator/createSeparator.ts
-function createSeparator(props = {}) {
-  const getSeparatorProps = () => {
-    const p = access(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,
-  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
-};