@exponential-at/ui-solid 0.0.0-stage → 0.1.0

package/dist/chunks/image-loading-status-DZOoj4RQ.js

@@ -0,0 +1,1724 @@
+import { createComponent, mergeProps, Dynamic, spread, insert, template, effect, setAttribute, style, use } from "solid-js/web";
+import { splitProps, createRoot, For, createSignal, createEffect, onCleanup, getOwner, createRenderEffect, Show, children, untrack, on, createContext, useContext, onMount, createMemo, createComputed } from "solid-js";
+import { Loader, CircleDashed, Star, Upload, Search, Calendar, Menu, Ellipsis, ArrowLeft, Send, Paperclip, CircleStop, CircleX, TriangleAlert, CircleCheck, Info, Clock, Plus, Minus, File, Copy, X, ChevronsUpDown, ChevronRight, ChevronLeft, ChevronUp, ChevronDown, Check, Play, Square } from "lucide-solid";
+import { lookupIcon, typeaheadStep, nextEnabledIndex, str, bool } from "@exponential-at/ui/web";
+import { OVERLAY_PADDING } from "@exponential-at/ui";
+import { hideOthers } from "aria-hidden";
+import { offset, shift, limitShift, flip, size, autoUpdate, computePosition } from "@floating-ui/dom";
+var _tmpl$$4 = /* @__PURE__ */ template(`<svg xmlns=http://www.w3.org/2000/svg viewBox="0 0 24 24"fill=none stroke=currentColor stroke-width=2 stroke-linecap=round stroke-linejoin=round>`);
+const CHROME = {
+  check: Check,
+  chevronDown: ChevronDown,
+  chevronUp: ChevronUp,
+  chevronLeft: ChevronLeft,
+  chevronRight: ChevronRight,
+  close: X,
+  search: Search,
+  calendar: Calendar,
+  send: Send,
+  stop: Square,
+  play: Play,
+  attach: Paperclip,
+  spinner: Loader,
+  placeholder: CircleDashed
+};
+const FALLBACK_ICONS = {
+  "ui-check": Check,
+  "ui-chevron-down": ChevronDown,
+  "ui-chevron-up": ChevronUp,
+  "ui-chevron-left": ChevronLeft,
+  "ui-chevron-right": ChevronRight,
+  "ui-selector": ChevronsUpDown,
+  "ui-close": X,
+  "ui-copy": Copy,
+  "ui-file": File,
+  "ui-minus": Minus,
+  "ui-add": Plus,
+  "ui-clock": Clock,
+  "ui-info": Info,
+  "ui-success": CircleCheck,
+  "ui-warning": TriangleAlert,
+  "ui-error": CircleX,
+  "ui-stop": CircleStop,
+  "ui-attach": Paperclip,
+  "ui-send": Send,
+  "ui-back": ArrowLeft,
+  "ui-more": Ellipsis,
+  "ui-menu": Menu,
+  "ui-search": Search,
+  "ui-icon-placeholder": CircleDashed,
+  calendar: Calendar,
+  search: Search,
+  upload: Upload,
+  star: Star
+};
+function resolveIcon(icons, name) {
+  return lookupIcon(icons, name, FALLBACK_ICONS);
+}
+const shapes = /* @__PURE__ */ new WeakMap();
+function probe(icon) {
+  if (shapes.has(icon)) return shapes.get(icon);
+  let shape = null;
+  if (typeof document !== `undefined`) {
+    try {
+      createRoot((dispose) => {
+        const el = icon({});
+        if (el instanceof Element && el.localName === `svg` && el.classList.contains(`lucide`)) {
+          const classes = Array.from(el.classList).filter((c) => c !== `lucide` && c !== `lucide-icon`);
+          const nodes = Array.from(el.children).map((child) => {
+            const attrs = {};
+            for (const a of Array.from(child.attributes)) if (a.name !== `key`) attrs[a.name] = a.value;
+            return [child.localName, attrs];
+          });
+          shape = {
+            classes,
+            nodes
+          };
+        }
+        dispose();
+      });
+    } catch {
+      shape = null;
+    }
+  }
+  shapes.set(icon, shape);
+  return shape;
+}
+const mergeClasses = (...classes) => classes.filter((c, i, all) => Boolean(c) && c.trim() !== `` && all.indexOf(c) === i).join(` `).trim();
+function LucideSvg(props) {
+  const [local, rest] = splitProps(props, [`shape`, `size`, `class`]);
+  const hasA11y = () => Object.keys(rest).some((k) => k.startsWith(`aria-`) || k === `role` || k === `title`);
+  const size2 = () => local.size ?? 24;
+  const attr = (name, fallback) => name in rest ? rest[name] : fallback;
+  return (() => {
+    var _el$ = _tmpl$$4();
+    spread(_el$, mergeProps({
+      get ["aria-hidden"]() {
+        return hasA11y() ? void 0 : `true`;
+      }
+    }, rest, {
+      get width() {
+        return attr(`width`, size2());
+      },
+      get height() {
+        return attr(`height`, size2());
+      },
+      get ["class"]() {
+        return mergeClasses(`lucide`, mergeClasses(...local.shape.classes, local.class));
+      }
+    }), true, true);
+    insert(_el$, createComponent(For, {
+      get each() {
+        return local.shape.nodes;
+      },
+      children: ([tag, attrs]) => createComponent(Dynamic, mergeProps({
+        component: tag
+      }, attrs))
+    }));
+    return _el$;
+  })();
+}
+function PaintIcon(props) {
+  const [local, rest] = splitProps(props, [`icon`]);
+  return createComponent(Dynamic, mergeProps({
+    get component() {
+      const icon = local.icon;
+      const shape = probe(icon);
+      return shape ? (p) => createComponent(LucideSvg, mergeProps({
+        shape
+      }, p)) : icon;
+    }
+  }, rest));
+}
+function IconGlyph(props) {
+  const [local, rest] = splitProps(props, [`icons`, `name`, `size`, `class`]);
+  const resolved = () => resolveIcon(local.icons, local.name);
+  return createComponent(PaintIcon, mergeProps({
+    get icon() {
+      return resolved() ?? CircleDashed;
+    },
+    "aria-hidden": "true",
+    get ["data-icon"]() {
+      return local.name;
+    },
+    get ["data-icon-missing"]() {
+      return resolved() ? void 0 : `true`;
+    },
+    get size() {
+      return local.size;
+    },
+    get ["class"]() {
+      return local.class;
+    }
+  }, rest));
+}
+const UNITLESS = new Set(
+  `animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp`.split(` `)
+);
+const hyphenated = /* @__PURE__ */ new Map();
+function hyphenate(name) {
+  let hit = hyphenated.get(name);
+  if (hit === void 0) {
+    hit = name.includes(`-`) ? name : name.replace(/([A-Z])/g, `-$1`).toLowerCase().replace(/^ms-/, `-ms-`);
+    hyphenated.set(name, hit);
+  }
+  return hit;
+}
+function css(style2) {
+  if (!style2) return void 0;
+  const out = {};
+  for (const [name, value] of Object.entries(style2)) {
+    if (value === null || value === void 0 || typeof value === `boolean` || value === ``) continue;
+    if (name.startsWith(`--`)) {
+      out[name] = String(value);
+      continue;
+    }
+    const key = name === `cssFloat` ? `float` : hyphenate(name);
+    out[key] = typeof value === `number` && value !== 0 && !UNITLESS.has(name) ? `${value}px` : String(value).trim();
+  }
+  return out;
+}
+const px = (v) => typeof v === `number` ? v === 0 ? `0` : `${v}px` : v;
+function createMediaQuery(query, fallback = false) {
+  if (typeof window === `undefined` || typeof window.matchMedia !== `function`) return () => fallback;
+  const mql = window.matchMedia(query);
+  const [matches, setMatches] = createSignal(mql.matches);
+  const onChange = () => setMatches(mql.matches);
+  mql.addEventListener?.(`change`, onChange);
+  if (getOwner()) onCleanup(() => mql.removeEventListener?.(`change`, onChange));
+  return matches;
+}
+function createElementSize$1(el, initialWidth = 0) {
+  const [size2, setSize] = createSignal({ width: initialWidth, height: 0, measured: false });
+  createEffect(() => {
+    const node = el();
+    if (!node) return;
+    const read = () => {
+      const r = node.getBoundingClientRect();
+      const cur = size2();
+      if (!cur.measured && r.width === 0 && r.height === 0) return;
+      if (cur.measured && cur.width === r.width && cur.height === r.height) return;
+      setSize({ width: r.width, height: r.height, measured: true });
+    };
+    read();
+    if (typeof ResizeObserver === `undefined`) return;
+    const ro = new ResizeObserver(read);
+    ro.observe(node);
+    onCleanup(() => ro.disconnect());
+  });
+  return size2;
+}
+function styleWriter(el) {
+  let prev = null;
+  const write = (k, v) => el.style.setProperty(k, v === void 0 ? `` : v);
+  return (next) => {
+    if (prev) {
+      for (const k of Object.keys(prev)) if (!(k in next)) write(k, ``);
+      for (const k of Object.keys(next)) if (prev[k] !== next[k]) write(k, next[k]);
+    } else for (const k of Object.keys(next)) write(k, next[k]);
+    prev = { ...next };
+  };
+}
+function bindStyle(el, style2) {
+  const write = styleWriter(el);
+  createRenderEffect(() => write(style2()));
+}
+function LayerPortal(props) {
+  return createComponent(Show, {
+    get when() {
+      return props.mount;
+    },
+    children: (mount) => {
+      const el = mount();
+      const nodes = children(() => props.children);
+      const marker = document.createTextNode(``);
+      el.appendChild(marker);
+      insert(el, nodes, marker);
+      onCleanup(() => {
+        for (const n of [nodes()].flat(Infinity)) if (n instanceof Node && n.parentNode === el) el.removeChild(n);
+        marker.remove();
+      });
+      return null;
+    }
+  });
+}
+function mountIn(container, el) {
+  container.appendChild(el);
+  onCleanup(() => el.parentNode?.removeChild(el));
+}
+function createPresence(present) {
+  const [mounted, setMounted] = createSignal(untrack(present));
+  let node;
+  let openName = `none`;
+  let stop;
+  const nameOf = (el) => getComputedStyle(el).animationName || `none`;
+  createEffect(
+    on(present, (p) => {
+      stop?.();
+      stop = void 0;
+      if (p) {
+        setMounted(true);
+        return;
+      }
+      const el = node;
+      if (!el || !el.isConnected) return setMounted(false);
+      const styles = getComputedStyle(el);
+      const current = styles.animationName || `none`;
+      if (current === `none` || styles.display === `none` || current === openName) return setMounted(false);
+      const done = (e) => {
+        if (e.target !== el || !nameOf(el).split(`,`).map((s) => s.trim()).includes(e.animationName)) return;
+        stop?.();
+        setMounted(false);
+      };
+      el.addEventListener(`animationend`, done);
+      el.addEventListener(`animationcancel`, done);
+      stop = () => {
+        el.removeEventListener(`animationend`, done);
+        el.removeEventListener(`animationcancel`, done);
+      };
+    }, { defer: true })
+  );
+  onCleanup(() => stop?.());
+  return {
+    mounted,
+    ref: (el) => {
+      node = el;
+      el.addEventListener(`animationstart`, (e) => {
+        if (e.target === el && untrack(present)) openName = nameOf(el);
+      });
+    }
+  };
+}
+const LAYERS = [];
+const MODAL_LAYERS = [];
+const [layersVersion, setLayersVersion] = createSignal(0);
+let originalBodyPointerEvents = ``;
+const LayerContext = createContext();
+function layerContains(layer, target) {
+  if (!target) return false;
+  if (layer.el?.contains(target)) return true;
+  for (const kid of layer.kids) if (layerContains(kid, target)) return true;
+  return false;
+}
+const outsideEvent = (originalEvent) => {
+  const e = { target: originalEvent.target, detail: { originalEvent }, defaultPrevented: false, preventDefault: () => e.defaultPrevented = true };
+  return e;
+};
+function createLayer(o) {
+  const parent = useContext(LayerContext);
+  const layer = { parent, kids: /* @__PURE__ */ new Set() };
+  const modal = () => o.disableOutsidePointerEvents?.() ?? false;
+  const enabled = () => {
+    const highest = MODAL_LAYERS[MODAL_LAYERS.length - 1];
+    return LAYERS.indexOf(layer) >= (highest ? LAYERS.indexOf(highest) : -1);
+  };
+  const pointerEvents = (registered) => {
+    layersVersion();
+    if (MODAL_LAYERS.length === 0) return void 0;
+    const highest = MODAL_LAYERS[MODAL_LAYERS.length - 1];
+    const index = registered ? LAYERS.indexOf(layer) : -1;
+    return index >= LAYERS.indexOf(highest) ? `auto` : `none`;
+  };
+  const attach = (el) => {
+    layer.el = el;
+    const doc = el.ownerDocument;
+    const disable = untrack(modal);
+    if (disable) {
+      if (MODAL_LAYERS.length === 0) {
+        originalBodyPointerEvents = doc.body.style.pointerEvents;
+        doc.body.style.pointerEvents = `none`;
+      }
+      MODAL_LAYERS.push(layer);
+    }
+    LAYERS.push(layer);
+    parent?.kids.add(layer);
+    setLayersVersion((v) => v + 1);
+    let clickHandler;
+    const pointerDown = (event) => {
+      if (event.target && !layerContains(layer, event.target)) {
+        const run = () => {
+          if (!enabled()) return;
+          const e = outsideEvent(event);
+          o.onPointerDownOutside?.(e);
+          o.onInteractOutside?.(e);
+          if (!e.defaultPrevented) o.onDismiss();
+        };
+        if (event.pointerType === `touch`) {
+          if (clickHandler) doc.removeEventListener(`click`, clickHandler);
+          clickHandler = run;
+          doc.addEventListener(`click`, clickHandler, { once: true });
+        } else run();
+      } else if (clickHandler) doc.removeEventListener(`click`, clickHandler);
+    };
+    const focusIn = (event) => {
+      if (!event.target || layerContains(layer, event.target)) return;
+      const e = outsideEvent(event);
+      o.onFocusOutside?.(e);
+      o.onInteractOutside?.(e);
+      if (!e.defaultPrevented) o.onDismiss();
+    };
+    const keyDown = (event) => {
+      if (event.key !== `Escape`) return;
+      if (LAYERS.indexOf(layer) !== LAYERS.length - 1) return;
+      o.onEscapeKeyDown?.(event);
+      if (!event.defaultPrevented) {
+        event.preventDefault();
+        o.onDismiss();
+      }
+    };
+    const timer = setTimeout(() => doc.addEventListener(`pointerdown`, pointerDown), 0);
+    doc.addEventListener(`focusin`, focusIn);
+    doc.addEventListener(`keydown`, keyDown, { capture: true });
+    onCleanup(() => {
+      clearTimeout(timer);
+      doc.removeEventListener(`pointerdown`, pointerDown);
+      if (clickHandler) doc.removeEventListener(`click`, clickHandler);
+      doc.removeEventListener(`focusin`, focusIn);
+      doc.removeEventListener(`keydown`, keyDown, { capture: true });
+      if (disable && MODAL_LAYERS.length === 1) doc.body.style.pointerEvents = originalBodyPointerEvents;
+      LAYERS.splice(LAYERS.indexOf(layer), 1);
+      const m = MODAL_LAYERS.indexOf(layer);
+      if (m >= 0) MODAL_LAYERS.splice(m, 1);
+      parent?.kids.delete(layer);
+      setLayersVersion((v) => v + 1);
+    });
+  };
+  return { layer, attach, pointerEvents };
+}
+const layers = [];
+function dismissable(opts) {
+  onMount(() => {
+    const layer = opts.layer();
+    if (!layer) return;
+    layers.push(layer);
+    const inside = (t) => t instanceof Node && (layer.contains(t) || Boolean(opts.isInside?.(t)));
+    const onKey = (e) => {
+      if (e.key !== `Escape` || layers[layers.length - 1] !== layer) return;
+      e.preventDefault();
+      e.stopImmediatePropagation();
+      opts.onDismiss();
+    };
+    const onPointer = (e) => {
+      if (inside(e.target)) return;
+      opts.onOutside?.();
+      opts.onDismiss();
+    };
+    const onFocusIn = (e) => {
+      if (opts.keepOnFocusOutside || inside(e.target)) return;
+      opts.onOutside?.();
+      opts.onDismiss();
+    };
+    document.addEventListener(`keydown`, onKey, { capture: true });
+    document.addEventListener(`focusin`, onFocusIn);
+    const timer = window.setTimeout(() => document.addEventListener(`pointerdown`, onPointer));
+    onCleanup(() => {
+      window.clearTimeout(timer);
+      document.removeEventListener(`keydown`, onKey, { capture: true });
+      document.removeEventListener(`focusin`, onFocusIn);
+      document.removeEventListener(`pointerdown`, onPointer);
+      const i = layers.indexOf(layer);
+      if (i >= 0) layers.splice(i, 1);
+    });
+  });
+}
+let SCOPES = [];
+const scopesAdd = (s) => {
+  const active = SCOPES[0];
+  if (active && active !== s) active.paused = true;
+  SCOPES = [s, ...SCOPES.filter((x) => x !== s)];
+};
+const scopesRemove = (s) => {
+  SCOPES = SCOPES.filter((x) => x !== s);
+  if (SCOPES[0]) SCOPES[0].paused = false;
+};
+function tabbables(container) {
+  const nodes = [];
+  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
+    acceptNode: (node) => {
+      const el = node;
+      const hiddenInput = el.tagName === `INPUT` && el.type === `hidden`;
+      if (el.disabled || el.hidden || hiddenInput) return NodeFilter.FILTER_SKIP;
+      return el.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+    }
+  });
+  while (walker.nextNode()) nodes.push(walker.currentNode);
+  return nodes;
+}
+function isHidden(node, upTo) {
+  if (node && getComputedStyle(node).visibility === `hidden`) return true;
+  while (node) {
+    if (node === upTo) return false;
+    if (getComputedStyle(node).display === `none`) return true;
+    node = node.parentElement;
+  }
+  return false;
+}
+function focusEl(el, select = false) {
+  if (!el?.focus) return;
+  const prev = document.activeElement;
+  el.focus({ preventScroll: true });
+  if (el !== prev && select && el instanceof HTMLInputElement && `select` in el) el.select();
+}
+function focusFirst(candidates, select = false) {
+  const prev = document.activeElement;
+  for (const c of candidates) {
+    focusEl(c, select);
+    if (document.activeElement !== prev) return;
+  }
+}
+const AUTOFOCUS_ON_MOUNT = `focusScope.autoFocusOnMount`;
+const AUTOFOCUS_ON_UNMOUNT = `focusScope.autoFocusOnUnmount`;
+function createFocusScope(o) {
+  const scope = { paused: false };
+  let container;
+  const attach = (el) => {
+    let started = false;
+    let disposed = false;
+    let previouslyFocused = null;
+    let lastFocused = null;
+    const focusIn = (event) => {
+      if (!untrack(o.trapped) || scope.paused) return;
+      const target = event.target;
+      if (el.contains(target)) lastFocused = target;
+      else focusEl(lastFocused, true);
+    };
+    const focusOut = (event) => {
+      if (!untrack(o.trapped) || scope.paused) return;
+      const related = event.relatedTarget;
+      if (related === null) return;
+      if (!el.contains(related)) focusEl(lastFocused, true);
+    };
+    const observer = new MutationObserver((mutations) => {
+      if (!untrack(o.trapped) || scope.paused) return;
+      if (document.activeElement !== document.body) return;
+      for (const m of mutations) if (m.removedNodes.length > 0) focusEl(el);
+    });
+    queueMicrotask(() => {
+      if (disposed || !el.isConnected) return;
+      started = true;
+      container = el;
+      scopesAdd(scope);
+      previouslyFocused = document.activeElement;
+      if (!el.contains(previouslyFocused)) {
+        const mountEvent = new CustomEvent(AUTOFOCUS_ON_MOUNT, { bubbles: false, cancelable: true });
+        const onMount2 = (e) => o.onMountAutoFocus?.(e);
+        el.addEventListener(AUTOFOCUS_ON_MOUNT, onMount2);
+        el.dispatchEvent(mountEvent);
+        el.removeEventListener(AUTOFOCUS_ON_MOUNT, onMount2);
+        if (!mountEvent.defaultPrevented) {
+          focusFirst(tabbables(el).filter((n) => n.tagName !== `A`), true);
+          if (document.activeElement === previouslyFocused) focusEl(el);
+        }
+      }
+      document.addEventListener(`focusin`, focusIn);
+      document.addEventListener(`focusout`, focusOut);
+      observer.observe(el, { childList: true, subtree: true });
+    });
+    onCleanup(() => {
+      disposed = true;
+      if (!started) return;
+      document.removeEventListener(`focusin`, focusIn);
+      document.removeEventListener(`focusout`, focusOut);
+      observer.disconnect();
+      const prev = previouslyFocused;
+      setTimeout(() => {
+        const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, { bubbles: false, cancelable: true });
+        const onUnmount = (e) => o.onUnmountAutoFocus?.(e);
+        el.addEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmount);
+        el.dispatchEvent(unmountEvent);
+        if (!unmountEvent.defaultPrevented) focusEl(prev ?? document.body, true);
+        el.removeEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmount);
+        scopesRemove(scope);
+      }, 0);
+    });
+  };
+  const onKeyDown = (event) => {
+    if (!o.loop && !untrack(o.trapped)) return;
+    if (scope.paused || !container) return;
+    const isTab = event.key === `Tab` && !event.altKey && !event.ctrlKey && !event.metaKey;
+    const focused = document.activeElement;
+    if (!isTab || !focused) return;
+    const candidates = tabbables(container);
+    const first = candidates.find((c) => !isHidden(c, container));
+    const last = [...candidates].reverse().find((c) => !isHidden(c, container));
+    if (!first || !last) {
+      if (focused === container) event.preventDefault();
+    } else if (!event.shiftKey && focused === last) {
+      event.preventDefault();
+      if (o.loop) focusEl(first, true);
+    } else if (event.shiftKey && focused === first) {
+      event.preventDefault();
+      if (o.loop) focusEl(last, true);
+    }
+  };
+  return { attach, onKeyDown };
+}
+let guardCount = 0;
+function createGuard() {
+  const el = document.createElement(`span`);
+  el.setAttribute(`data-radix-focus-guard`, ``);
+  el.tabIndex = 0;
+  el.style.outline = `none`;
+  el.style.opacity = `0`;
+  el.style.position = `fixed`;
+  el.style.pointerEvents = `none`;
+  return el;
+}
+function useFocusGuards() {
+  const edges = document.querySelectorAll(`[data-radix-focus-guard]`);
+  document.body.insertAdjacentElement(`afterbegin`, edges[0] ?? createGuard());
+  document.body.insertAdjacentElement(`beforeend`, edges[1] ?? createGuard());
+  guardCount++;
+  onCleanup(() => {
+    if (guardCount === 1) document.querySelectorAll(`[data-radix-focus-guard]`).forEach((n) => n.remove());
+    guardCount--;
+  });
+}
+const LOCK_ATTRIBUTE = `data-scroll-locked`;
+let lockSheets = 0;
+let lockSheet = null;
+function useScrollLock() {
+  const body = document.body;
+  const count = () => {
+    const n = parseInt(body.getAttribute(LOCK_ATTRIBUTE) || `0`, 10);
+    return isFinite(n) ? n : 0;
+  };
+  body.setAttribute(LOCK_ATTRIBUTE, String(count() + 1));
+  if (lockSheets === 0) {
+    const cs = getComputedStyle(body);
+    const parse = (x) => parseInt(x || ``, 10) || 0;
+    const [left, top, right] = [parse(cs.marginLeft), parse(cs.marginTop), parse(cs.marginRight)];
+    const gap = Math.max(0, window.innerWidth - document.documentElement.clientWidth + right - left);
+    const important = `!important`;
+    const css2 = `
+  .with-scroll-bars-hidden {
+   overflow: hidden ${important};
+   padding-right: ${gap}px ${important};
+  }
+  body[${LOCK_ATTRIBUTE}] {
+    overflow: hidden ${important};
+    overscroll-behavior: contain;
+    ${[`position: relative ${important};`, `
+    padding-left: ${left}px;
+    padding-top: ${top}px;
+    padding-right: ${right}px;
+    margin-left:0;
+    margin-top:0;
+    margin-right: ${gap}px ${important};
+    `].join(``)}
+  }
+  
+  .right-scroll-bar-position {
+    right: ${gap}px ${important};
+  }
+  
+  .width-before-scroll-bar {
+    margin-right: ${gap}px ${important};
+  }
+  
+  .right-scroll-bar-position .right-scroll-bar-position {
+    right: 0 ${important};
+  }
+  
+  .width-before-scroll-bar .width-before-scroll-bar {
+    margin-right: 0 ${important};
+  }
+  
+  body[${LOCK_ATTRIBUTE}] {
+    --removed-body-scroll-bar-size: ${gap}px;
+  }
+`;
+    lockSheet = document.createElement(`style`);
+    lockSheet.type = `text/css`;
+    lockSheet.appendChild(document.createTextNode(css2));
+    (document.head || document.getElementsByTagName(`head`)[0]).appendChild(lockSheet);
+  }
+  lockSheets++;
+  onCleanup(() => {
+    const n = count() - 1;
+    if (n <= 0) body.removeAttribute(LOCK_ATTRIBUTE);
+    else body.setAttribute(LOCK_ATTRIBUTE, String(n));
+    lockSheets--;
+    if (!lockSheets && lockSheet) {
+      lockSheet.remove();
+      lockSheet = null;
+    }
+  });
+}
+function useModalEffects(el, lockScroll) {
+  const undo = hideOthers(el);
+  onCleanup(undo);
+  if (lockScroll) useScrollLock();
+}
+var _tmpl$$3 = /* @__PURE__ */ template(`<div data-radix-popper-content-wrapper>`);
+const transformOrigin = {
+  name: `transformOrigin`,
+  fn(data) {
+    const [placedSide, placedAlign = `center`] = data.placement.split(`-`);
+    const noArrowAlign = {
+      start: `0%`,
+      center: `50%`,
+      end: `100%`
+    }[placedAlign];
+    let x = ``;
+    let y = ``;
+    if (placedSide === `bottom`) {
+      x = noArrowAlign;
+      y = `${-0}px`;
+    } else if (placedSide === `top`) {
+      x = noArrowAlign;
+      y = `${data.rects.floating.height + 0}px`;
+    } else if (placedSide === `right`) {
+      x = `${-0}px`;
+      y = noArrowAlign;
+    } else if (placedSide === `left`) {
+      x = `${data.rects.floating.width + 0}px`;
+      y = noArrowAlign;
+    }
+    return {
+      data: {
+        x,
+        y
+      }
+    };
+  }
+};
+function Popper(props) {
+  const desired = () => props.align === `center` ? props.side : `${props.side}-${props.align}`;
+  const [placement, setPlacement] = createSignal(untrack(desired));
+  const [isPositioned, setPositioned] = createSignal(false);
+  const [content, setContent] = createSignal();
+  let pos = {
+    x: 0,
+    y: 0,
+    origin: void 0
+  };
+  let floatingSet = false;
+  let zIndex;
+  let disposed = false;
+  const wrapper = (() => {
+    var _el$ = _tmpl$$3();
+    effect(() => setAttribute(_el$, "dir", props.dir));
+    return _el$;
+  })();
+  const writeWrapper = styleWriter(wrapper);
+  const dpr = () => wrapper.ownerDocument.defaultView?.devicePixelRatio || 1;
+  const roundByDPR = (v) => Math.round(v * dpr()) / dpr();
+  const paintWrapper = () => {
+    const s = {
+      position: `fixed`,
+      left: `0`,
+      top: `0`
+    };
+    if (floatingSet) {
+      s.transform = `translate(${roundByDPR(pos.x)}px, ${roundByDPR(pos.y)}px)`;
+      if (dpr() >= 1.5) s[`will-change`] = `transform`;
+    }
+    s.transform = untrack(isPositioned) ? s.transform : `translate(0, -200%)`;
+    s[`min-width`] = `max-content`;
+    s[`z-index`] = zIndex || void 0;
+    s[`--radix-popper-transform-origin`] = [pos.origin?.x, pos.origin?.y].join(` `);
+    writeWrapper(s);
+  };
+  paintWrapper();
+  const state = {
+    placedSide: () => placement().split(`-`)[0],
+    placedAlign: () => placement().split(`-`)[1] ?? `center`,
+    isPositioned,
+    setContent
+  };
+  insert(wrapper, untrack(() => props.children(state)));
+  createEffect(() => {
+    const anchor = props.anchor;
+    const el = content();
+    if (!anchor || !el) return;
+    untrack(() => {
+      floatingSet = true;
+      paintWrapper();
+      zIndex = getComputedStyle(el).zIndex;
+      paintWrapper();
+    });
+    const padding = props.collisionPadding;
+    const detect = {
+      padding,
+      boundary: [],
+      altBoundary: false
+    };
+    const middleware = [offset({
+      mainAxis: props.sideOffset,
+      alignmentAxis: props.alignOffset ?? 0
+    }), shift({
+      mainAxis: true,
+      crossAxis: false,
+      limiter: limitShift(),
+      ...detect
+    }), flip({
+      ...detect
+    }), size({
+      ...detect,
+      apply: ({
+        elements,
+        rects,
+        availableWidth,
+        availableHeight
+      }) => {
+        const st = elements.floating.style;
+        st.setProperty(`--radix-popper-available-width`, `${availableWidth}px`);
+        st.setProperty(`--radix-popper-available-height`, `${availableHeight}px`);
+        st.setProperty(`--radix-popper-anchor-width`, `${rects.reference.width}px`);
+        st.setProperty(`--radix-popper-anchor-height`, `${rects.reference.height}px`);
+      }
+    }), transformOrigin];
+    const placementNow = desired();
+    const update = () => {
+      void computePosition(anchor, wrapper, {
+        strategy: `fixed`,
+        placement: placementNow,
+        middleware
+      }).then((d) => {
+        if (disposed) return;
+        const origin = d.middlewareData.transformOrigin;
+        const same = untrack(isPositioned) && pos.x === d.x && pos.y === d.y && pos.origin?.x === origin?.x && pos.origin?.y === origin?.y && untrack(placement) === d.placement;
+        if (same) return;
+        pos = {
+          x: d.x,
+          y: d.y,
+          origin
+        };
+        setPlacement(d.placement);
+        setPositioned(true);
+        paintWrapper();
+      });
+    };
+    const stop = autoUpdate(anchor, wrapper, update, {
+      animationFrame: false
+    });
+    onCleanup(stop);
+  });
+  onCleanup(() => disposed = true);
+  return wrapper;
+}
+function popperContentStyle(kind, trigger, pointerEvents, positioned, prefix = {}) {
+  return {
+    ...prefix,
+    "pointer-events": pointerEvents,
+    [`--radix-${kind}-content-transform-origin`]: `var(--radix-popper-transform-origin)`,
+    [`--radix-${kind}-content-available-width`]: `var(--radix-popper-available-width)`,
+    [`--radix-${kind}-content-available-height`]: `var(--radix-popper-available-height)`,
+    [`--radix-${kind}-${trigger}-width`]: `var(--radix-popper-anchor-width)`,
+    [`--radix-${kind}-${trigger}-height`]: `var(--radix-popper-anchor-height)`,
+    animation: positioned ? void 0 : `none`
+  };
+}
+function popperWrapper(opts) {
+  const [pos, setPos] = createSignal(null);
+  const [zIndex, setZIndex] = createSignal();
+  let contentEl;
+  const dpr = () => typeof window === `undefined` ? 1 : window.devicePixelRatio || 1;
+  const round = (v) => Math.round(v * dpr()) / dpr();
+  const placed = createMemo(() => {
+    const p = pos();
+    const [side, align = `center`] = (p?.placement ?? `bottom-${opts.align}`).split(`-`);
+    return {
+      side,
+      align: opts.align === `center` && !p ? `center` : align,
+      positioned: p !== null
+    };
+  });
+  const style$1 = () => {
+    const p = pos();
+    const s = {
+      position: `fixed`,
+      left: 0,
+      top: 0,
+      transform: p ? `translate(${round(p.x)}px, ${round(p.y)}px)` : `translate(0, -200%)`
+    };
+    if (dpr() >= 1.5) s.willChange = `transform`;
+    s.minWidth = `max-content`;
+    s.zIndex = zIndex();
+    s[`--radix-popper-transform-origin`] = p ? p.origin.join(` `) : ` `;
+    return css(s);
+  };
+  const wrapper = (() => {
+    var _el$2 = _tmpl$$3();
+    insert(_el$2, () => opts.content(placed, (el) => contentEl = el));
+    effect((_p$) => {
+      var _v$ = style$1(), _v$2 = opts.dir?.();
+      _p$.e = style(_el$2, _v$, _p$.e);
+      _v$2 !== _p$.t && setAttribute(_el$2, "dir", _p$.t = _v$2);
+      return _p$;
+    }, {
+      e: void 0,
+      t: void 0
+    });
+    return _el$2;
+  })();
+  onMount(() => {
+    if (contentEl) setZIndex(getComputedStyle(contentEl).zIndex);
+    const anchor = opts.anchor();
+    if (!anchor) return;
+    const detect = {
+      padding: opts.collisionPadding,
+      boundary: [],
+      altBoundary: false
+    };
+    let alive = true;
+    const update = () => void computePosition(anchor, wrapper, {
+      strategy: `fixed`,
+      placement: opts.align === `center` ? `bottom` : `bottom-${opts.align}`,
+      middleware: [offset({
+        mainAxis: opts.sideOffset,
+        alignmentAxis: 0
+      }), shift({
+        mainAxis: true,
+        crossAxis: false,
+        limiter: limitShift(),
+        ...detect
+      }), flip({
+        ...detect
+      }), size({
+        ...detect,
+        apply: ({
+          elements,
+          rects,
+          availableWidth,
+          availableHeight
+        }) => {
+          const st = elements.floating.style;
+          st.setProperty(`--radix-popper-available-width`, `${availableWidth}px`);
+          st.setProperty(`--radix-popper-available-height`, `${availableHeight}px`);
+          st.setProperty(`--radix-popper-anchor-width`, `${rects.reference.width}px`);
+          st.setProperty(`--radix-popper-anchor-height`, `${rects.reference.height}px`);
+        }
+      }), transformOrigin]
+    }).then((r) => {
+      if (!alive) return;
+      const first = pos() === null;
+      const origin = r.middlewareData.transformOrigin;
+      setPos({
+        x: r.x,
+        y: r.y,
+        placement: r.placement,
+        origin: [origin?.x ?? ``, origin?.y ?? ``]
+      });
+      if (first) opts.onPlaced?.();
+    });
+    const stop = autoUpdate(anchor, wrapper, update, {
+      animationFrame: false
+    });
+    onCleanup(() => {
+      alive = false;
+      stop();
+    });
+  });
+  return wrapper;
+}
+function inPolygon(point, polygon) {
+  let inside = false;
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const a = polygon[i];
+    const b = polygon[j];
+    if (a.y > point.y !== b.y > point.y && point.x < (b.x - a.x) * (point.y - a.y) / (b.y - a.y) + a.x) inside = !inside;
+  }
+  return inside;
+}
+function hull(points) {
+  const sorted = [...points].sort((a, b) => a.x < b.x ? -1 : a.x > b.x ? 1 : a.y < b.y ? -1 : a.y > b.y ? 1 : 0);
+  if (sorted.length <= 1) return sorted;
+  const cross = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+  const upper = [];
+  for (const p of sorted) {
+    while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], p) >= 0) upper.pop();
+    upper.push(p);
+  }
+  upper.pop();
+  const lower = [];
+  for (let i = sorted.length - 1; i >= 0; i--) {
+    const p = sorted[i];
+    while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], p) >= 0) lower.pop();
+    lower.push(p);
+  }
+  lower.pop();
+  return upper.length === 1 && lower.length === 1 && upper[0].x === lower[0].x && upper[0].y === lower[0].y ? upper : upper.concat(lower);
+}
+function graceArea(exit, from, to) {
+  const padding = 5;
+  const top = Math.abs(from.top - exit.y);
+  const bottom = Math.abs(from.bottom - exit.y);
+  const right = Math.abs(from.right - exit.x);
+  const left = Math.abs(from.left - exit.x);
+  const m = Math.min(top, bottom, right, left);
+  const padded = m === left ? [{ x: exit.x + padding, y: exit.y - padding }, { x: exit.x + padding, y: exit.y + padding }] : m === right ? [{ x: exit.x - padding, y: exit.y - padding }, { x: exit.x - padding, y: exit.y + padding }] : m === top ? [{ x: exit.x - padding, y: exit.y + padding }, { x: exit.x + padding, y: exit.y + padding }] : [{ x: exit.x - padding, y: exit.y - padding }, { x: exit.x + padding, y: exit.y - padding }];
+  return hull([...padded, { x: to.left, y: to.top }, { x: to.right, y: to.top }, { x: to.right, y: to.bottom }, { x: to.left, y: to.bottom }]);
+}
+var _tmpl$$2 = /* @__PURE__ */ template(`<span role=tooltip>`);
+function VisuallyHidden(props) {
+  const el = (() => {
+    var _el$ = _tmpl$$2();
+    insert(_el$, () => props.children);
+    effect(() => setAttribute(_el$, "id", props.id));
+    return _el$;
+  })();
+  styleWriter(el)({
+    position: `absolute`,
+    border: `0`,
+    width: `1px`,
+    height: `1px`,
+    padding: `0`,
+    margin: `-1px`,
+    overflow: `hidden`,
+    clip: `rect(0, 0, 0, 0)`,
+    "white-space": `nowrap`,
+    "word-wrap": `normal`
+  });
+  return el;
+}
+const wrapArray = (array, start) => array.map((_, i) => array[(start + i) % array.length]);
+function getNextMatch(values, search, currentMatch) {
+  const isRepeated = search.length > 1 && Array.from(search).every((c) => c === search[0]);
+  const normalized = isRepeated ? search[0] : search;
+  const currentIndex = currentMatch ? values.indexOf(currentMatch) : -1;
+  let wrapped = wrapArray(values, Math.max(currentIndex, 0));
+  if (normalized.length === 1) wrapped = wrapped.filter((v) => v !== currentMatch);
+  const next = wrapped.find((v) => v.toLowerCase().startsWith(normalized.toLowerCase()));
+  return next !== currentMatch ? next : void 0;
+}
+function radixTypeahead(onSearch) {
+  let search = ``;
+  let timer = 0;
+  const update = (v) => {
+    search = v;
+    window.clearTimeout(timer);
+    if (v !== ``) timer = window.setTimeout(() => update(``), 1e3);
+  };
+  onCleanup(() => window.clearTimeout(timer));
+  return {
+    get search() {
+      return search;
+    },
+    type: (key) => {
+      const next = search + key;
+      onSearch(next);
+      update(next);
+    },
+    reset: () => {
+      search = ``;
+      window.clearTimeout(timer);
+    }
+  };
+}
+function findNextItem(items, search, current) {
+  const repeated = search.length > 1 && Array.from(search).every((c) => c === search[0]);
+  const normalized = repeated ? search[0] : search;
+  const at = current ? items.indexOf(current) : -1;
+  let wrapped = items.map((_, i) => items[(Math.max(at, 0) + i) % items.length]);
+  if (normalized.length === 1) wrapped = wrapped.filter((v) => v !== current);
+  const next = wrapped.find((item) => item.label.toLowerCase().startsWith(normalized.toLowerCase()));
+  return next !== current ? next : void 0;
+}
+var _tmpl$$1 = /* @__PURE__ */ template(`<div role=menu aria-orientation=vertical data-radix-menu-content>`);
+let usingKeyboard = false;
+let keyboardListeners = 0;
+function useKeyboardTracking() {
+  const key = () => usingKeyboard = true;
+  const pointer = () => usingKeyboard = false;
+  if (keyboardListeners++ === 0) {
+    document.addEventListener(`keydown`, key, {
+      capture: true
+    });
+    document.addEventListener(`pointerdown`, pointer, {
+      capture: true
+    });
+    document.addEventListener(`pointermove`, pointer, {
+      capture: true
+    });
+  }
+  onCleanup(() => {
+    if (--keyboardListeners === 0) {
+      document.removeEventListener(`keydown`, key, {
+        capture: true
+      });
+      document.removeEventListener(`pointerdown`, pointer, {
+        capture: true
+      });
+      document.removeEventListener(`pointermove`, pointer, {
+        capture: true
+      });
+    }
+  });
+}
+const MenuLevelContext = createContext();
+const FIRST_KEYS = [`ArrowDown`, `PageUp`, `Home`];
+const LAST_KEYS = [`ArrowUp`, `PageDown`, `End`];
+const itemsOf = (content) => content ? Array.from(content.querySelectorAll(`:scope [data-radix-collection-item]`)).filter((el) => el.closest(`[data-radix-menu-content]`) === content) : [];
+function MenuContent(props) {
+  const layer = createLayer({
+    disableOutsidePointerEvents: () => props.root,
+    onEscapeKeyDown: (e) => props.onEscapeKeyDown?.(e),
+    onFocusOutside: (e) => {
+      if (props.root) e.preventDefault();
+      props.onFocusOutside?.(e);
+    },
+    onInteractOutside: (e) => props.onInteractOutside?.(e),
+    onDismiss: () => props.onDismiss()
+  });
+  const scope = createFocusScope({
+    trapped: () => props.root,
+    loop: false,
+    onMountAutoFocus: (e) => {
+      e.preventDefault();
+      if (props.root || usingKeyboard) contentEl?.focus({
+        preventScroll: true
+      });
+    },
+    onUnmountAutoFocus: (e) => props.onCloseAutoFocus(e)
+  });
+  const [registered, setRegistered] = createSignal(false);
+  const [highlighted, setHighlighted] = createSignal();
+  const [tabStop, setTabStop] = createSignal();
+  let contentEl;
+  let search = ``;
+  let searchTimer;
+  let grace = null;
+  let pointerDir = `right`;
+  let lastPointerX = 0;
+  const movingToSubmenu = (e) => Boolean(grace && pointerDir === grace.side && inPolygon({
+    x: e.clientX,
+    y: e.clientY
+  }, grace.area));
+  const level = {
+    content: () => contentEl,
+    highlighted,
+    setHighlighted,
+    tabStop,
+    setTabStop,
+    search: () => search,
+    onItemEnter: (e) => movingToSubmenu(e),
+    onItemLeave: (e) => {
+      if (movingToSubmenu(e)) return;
+      contentEl?.focus({
+        preventScroll: true
+      });
+      setTabStop(void 0);
+    },
+    onTriggerLeave: (e) => movingToSubmenu(e),
+    setGrace: (g) => grace = g
+  };
+  onCleanup(() => clearTimeout(searchTimer));
+  const typeahead = (key) => {
+    const next = search + key;
+    const items = itemsOf(contentEl).filter((el) => !el.hasAttribute(`data-disabled`));
+    const current = document.activeElement;
+    const currentMatch = items.find((el) => el === current)?.textContent ?? void 0;
+    const values = items.map((el) => el.textContent ?? ``);
+    const match = getNextMatch(values, next, currentMatch);
+    const target = items.find((el) => (el.textContent ?? ``) === match);
+    const update = (value) => {
+      search = value;
+      clearTimeout(searchTimer);
+      if (value !== ``) searchTimer = setTimeout(() => update(``), 1e3);
+    };
+    update(next);
+    if (target) setTimeout(() => target.focus());
+  };
+  return createComponent(Popper, {
+    get anchor() {
+      return props.anchor;
+    },
+    get side() {
+      return props.side;
+    },
+    get align() {
+      return props.align;
+    },
+    get sideOffset() {
+      return props.sideOffset;
+    },
+    get alignOffset() {
+      return props.alignOffset;
+    },
+    get collisionPadding() {
+      return props.collisionPadding ?? OVERLAY_PADDING;
+    },
+    get dir() {
+      return props.dir;
+    },
+    children: (popper) => {
+      const el = (() => {
+        var _el$ = _tmpl$$1();
+        spread(_el$, mergeProps({
+          get ["data-side"]() {
+            return popper.placedSide();
+          },
+          get ["data-align"]() {
+            return popper.placedAlign();
+          },
+          get ["data-state"]() {
+            return props.state();
+          },
+          get dir() {
+            return props.dir;
+          },
+          get id() {
+            return props.id;
+          },
+          get ["aria-labelledby"]() {
+            return props.labelledBy;
+          }
+        }, () => props.attrs(), {
+          "tabindex": "-1",
+          "data-orientation": "vertical",
+          "onKeyDown": (e) => {
+            scope.onKeyDown(e);
+            const target = e.target;
+            const inside = target.closest(`[data-radix-menu-content]`) === el;
+            const modifier = e.ctrlKey || e.altKey || e.metaKey;
+            if (inside) {
+              if (e.key === `Tab`) e.preventDefault();
+              if (!modifier && e.key.length === 1) typeahead(e.key);
+            }
+            props.onKeyDown?.(e);
+            if (e.target !== el) return;
+            if (!FIRST_KEYS.includes(e.key) && !LAST_KEYS.includes(e.key)) return;
+            e.preventDefault();
+            const nodes = itemsOf(el).filter((n) => !n.hasAttribute(`data-disabled`));
+            if (LAST_KEYS.includes(e.key)) nodes.reverse();
+            focusFirst(nodes);
+          },
+          "onFocus": (e) => {
+            if (e.target !== el || !usingKeyboard) return;
+            const nodes = itemsOf(el).filter((n) => !n.hasAttribute(`data-disabled`));
+            const current = untrack(tabStop);
+            focusFirst([current, ...nodes].filter(Boolean));
+          },
+          "onPointerMove": (e) => {
+            if (e.pointerType !== `mouse`) return;
+            if (el.contains(e.target) && lastPointerX !== e.clientX) {
+              pointerDir = e.clientX > lastPointerX ? `right` : `left`;
+              lastPointerX = e.clientX;
+            }
+          }
+        }), false, true);
+        insert(_el$, createComponent(LayerContext.Provider, {
+          get value() {
+            return layer.layer;
+          },
+          get children() {
+            return createComponent(MenuLevelContext.Provider, {
+              value: level,
+              get children() {
+                return props.children;
+              }
+            });
+          }
+        }));
+        return _el$;
+      })();
+      contentEl = el;
+      props.setContent?.(el);
+      onCleanup(() => props.setContent?.(void 0));
+      popper.setContent(el);
+      bindStyle(el, () => popperContentStyle(props.kind, `trigger`, props.lagParentLayer && !registered() ? void 0 : layer.pointerEvents(registered()), popper.isPositioned(), {
+        outline: `none`
+      }));
+      onMount(() => {
+        layer.attach(el);
+        setRegistered(true);
+        scope.attach(el);
+        useFocusGuards();
+        if (props.root) useModalEffects(el, true);
+      });
+      return el;
+    }
+  });
+}
+function createMenuRow(disabled) {
+  const level = useContext(MenuLevelContext);
+  let el;
+  const attrs = () => ({
+    tabindex: level.tabStop() === el && el !== void 0 ? `0` : `-1`,
+    "data-orientation": `vertical`,
+    "data-radix-collection-item": ``,
+    "data-highlighted": level.highlighted() === el && el !== void 0 ? `` : void 0,
+    "aria-disabled": disabled() ? `true` : void 0,
+    "data-disabled": disabled() ? `` : void 0
+  });
+  const handlers = {
+    onFocus: () => {
+      level.setHighlighted(el);
+      if (!untrack(disabled)) level.setTabStop(el);
+    },
+    onBlur: () => {
+      if (untrack(level.highlighted) === el) level.setHighlighted(void 0);
+    },
+    onPointerMove: (e) => {
+      if (e.pointerType !== `mouse`) return;
+      if (untrack(disabled)) level.onItemLeave(e);
+      else if (!level.onItemEnter(e)) el?.focus({
+        preventScroll: true
+      });
+    },
+    onPointerLeave: (e) => {
+      if (e.pointerType !== `mouse`) return;
+      level.onItemLeave(e);
+    },
+    onKeyDown: (e) => {
+      if (e.target !== e.currentTarget) return;
+      const intent = e.key === `ArrowUp` ? `prev` : e.key === `ArrowDown` ? `next` : e.key === `Home` || e.key === `PageUp` ? `first` : e.key === `End` || e.key === `PageDown` ? `last` : void 0;
+      if (!intent || e.metaKey || e.ctrlKey || e.altKey || e.shiftKey) return;
+      e.preventDefault();
+      let candidates = itemsOf(level.content()).filter((n) => !n.hasAttribute(`data-disabled`));
+      if (intent === `last`) candidates.reverse();
+      else if (intent === `prev` || intent === `next`) {
+        if (intent === `prev`) candidates.reverse();
+        const at = candidates.indexOf(e.currentTarget);
+        candidates = candidates.slice(at + 1);
+      }
+      focusFirst(candidates);
+    }
+  };
+  return {
+    attrs,
+    handlers,
+    ref: (node) => el = node,
+    level
+  };
+}
+function createSelectable(disabled, onSelect, close) {
+  const row = createMenuRow(disabled);
+  let pointerDownHere = false;
+  const select = () => {
+    if (untrack(disabled)) return;
+    const e = new CustomEvent(`menu.itemSelect`, {
+      bubbles: true,
+      cancelable: true
+    });
+    onSelect(e);
+    if (e.defaultPrevented) pointerDownHere = false;
+    else close();
+  };
+  const handlers = {
+    ...row.handlers,
+    onClick: select,
+    onPointerDown: () => pointerDownHere = true,
+    onPointerUp: (e) => {
+      if (!pointerDownHere) e.currentTarget?.click();
+    },
+    onKeyDown: (e) => {
+      row.handlers.onKeyDown(e);
+      if (e.defaultPrevented) return;
+      const typingAhead = row.level.search() !== ``;
+      if (untrack(disabled) || typingAhead && e.key === ` `) return;
+      if (e.key === `Enter` || e.key === ` `) {
+        e.currentTarget.click();
+        e.preventDefault();
+      }
+    }
+  };
+  return {
+    ...row,
+    handlers
+  };
+}
+const KEY_INTENT = { ArrowLeft: `prev`, ArrowUp: `prev`, ArrowRight: `next`, ArrowDown: `next`, PageUp: `first`, Home: `first`, PageDown: `last`, End: `last` };
+function focusIntent(e, orientation, dir) {
+  let key = e.key;
+  if (dir === `rtl`) key = key === `ArrowLeft` ? `ArrowRight` : key === `ArrowRight` ? `ArrowLeft` : key;
+  if (orientation === `vertical` && (key === `ArrowLeft` || key === `ArrowRight`)) return void 0;
+  if (orientation === `horizontal` && (key === `ArrowUp` || key === `ArrowDown`)) return void 0;
+  return KEY_INTENT[key];
+}
+function rovingFocusFirst(candidates) {
+  const previous = document.activeElement;
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    if (candidate === previous) return;
+    candidate.focus();
+    if (document.activeElement !== previous) return;
+  }
+}
+function createRovingGroup(opts) {
+  const [stop, setStop] = createSignal(null);
+  const [tabbingBackOut, setTabbingBackOut] = createSignal(false);
+  let clickFocus = false;
+  const group = () => ({ tabindex: tabbingBackOut() ? -1 : 0, "data-orientation": opts.orientation });
+  const groupHandlers = {
+    onMouseDown: () => void (clickFocus = true),
+    onFocusIn: (e) => {
+      const keyboard = !clickFocus;
+      if (e.target === e.currentTarget && keyboard && !tabbingBackOut()) {
+        const items = opts.items().filter(opts.focusable);
+        const activeItem = items.find(opts.active);
+        const current = items.find((el) => el === stop());
+        rovingFocusFirst([activeItem, current, ...items].filter((el) => Boolean(el)));
+      }
+      clickFocus = false;
+    },
+    onFocusOut: () => setTabbingBackOut(false)
+  };
+  const item = (el, focusable) => ({
+    tabindex: () => stop() !== null && stop() === el() ? 0 : -1,
+    onMouseDown: (e) => {
+      if (!focusable()) e.preventDefault();
+      else setStop(el() ?? null);
+    },
+    onFocus: () => setStop(el() ?? null),
+    onKeyDown: (e) => {
+      if (e.key === `Tab` && e.shiftKey) {
+        setTabbingBackOut(true);
+        return;
+      }
+      if (e.target !== e.currentTarget) return;
+      const intent = focusIntent(e, opts.orientation, opts.dir());
+      if (intent === void 0) return;
+      if (e.metaKey || e.ctrlKey || e.altKey || e.shiftKey) return;
+      e.preventDefault();
+      let candidates = opts.items().filter(opts.focusable);
+      if (intent === `last`) candidates.reverse();
+      else if (intent === `prev` || intent === `next`) {
+        if (intent === `prev`) candidates.reverse();
+        const at = candidates.indexOf(e.currentTarget);
+        candidates = opts.loop ? wrapArray(candidates, at + 1) : candidates.slice(at + 1);
+      }
+      setTimeout(() => rovingFocusFirst(candidates));
+    }
+  });
+  return { group, groupHandlers, item };
+}
+function createListNavigation(o) {
+  const isDisabled = o.isDisabled ?? (() => false);
+  const labelOf = o.labelOf ?? (() => ``);
+  const typeahead = o.typeahead ?? (() => false);
+  const [active, setActive] = createSignal(o.initial ?? -1);
+  let buffer = { text: ``, at: 0 };
+  createEffect(() => {
+    const count = o.count();
+    if (active() >= count) setActive(count - 1);
+  });
+  const move = (from, delta) => nextEnabledIndex(o.count(), from, delta, isDisabled);
+  const onKeyDown = (e) => {
+    const count = o.count();
+    const a = active();
+    if (e.key === `ArrowDown`) {
+      e.preventDefault();
+      setActive(move(a < 0 ? -1 : a, 1));
+    } else if (e.key === `ArrowUp`) {
+      e.preventDefault();
+      setActive(move(a < 0 ? 0 : a, -1));
+    } else if (e.key === `Home`) {
+      e.preventDefault();
+      setActive(move(-1, 1));
+    } else if (e.key === `End`) {
+      e.preventDefault();
+      setActive(move(0, -1));
+    } else if (e.key === `Enter` || e.key === ` ` && typeahead() && buffer.text === ``) {
+      if (a >= 0 && a < count && !isDisabled(a)) {
+        e.preventDefault();
+        o.onPick(a);
+      }
+    } else if (typeahead() && e.key.length === 1 && !e.metaKey && !e.ctrlKey && !e.altKey) {
+      const step = typeaheadStep(buffer, e.key, Date.now(), a, count, isDisabled, labelOf);
+      buffer = step.buffer;
+      if (step.index >= 0) setActive(step.index);
+    }
+  };
+  return { active, setActive, onKeyDown };
+}
+function createListNavigationSync(o) {
+  const isDisabled = o.isDisabled ?? (() => false);
+  const labelOf = o.labelOf ?? (() => ``);
+  const [active, setActive] = createSignal(o.initial ?? -1);
+  let buffer = { text: ``, at: 0 };
+  createComputed(() => {
+    const c = o.count();
+    if (untrack(active) >= c) setActive(c - 1);
+  });
+  const move = (from, delta) => nextEnabledIndex(o.count(), from, delta, isDisabled);
+  const onKeyDown = (e) => {
+    const count = o.count();
+    const a = active();
+    if (e.key === `ArrowDown`) {
+      e.preventDefault();
+      setActive(move(a < 0 ? -1 : a, 1));
+    } else if (e.key === `ArrowUp`) {
+      e.preventDefault();
+      setActive(move(a < 0 ? 0 : a, -1));
+    } else if (e.key === `Home`) {
+      e.preventDefault();
+      setActive(move(-1, 1));
+    } else if (e.key === `End`) {
+      e.preventDefault();
+      setActive(move(0, -1));
+    } else if (e.key === `Enter` || e.key === ` ` && o.typeahead && buffer.text === ``) {
+      if (a >= 0 && a < count && !isDisabled(a)) {
+        e.preventDefault();
+        o.onPick(a);
+      }
+    } else if (o.typeahead && e.key.length === 1 && !e.metaKey && !e.ctrlKey && !e.altKey) {
+      const step = typeaheadStep(buffer, e.key, Date.now(), a, count, isDisabled, labelOf);
+      buffer = step.buffer;
+      if (step.index >= 0) setActive(step.index);
+    }
+  };
+  return { active, setActive: (i) => setActive(i), onKeyDown };
+}
+const OPEN_KEYS = [` `, `Enter`, `ArrowUp`, `ArrowDown`];
+const SELECTION_KEYS = [` `, `Enter`];
+function createElementSize(el) {
+  const [size2, setSize] = createSignal(void 0, { equals: (a, b) => a?.width === b?.width && a?.height === b?.height });
+  createEffect(() => {
+    const node = el();
+    if (!node) return setSize(void 0);
+    setSize({ width: node.offsetWidth, height: node.offsetHeight });
+    if (typeof ResizeObserver === `undefined`) return;
+    const ro = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (!entry) return;
+      let width;
+      let height;
+      if (`borderBoxSize` in entry && entry.borderBoxSize) {
+        const box = Array.isArray(entry.borderBoxSize) ? entry.borderBoxSize[0] : entry.borderBoxSize;
+        width = box.inlineSize;
+        height = box.blockSize;
+      } else {
+        width = node.offsetWidth;
+        height = node.offsetHeight;
+      }
+      setSize({ width, height });
+    });
+    ro.observe(node, { box: `border-box` });
+    onCleanup(() => ro.unobserve(node));
+  });
+  return size2;
+}
+var _tmpl$ = /* @__PURE__ */ template(`<input aria-hidden=true tabindex=-1>`), _tmpl$2 = /* @__PURE__ */ template(`<input>`), _tmpl$3 = /* @__PURE__ */ template(`<select aria-hidden=true tabindex=-1>`), _tmpl$4 = /* @__PURE__ */ template(`<option value>`), _tmpl$5 = /* @__PURE__ */ template(`<option>`);
+function createInForm(el) {
+  const [inForm, setInForm] = createSignal(false);
+  onMount(() => setInForm(Boolean(el()?.closest(`form`))));
+  return inForm;
+}
+function bubbleOnChange(input, value, apply, event, bubbles = () => true) {
+  createEffect(on(value, (v) => {
+    const el = input();
+    if (!el) return;
+    apply(el, v);
+    el.dispatchEvent(new Event(event, {
+      bubbles: bubbles()
+    }));
+  }, {
+    defer: true
+  }));
+}
+const setChecked = (el, v) => Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, `checked`)?.set?.call(el, v);
+function BubbleCheck(props) {
+  let input;
+  const size2 = createElementSize(() => props.control);
+  const initial = untrack(() => props.checked);
+  bubbleOnChange(() => input, () => props.checked, setChecked, `click`, props.bubbles);
+  const style$1 = () => {
+    const s = size2();
+    const box = s ? {
+      width: s.width,
+      height: s.height
+    } : {};
+    const fixed = {
+      position: `absolute`,
+      pointerEvents: `none`,
+      opacity: 0,
+      margin: 0
+    };
+    return css(props.transformFirst ? {
+      transform: `translateX(-100%)`,
+      ...box,
+      ...fixed
+    } : {
+      ...box,
+      ...fixed,
+      transform: `translateX(-100%)`
+    });
+  };
+  return (() => {
+    var _el$ = _tmpl$();
+    var _ref$ = input;
+    typeof _ref$ === "function" ? use(_ref$, _el$) : input = _el$;
+    setAttribute(_el$, "checked", initial ? `` : void 0);
+    effect((_p$) => {
+      var _v$ = props.type, _v$2 = props.name, _v$3 = props.disabled, _v$4 = style$1();
+      _v$ !== _p$.e && setAttribute(_el$, "type", _p$.e = _v$);
+      _v$2 !== _p$.t && setAttribute(_el$, "name", _p$.t = _v$2);
+      _v$3 !== _p$.a && (_el$.disabled = _p$.a = _v$3);
+      _p$.o = style(_el$, _v$4, _p$.o);
+      return _p$;
+    }, {
+      e: void 0,
+      t: void 0,
+      a: void 0,
+      o: void 0
+    });
+    effect(() => _el$.value = props.value);
+    return _el$;
+  })();
+}
+function SliderBubble(props) {
+  let input;
+  const initial = untrack(() => String(props.value));
+  bubbleOnChange(() => input, () => props.value, (el, v) => Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, `value`)?.set?.call(el, v), `input`);
+  return (() => {
+    var _el$2 = _tmpl$2();
+    var _ref$2 = input;
+    typeof _ref$2 === "function" ? use(_ref$2, _el$2) : input = _el$2;
+    setAttribute(_el$2, "value", initial);
+    effect((_p$) => {
+      var _v$5 = css({
+        display: `none`
+      }), _v$6 = props.name;
+      _p$.e = style(_el$2, _v$5, _p$.e);
+      _v$6 !== _p$.t && setAttribute(_el$2, "name", _p$.t = _v$6);
+      return _p$;
+    }, {
+      e: void 0,
+      t: void 0
+    });
+    return _el$2;
+  })();
+}
+function NativeSelect(props) {
+  let el;
+  const initial = untrack(() => props.value);
+  createEffect(on(() => props.value, (v) => {
+    if (!el) return;
+    Object.getOwnPropertyDescriptor(window.HTMLSelectElement.prototype, `value`)?.set?.call(el, v);
+    el.dispatchEvent(new Event(`change`, {
+      bubbles: true
+    }));
+  }, {
+    defer: true
+  }));
+  const hidden = css({
+    position: `absolute`,
+    border: 0,
+    width: 1,
+    height: 1,
+    padding: 0,
+    margin: -1,
+    overflow: `hidden`,
+    clip: `rect(0, 0, 0, 0)`,
+    whiteSpace: `nowrap`,
+    wordWrap: `normal`
+  });
+  return (() => {
+    var _el$3 = _tmpl$3();
+    _el$3.addEventListener("change", (e) => props.onChange(e.currentTarget.value));
+    var _ref$3 = el;
+    typeof _ref$3 === "function" ? use(_ref$3, _el$3) : el = _el$3;
+    insert(_el$3, initial === void 0 ? _tmpl$4() : null, null);
+    insert(_el$3, createComponent(For, {
+      get each() {
+        return props.options;
+      },
+      children: (o) => (() => {
+        var _el$5 = _tmpl$5();
+        insert(_el$5, () => str(o.label));
+        effect((_p$) => {
+          var _v$0 = bool(o.disabled), _v$1 = initial !== void 0 && o.value === initial ? `` : void 0;
+          _v$0 !== _p$.e && (_el$5.disabled = _p$.e = _v$0);
+          _v$1 !== _p$.t && setAttribute(_el$5, "selected", _p$.t = _v$1);
+          return _p$;
+        }, {
+          e: void 0,
+          t: void 0
+        });
+        effect(() => _el$5.value = o.value);
+        return _el$5;
+      })()
+    }), null);
+    effect((_p$) => {
+      var _v$7 = props.name, _v$8 = props.disabled, _v$9 = hidden;
+      _v$7 !== _p$.e && setAttribute(_el$3, "name", _p$.e = _v$7);
+      _v$8 !== _p$.t && (_el$3.disabled = _p$.t = _v$8);
+      _p$.a = style(_el$3, _v$9, _p$.a);
+      return _p$;
+    }, {
+      e: void 0,
+      t: void 0,
+      a: void 0
+    });
+    return _el$3;
+  })();
+}
+function createImageLoadingStatus(src) {
+  const [status, setStatus] = createSignal(`idle`);
+  const image = typeof window === `undefined` ? null : new window.Image();
+  const resolve = (s) => {
+    if (!image) return `idle`;
+    if (!s) return `error`;
+    if (image.src !== s) image.src = s;
+    return image.complete && image.naturalWidth > 0 ? `loaded` : `loading`;
+  };
+  createComputed(() => setStatus(resolve(src())));
+  if (image) {
+    const loaded = () => setStatus(`loaded`);
+    const errored = () => setStatus(`error`);
+    image.addEventListener(`load`, loaded);
+    image.addEventListener(`error`, errored);
+    onCleanup(() => {
+      image.removeEventListener(`load`, loaded);
+      image.removeEventListener(`error`, errored);
+    });
+  }
+  return status;
+}
+export {
+  findNextItem as A,
+  BubbleCheck as B,
+  CHROME as C,
+  dismissable as D,
+  popperWrapper as E,
+  mountIn as F,
+  SELECTION_KEYS as G,
+  createMediaQuery as H,
+  IconGlyph as I,
+  px as J,
+  KEY_INTENT as K,
+  LayerPortal as L,
+  MenuContent as M,
+  NativeSelect as N,
+  OPEN_KEYS as O,
+  PaintIcon as P,
+  FALLBACK_ICONS as Q,
+  resolveIcon as R,
+  SliderBubble as S,
+  bubbleOnChange as T,
+  focusIntent as U,
+  VisuallyHidden as V,
+  wrapArray as W,
+  styleWriter as X,
+  setChecked as Y,
+  createElementSize$1 as a,
+  createListNavigation as b,
+  css as c,
+  createListNavigationSync as d,
+  createElementSize as e,
+  createInForm as f,
+  createImageLoadingStatus as g,
+  createRovingGroup as h,
+  createPresence as i,
+  createLayer as j,
+  Popper as k,
+  bindStyle as l,
+  LayerContext as m,
+  useKeyboardTracking as n,
+  graceArea as o,
+  createFocusScope as p,
+  useScrollLock as q,
+  rovingFocusFirst as r,
+  useModalEffects as s,
+  transformOrigin as t,
+  useFocusGuards as u,
+  createMenuRow as v,
+  createSelectable as w,
+  popperContentStyle as x,
+  inPolygon as y,
+  radixTypeahead as z
+};
+//# sourceMappingURL=image-loading-status-DZOoj4RQ.js.map