@enigmax/primitives 0.17.0 → 0.19.0

package/dist/chunk-FWVWX67R.js

@@ -0,0 +1,462 @@
+import { createRecentStore, shortcutLabel, moveActive, groupRows, isPaletteShortcut } from './chunk-DTWZDONY.js';
+import { subsequenceMatcher, createSearch } from './chunk-D5A2ZMAG.js';
+import { Slot } from './chunk-HS3X3XCW.js';
+import { createPortal } from 'react-dom';
+import { createContext, useContext, useState, useRef, useId, useMemo, useCallback, useEffect } from 'react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+var PaletteContext = createContext(null);
+function usePaletteContext(part) {
+  const value = useContext(PaletteContext);
+  if (!value) throw new Error(`<${part}> must be rendered inside <SearchPalette.Root>.`);
+  return value;
+}
+var RECENTS_SHOWN = 5;
+function firstString(item) {
+  if (typeof item === "string") return item;
+  if (item && typeof item === "object") {
+    for (const value of Object.values(item)) {
+      if (typeof value === "string" && value.trim()) return value;
+    }
+  }
+  return "";
+}
+function PaletteRoot({
+  items,
+  keys,
+  fuse,
+  fuseOptions,
+  matcher,
+  delay = 120,
+  limit = 40,
+  groupBy,
+  labelOf = firstString,
+  descriptionOf,
+  sections = [],
+  onSelect,
+  recents = true,
+  recentsKey,
+  recentsLimit = 8,
+  shortcut = "k",
+  open: openProp,
+  onOpenChange,
+  defaultOpen = false,
+  resultsLabel = "Results",
+  recentsLabel = "Recent",
+  children
+}) {
+  const [ownOpen, setOwnOpen] = useState(defaultOpen);
+  const controlled = openProp !== void 0;
+  const open = controlled ? openProp : ownOpen;
+  const [query, setQuery] = useState("");
+  const [active, setActive] = useState(0);
+  const [results, setResults] = useState([]);
+  const [remembered, setRemembered] = useState([]);
+  const [busy, setBusy] = useState(false);
+  const triggerRef = useRef(null);
+  const fieldRef = useRef(null);
+  const base = useId();
+  const ids = useMemo(() => ({ field: `${base}-field`, list: `${base}-list`, title: `${base}-title` }), [base]);
+  const store = useMemo(
+    () => createRecentStore({ key: recentsKey, limit: recentsLimit }),
+    [recentsKey, recentsLimit]
+  );
+  const setOpen = useCallback((next) => {
+    if (!controlled) setOwnOpen(next);
+    onOpenChange?.(next);
+  }, [controlled, onOpenChange]);
+  const ranking = useMemo(
+    () => matcher ?? (fuse ? void 0 : subsequenceMatcher(keys ?? [])),
+    [matcher, fuse, keys]
+  );
+  const engine = useMemo(() => createSearch({
+    items,
+    keys,
+    fuse,
+    fuseOptions,
+    matcher: ranking,
+    debounce: delay,
+    limit,
+    onResults: (next) => {
+      setResults(next);
+      setBusy(false);
+    }
+    // Built once: the engine indexes on construction, so rebuilding it per render would
+    // re-index the whole corpus on every keystroke.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }), []);
+  useEffect(() => () => engine.destroy(), [engine]);
+  useEffect(() => {
+    engine.setItems(items ?? []);
+  }, [engine, items]);
+  useEffect(() => {
+    engine.update({ keys, fuse, fuseOptions, matcher: ranking, debounce: delay, limit });
+  }, [engine, keys, fuse, fuseOptions, ranking, delay, limit]);
+  useEffect(() => {
+    if (!open) return;
+    setRemembered(recents ? store.list() : []);
+    setQuery("");
+    engine.searchNow("");
+    setActive(0);
+  }, [open, recents, store, engine]);
+  useEffect(() => {
+    if (shortcut === null || typeof window === "undefined") return;
+    const onKeyDown = (event) => {
+      if (!isPaletteShortcut(event, shortcut)) return;
+      event.preventDefault();
+      setOpen(!open);
+    };
+    window.addEventListener("keydown", onKeyDown);
+    return () => window.removeEventListener("keydown", onKeyDown);
+  }, [shortcut, open, setOpen]);
+  const rows = useMemo(() => {
+    const trimmed = query.trim();
+    const out = [];
+    if (!trimmed && recents && remembered.length) {
+      remembered.slice(0, RECENTS_SHOWN).forEach((entry, index) => {
+        out.push({
+          id: `recent-${index}`,
+          kind: "recent",
+          group: recentsLabel,
+          recent: entry,
+          label: entry.label ?? entry.term
+        });
+      });
+    }
+    for (const section of sections) {
+      const pool = section.always || !trimmed ? section.items : section.items.filter((item) => labelOf(item).toLowerCase().includes(trimmed.toLowerCase()));
+      pool.forEach((item, index) => {
+        out.push({
+          id: `section-${section.label}-${index}`,
+          kind: "action",
+          group: section.label,
+          item,
+          label: labelOf(item),
+          description: descriptionOf?.(item)
+        });
+      });
+    }
+    results.forEach((match, index) => {
+      out.push({
+        id: `result-${index}`,
+        kind: "item",
+        group: groupBy?.(match.item) ?? resultsLabel,
+        item: match.item,
+        match,
+        label: labelOf(match.item),
+        description: descriptionOf?.(match.item)
+      });
+    });
+    return out;
+  }, [query, recents, remembered, recentsLabel, sections, results, groupBy, labelOf, descriptionOf, resultsLabel]);
+  useEffect(() => {
+    setActive((current) => current < rows.length ? current : 0);
+  }, [rows.length]);
+  const select = useCallback((row) => {
+    if (!row) return;
+    if (row.kind === "recent" && row.recent) {
+      if (!row.recent.href) {
+        setQuery(row.recent.term);
+        setBusy(true);
+        engine.search(row.recent.term);
+        fieldRef.current?.focus();
+        return;
+      }
+    }
+    const stay = row.onSelect ? row.onSelect() : row.item !== void 0 ? onSelect?.(row.item) : void 0;
+    if (recents) {
+      setRemembered(store.remember({
+        term: query.trim(),
+        label: row.label,
+        scope: row.group
+      }));
+    }
+    if (stay !== false) setOpen(false);
+  }, [engine, onSelect, query, recents, setOpen, store]);
+  const handleQuery = useCallback((next) => {
+    setQuery(next);
+    setActive(0);
+    setBusy(Boolean(next.trim()));
+    engine.search(next);
+  }, [engine]);
+  const value = useMemo(() => ({
+    open,
+    setOpen,
+    query,
+    setQuery: handleQuery,
+    rows,
+    active,
+    setActive,
+    select,
+    clearRecents: () => {
+      store.clear();
+      setRemembered([]);
+    },
+    forgetRecent: (entry) => setRemembered(store.forget(entry)),
+    busy,
+    ids,
+    shortcutLabel: shortcutLabel(shortcut ?? "k"),
+    triggerRef,
+    fieldRef,
+    rowId: (row) => `${ids.list}-${row.id}`
+  }), [open, setOpen, query, handleQuery, rows, active, select, busy, ids, shortcut, store]);
+  return /* @__PURE__ */ jsx(PaletteContext.Provider, { value, children });
+}
+function PaletteTrigger({ asChild = false, children, onClick, ...props }) {
+  const palette = usePaletteContext("SearchPalette.Trigger");
+  const Tag = asChild ? Slot : "button";
+  return /* @__PURE__ */ jsx(
+    Tag,
+    {
+      ...asChild ? {} : { type: "button" },
+      ...props,
+      ref: palette.triggerRef,
+      "data-enigma-palette-trigger": "",
+      "aria-haspopup": "dialog",
+      "aria-expanded": palette.open,
+      "aria-keyshortcuts": "Control+K Meta+K",
+      onClick: (event) => {
+        onClick?.(event);
+        if (!event.defaultPrevented) palette.setOpen(true);
+      },
+      children: children ?? /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx("span", { "data-enigma-palette-trigger-label": "", children: "Search" }),
+        /* @__PURE__ */ jsx("kbd", { "data-enigma-palette-trigger-key": "", children: palette.shortcutLabel })
+      ] })
+    }
+  );
+}
+function PaletteContent({ title = "Search", portal = true, overlayProps, closeDuration = 160, children, ...props }) {
+  const palette = usePaletteContext("SearchPalette.Content");
+  const panelRef = useRef(null);
+  const [mounted, setMounted] = useState(false);
+  const [present, setPresent] = useState(palette.open);
+  useEffect(() => setMounted(true), []);
+  useEffect(() => {
+    if (palette.open) {
+      setPresent(true);
+      return;
+    }
+    if (!present) return;
+    const reduced = typeof window !== "undefined" && window.matchMedia?.("(prefers-reduced-motion: reduce)").matches;
+    const timer = setTimeout(() => setPresent(false), reduced ? 0 : closeDuration);
+    return () => clearTimeout(timer);
+  }, [palette.open, present, closeDuration]);
+  useEffect(() => {
+    if (!palette.open || typeof document === "undefined") return;
+    const previous = document.activeElement;
+    const body = document.body;
+    const overflow = body.style.overflow;
+    const gap = window.innerWidth - document.documentElement.clientWidth;
+    const padding = body.style.paddingRight;
+    body.style.overflow = "hidden";
+    if (gap > 0) body.style.paddingRight = `${gap}px`;
+    const onKeyDown = (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        palette.setOpen(false);
+        return;
+      }
+      if (event.key !== "Tab") return;
+      const focusable = panelRef.current?.querySelectorAll(
+        'a[href], button:not([disabled]), input:not([disabled]), [tabindex]:not([tabindex="-1"])'
+      );
+      if (!focusable || focusable.length === 0) return;
+      const first = focusable[0];
+      const last = focusable[focusable.length - 1];
+      if (!event.shiftKey && document.activeElement === last) {
+        event.preventDefault();
+        first.focus();
+      } else if (event.shiftKey && document.activeElement === first) {
+        event.preventDefault();
+        last.focus();
+      }
+    };
+    document.addEventListener("keydown", onKeyDown);
+    return () => {
+      document.removeEventListener("keydown", onKeyDown);
+      body.style.overflow = overflow;
+      body.style.paddingRight = padding;
+      (palette.triggerRef.current ?? previous)?.focus?.();
+    };
+  }, [palette.open, palette.setOpen, palette.triggerRef]);
+  if (!present) return null;
+  const panel = /* @__PURE__ */ jsxs("div", { "data-enigma-palette-portal": "", "data-state": palette.open ? "open" : "closed", children: [
+    overlayProps !== null && /* @__PURE__ */ jsx(
+      "div",
+      {
+        ...overlayProps,
+        "data-enigma-palette-overlay": "",
+        "data-state": palette.open ? "open" : "closed",
+        onClick: (event) => {
+          overlayProps?.onClick?.(event);
+          if (!event.defaultPrevented) palette.setOpen(false);
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ...props,
+        ref: panelRef,
+        role: "dialog",
+        "aria-modal": "true",
+        "aria-labelledby": palette.ids.title,
+        "data-enigma-palette-content": "",
+        "data-state": palette.open ? "open" : "closed",
+        children: [
+          /* @__PURE__ */ jsx("h2", { id: palette.ids.title, "data-enigma-palette-title": "", children: title }),
+          children
+        ]
+      }
+    )
+  ] });
+  if (!portal) return panel;
+  if (!mounted || typeof document === "undefined") return null;
+  return createPortal(panel, document.body);
+}
+function PaletteField({ asChild = false, onKeyDown, ...props }) {
+  const palette = usePaletteContext("SearchPalette.Field");
+  const Tag = asChild ? Slot : "input";
+  const activeRow = palette.rows[palette.active];
+  return /* @__PURE__ */ jsx(
+    Tag,
+    {
+      ...props,
+      ref: palette.fieldRef,
+      id: palette.ids.field,
+      type: "search",
+      value: palette.query,
+      autoFocus: true,
+      autoComplete: "off",
+      autoCorrect: "off",
+      autoCapitalize: "none",
+      spellCheck: false,
+      enterKeyHint: "go",
+      role: "combobox",
+      "aria-expanded": true,
+      "aria-autocomplete": "list",
+      "aria-controls": palette.ids.list,
+      "aria-activedescendant": activeRow ? palette.rowId(activeRow) : void 0,
+      "data-enigma-palette-field": "",
+      onChange: (event) => palette.setQuery(event.target.value),
+      onKeyDown: (event) => {
+        onKeyDown?.(event);
+        if (event.defaultPrevented) return;
+        const key = event.key;
+        if (key === "Enter") {
+          event.preventDefault();
+          palette.select(palette.rows[palette.active]);
+          return;
+        }
+        if (["ArrowDown", "ArrowUp", "Home", "End", "PageDown", "PageUp"].includes(key)) {
+          event.preventDefault();
+          palette.setActive(moveActive(palette.active, palette.rows.length, key));
+        }
+      }
+    }
+  );
+}
+function PaletteList({ children, empty, heading, ...props }) {
+  const palette = usePaletteContext("SearchPalette.List");
+  const listRef = useRef(null);
+  const groups = useMemo(() => groupRows(palette.rows, (row) => row.group), [palette.rows]);
+  useEffect(() => {
+    listRef.current?.querySelector('[data-active="true"]')?.scrollIntoView({ block: "nearest" });
+  }, [palette.active, palette.rows]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ...props,
+      ref: listRef,
+      id: palette.ids.list,
+      role: "listbox",
+      "aria-label": "Results",
+      "data-enigma-palette-list": "",
+      children: palette.rows.length === 0 ? empty ?? /* @__PURE__ */ jsx("p", { "data-enigma-palette-empty": "", children: palette.query.trim() ? `Nothing matches "${palette.query.trim()}".` : "Type to search." }) : groups.map((group) => /* @__PURE__ */ jsxs("div", { role: "group", "aria-label": group.label, "data-enigma-palette-group": "", children: [
+        heading !== null && (heading?.(group.label) ?? // The group carries the name already, so announcing the
+        // heading again would only repeat it.
+        /* @__PURE__ */ jsx("p", { "data-enigma-palette-group-label": "", "aria-hidden": "true", children: group.label })),
+        group.rows.map(({ row, position }) => /* @__PURE__ */ jsx(
+          PaletteItem,
+          {
+            row,
+            index: position,
+            children: children?.(row, { active: position === palette.active, index: position })
+          },
+          row.id
+        ))
+      ] }, group.label))
+    }
+  );
+}
+function PaletteItem({ row, index, children, ...props }) {
+  const palette = usePaletteContext("SearchPalette.Item");
+  const active = index === palette.active;
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ...props,
+      id: palette.rowId(row),
+      role: "option",
+      "aria-selected": active,
+      "data-enigma-palette-item": "",
+      "data-kind": row.kind,
+      "data-active": active ? "true" : void 0,
+      onMouseMove: () => {
+        if (!active) palette.setActive(index);
+      },
+      onClick: () => palette.select(row),
+      children: children ?? /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx("span", { "data-enigma-palette-item-label": "", children: row.label }),
+        row.description && /* @__PURE__ */ jsx("span", { "data-enigma-palette-item-description": "", children: row.description })
+      ] })
+    }
+  );
+}
+function PaletteFooter({ hints, children, ...props }) {
+  usePaletteContext("SearchPalette.Footer");
+  return /* @__PURE__ */ jsx("div", { ...props, "data-enigma-palette-footer": "", children: children ?? hints ?? /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsxs("span", { "data-enigma-palette-hint": "", children: [
+      /* @__PURE__ */ jsx("kbd", { children: "up" }),
+      /* @__PURE__ */ jsx("kbd", { children: "down" }),
+      " to move"
+    ] }),
+    /* @__PURE__ */ jsxs("span", { "data-enigma-palette-hint": "", children: [
+      /* @__PURE__ */ jsx("kbd", { children: "enter" }),
+      " to open"
+    ] }),
+    /* @__PURE__ */ jsxs("span", { "data-enigma-palette-hint": "", children: [
+      /* @__PURE__ */ jsx("kbd", { children: "esc" }),
+      " to close"
+    ] })
+  ] }) });
+}
+function SearchPalette({
+  placeholder = "Search",
+  trigger,
+  renderItem,
+  empty,
+  footer,
+  children,
+  ...root
+}) {
+  return /* @__PURE__ */ jsxs(PaletteRoot, { ...root, children: [
+    trigger !== null && /* @__PURE__ */ jsx(PaletteTrigger, { children: trigger }),
+    /* @__PURE__ */ jsxs(PaletteContent, { children: [
+      /* @__PURE__ */ jsx(PaletteField, { placeholder, "aria-label": placeholder }),
+      /* @__PURE__ */ jsx(PaletteList, { empty, children: renderItem }),
+      footer === null ? null : /* @__PURE__ */ jsx(PaletteFooter, { children: footer })
+    ] }),
+    children
+  ] });
+}
+SearchPalette.Root = PaletteRoot;
+SearchPalette.Trigger = PaletteTrigger;
+SearchPalette.Content = PaletteContent;
+SearchPalette.Field = PaletteField;
+SearchPalette.List = PaletteList;
+SearchPalette.Item = PaletteItem;
+SearchPalette.Footer = PaletteFooter;
+
+export { PaletteContent, PaletteField, PaletteFooter, PaletteItem, PaletteList, PaletteRoot, PaletteTrigger, SearchPalette, usePaletteContext };

package/dist/chunk-HC2ME5PU.js

@@ -0,0 +1,168 @@
+// src/core/password.ts
+var LOWERCASE = "abcdefghijklmnopqrstuvwxyz";
+var UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var DIGITS = "0123456789";
+var SYMBOLS = "!@#$%^&*()-_=+[]{};:,.?";
+var AMBIGUOUS = "Il1O0";
+function randomIndex(bound) {
+  const random = globalThis.crypto?.getRandomValues?.bind(globalThis.crypto);
+  if (!random) {
+    throw new Error("Generating a password needs crypto.getRandomValues, which browsers only expose over HTTPS (or on localhost).");
+  }
+  const limit = Math.floor(2 ** 32 / bound) * bound;
+  const buffer = new Uint32Array(1);
+  let value;
+  do {
+    random(buffer);
+    value = buffer[0];
+  } while (value >= limit);
+  return value % bound;
+}
+function pick(alphabet) {
+  return alphabet[randomIndex(alphabet.length)];
+}
+function classes(options) {
+  const { lowercase = true, uppercase = true, digits = true, symbols = true, excludeAmbiguous = false, exclude = "" } = options;
+  const banned = /* @__PURE__ */ new Set([...excludeAmbiguous ? AMBIGUOUS : "", ...exclude]);
+  const clean = (source) => [...source].filter((character) => !banned.has(character)).join("");
+  return [
+    lowercase ? clean(LOWERCASE) : "",
+    uppercase ? clean(UPPERCASE) : "",
+    digits ? clean(DIGITS) : "",
+    symbols ? clean(SYMBOLS) : ""
+  ].filter(Boolean);
+}
+function shuffle(characters) {
+  for (let index = characters.length - 1; index > 0; index--) {
+    const swap = randomIndex(index + 1);
+    [characters[index], characters[swap]] = [characters[swap], characters[index]];
+  }
+  return characters;
+}
+function generatePassword(options = {}) {
+  const { length = 20, requireEachClass = true } = options;
+  const pools = classes(options);
+  if (!pools.length) throw new Error("generatePassword: every character class was excluded.");
+  if (length < 1) throw new Error("generatePassword: length must be at least 1.");
+  if (requireEachClass && length < pools.length) {
+    throw new Error(`generatePassword: length ${length} cannot hold one character from each of the ${pools.length} classes requested.`);
+  }
+  const everything = pools.join("");
+  const required = requireEachClass ? pools.map(pick) : [];
+  const rest = Array.from({ length: length - required.length }, () => pick(everything));
+  return shuffle([...required, ...rest]).join("");
+}
+var COMMON = /* @__PURE__ */ new Set([
+  "password",
+  "passwd",
+  "123456",
+  "12345678",
+  "123456789",
+  "1234567890",
+  "qwerty",
+  "qwertyuiop",
+  "abc123",
+  "111111",
+  "123123",
+  "admin",
+  "letmein",
+  "welcome",
+  "monkey",
+  "dragon",
+  "sunshine",
+  "iloveyou",
+  "princess",
+  "football",
+  "baseball",
+  "master",
+  "shadow",
+  "superman",
+  "batman",
+  "trustno1",
+  "hello",
+  "freedom",
+  "whatever",
+  "starwars",
+  "changeme",
+  "secret",
+  "login",
+  "root",
+  "toor",
+  "test",
+  "guest",
+  "azerty",
+  "1q2w3e4r",
+  "zaq12wsx"
+]);
+var SEQUENCES = ["abcdefghijklmnopqrstuvwxyz", "0123456789", "qwertyuiop", "asdfghjkl", "zxcvbnm"];
+function poolSize(password) {
+  let size = 0;
+  if (/[a-z]/.test(password)) size += 26;
+  if (/[A-Z]/.test(password)) size += 26;
+  if (/\d/.test(password)) size += 10;
+  if (/[^\w\s]|_/.test(password)) size += SYMBOLS.length;
+  if (/\s/.test(password)) size += 1;
+  return size || 1;
+}
+function longestRun(password) {
+  let longest = 1, run = 1;
+  for (let index = 1; index < password.length; index++) {
+    run = password[index] === password[index - 1] ? run + 1 : 1;
+    longest = Math.max(longest, run);
+  }
+  return longest;
+}
+function longestSequence(password) {
+  const lower = password.toLowerCase();
+  let longest = 0;
+  for (const line of SEQUENCES) {
+    const reversed = [...line].reverse().join("");
+    for (const source of [line, reversed]) {
+      for (let start = 0; start < source.length; start++) {
+        for (let end = source.length; end > start + longest; end--) {
+          if (lower.includes(source.slice(start, end))) {
+            longest = Math.max(longest, end - start);
+            break;
+          }
+        }
+      }
+    }
+  }
+  return longest;
+}
+function core(password) {
+  return password.toLowerCase().replace(/^[^a-z]+/, "").replace(/[^a-z]+$/, "").replace(/[0!@$]/g, (character) => ({ "0": "o", "!": "i", "@": "a", "$": "s" })[character] ?? character);
+}
+function estimatePasswordStrength(password, options = {}) {
+  if (!password) return { score: 0, bits: 0, warnings: [], empty: true };
+  const warnings = [];
+  let bits = password.length * Math.log2(poolSize(password));
+  const stripped = core(password);
+  if (COMMON.has(password.toLowerCase()) || COMMON.has(stripped)) {
+    bits = Math.min(bits, 8);
+    warnings.push("This is one of the most common passwords there is.");
+  }
+  for (const input of options.userInputs ?? []) {
+    const needle = input.trim().toLowerCase();
+    if (needle.length < 4 || !password.toLowerCase().includes(needle)) continue;
+    bits = Math.min(bits, 16);
+    warnings.push("It contains something you already typed on this form.");
+    break;
+  }
+  const run = longestRun(password);
+  if (run >= 3) {
+    bits -= (run - 2) * Math.log2(poolSize(password));
+    warnings.push("A character repeats several times in a row.");
+  }
+  const sequence = longestSequence(password);
+  if (sequence >= 4) {
+    bits -= sequence * Math.log2(poolSize(password)) * 0.75;
+    warnings.push("Part of it runs straight along the keyboard or the alphabet.");
+  }
+  if (password.length < 8) warnings.push("Short passwords fall to a brute force whatever they contain.");
+  bits = Math.max(0, Math.round(bits));
+  const score = bits < 28 ? 0 : bits < 40 ? 1 : bits < 60 ? 2 : bits < 80 ? 3 : 4;
+  return { score, bits, warnings, empty: false };
+}
+
+export { estimatePasswordStrength, generatePassword };

package/dist/chunk-HS3X3XCW.js

@@ -0,0 +1,43 @@
+import { forwardRef, Children, isValidElement, cloneElement } from 'react';
+
+// src/react/slot.tsx
+function composeRefs(...refs) {
+  return (node) => {
+    for (const ref of refs) {
+      if (typeof ref === "function") ref(node);
+      else if (ref) ref.current = node;
+    }
+  };
+}
+function mergeSlotProps(slotProps, childProps) {
+  const merged = { ...slotProps, ...childProps };
+  for (const key of Object.keys(slotProps)) {
+    const slotValue = slotProps[key];
+    const childValue = childProps[key];
+    const isHandler = /^on[A-Z]/.test(key);
+    if (isHandler && typeof slotValue === "function" && typeof childValue === "function") {
+      merged[key] = (...args) => {
+        slotValue(...args);
+        return childValue(...args);
+      };
+    } else if (isHandler && typeof slotValue === "function" && childValue === void 0) {
+      merged[key] = slotValue;
+    } else if (key === "style") {
+      merged[key] = { ...slotValue, ...childValue };
+    } else if (key === "className") {
+      merged[key] = [slotValue, childValue].filter(Boolean).join(" ");
+    }
+  }
+  return merged;
+}
+var Slot = forwardRef(function Slot2({ children, ...slotProps }, forwardedRef) {
+  const child = Children.only(children);
+  if (!isValidElement(child)) return null;
+  const childProps = child.props;
+  const childRef = child.ref;
+  const merged = mergeSlotProps(slotProps, childProps);
+  if (forwardedRef || childRef) merged.ref = composeRefs(forwardedRef, childRef ?? null);
+  return cloneElement(child, merged);
+});
+
+export { Slot, mergeSlotProps };