@bolio-ui/core 3.0.5 → 3.1.0

package/esm/chunk-DBXNG475.js

@@ -0,0 +1,27 @@
+// core/use-hover/use-hover.ts
+import { useEffect, useRef, useState } from "react";
+var useHover = () => {
+  const [hovered, setHovered] = useState(false);
+  const ref = useRef(null);
+  useEffect(() => {
+    const node = ref.current;
+    if (!node) return;
+    const enter = () => setHovered(true);
+    const leave = () => setHovered(false);
+    node.addEventListener("mouseenter", enter);
+    node.addEventListener("mouseleave", leave);
+    return () => {
+      node.removeEventListener("mouseenter", enter);
+      node.removeEventListener("mouseleave", leave);
+    };
+  }, []);
+  return { hovered, ref };
+};
+var use_hover_default = useHover;
+
+// core/use-hover/index.ts
+var use_hover_default2 = use_hover_default;
+
+export {
+  use_hover_default2 as use_hover_default
+};

package/esm/chunk-DJ3AH5YZ.js

@@ -0,0 +1,15 @@
+// core/use-mounted/use-mounted.ts
+import { useEffect, useState } from "react";
+var useMounted = () => {
+  const [mounted, setMounted] = useState(false);
+  useEffect(() => setMounted(true), []);
+  return mounted;
+};
+var use_mounted_default = useMounted;
+
+// core/use-mounted/index.ts
+var use_mounted_default2 = use_mounted_default;
+
+export {
+  use_mounted_default2 as use_mounted_default
+};

package/esm/chunk-DZHZXUII.js

@@ -0,0 +1,19 @@
+// core/utils/use-match-media.ts
+import { useEffect, useState } from "react";
+var useMatchMedia = (query, initialValue = false) => {
+  const [matches, setMatches] = useState(initialValue);
+  useEffect(() => {
+    if (typeof window.matchMedia !== "function") return;
+    const list = window.matchMedia(query);
+    const update = () => setMatches(list.matches);
+    update();
+    list.addEventListener("change", update);
+    return () => list.removeEventListener("change", update);
+  }, [query]);
+  return matches;
+};
+var use_match_media_default = useMatchMedia;
+
+export {
+  use_match_media_default
+};

package/esm/{chunk-33BUV2RX.js → chunk-E4LPRAZ6.js}

@@ -1,6 +1,6 @@
 import {
   use_current_state_default
-} from "./chunk-GGD4BGH2.js";
+} from "./chunk-OOU3TSOA.js";
 
 // core/utils/use-current-state.ts
 var use_current_state_default2 = use_current_state_default;

package/esm/{chunk-E5EDUOQT.js → chunk-E5ALJNBL.js}

@@ -1,9 +1,9 @@
 import {
   use_current_state_default
-} from "./chunk-33BUV2RX.js";
+} from "./chunk-E4LPRAZ6.js";
 import {
   addColorAlpha
-} from "./chunk-RZBEZ26A.js";
+} from "./chunk-SELOBD66.js";
 import {
   use_scale_default,
   with_scale_default
@@ -19,7 +19,7 @@ import {
 } from "./chunk-5KUROAEP.js";
 
 // core/Pagination/Pagination.tsx
-import React5, { useCallback as useCallback2, useEffect, useMemo as useMemo3 } from "react";
+import React4, { useCallback as useCallback2, useEffect, useMemo as useMemo3 } from "react";
 
 // core/Pagination/PaginationItem.tsx
 import { useMemo } from "react";
@@ -138,6 +138,7 @@ function PaginationEllipsis({ isBefore, onClick }) {
   return /* @__PURE__ */ jsx4(
     PaginationItem_default,
     {
+      "aria-label": isBefore ? "Previous 5 pages" : "Next 5 pages",
       onClick: (e) => onClick && onClick(e),
       onMouseEnter: () => setShowMore(true),
       onMouseLeave: () => setShowMore(false),
@@ -273,7 +274,7 @@ var Pagination_module_css_default = { "list": "Pagination-module_list__7wh2a", "
 
 // core/Pagination/Pagination.tsx
 import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
-var PaginationComponent = React5.forwardRef(
+var PaginationComponent = React4.forwardRef(
   ({
     page: customPage,
     initialPage = 1,
@@ -290,7 +291,7 @@ var PaginationComponent = React5.forwardRef(
     const [, prevChildren] = pickChild(children, PaginationPrevious_default);
     const [, nextChildren] = pickChild(children, PaginationNext_default);
     const [prevItem, nextItem] = useMemo3(() => {
-      const hasChildren = (c) => React5.Children.count(c) > 0;
+      const hasChildren = (c) => React4.Children.count(c) > 0;
       const prevDefault = /* @__PURE__ */ jsx6(PaginationPrevious_default, { children: "prev" });
       const nextDefault = /* @__PURE__ */ jsx6(PaginationNext_default, { children: "next" });
       return [

package/esm/{chunk-4X4ELIMQ.js → chunk-EENBS2NP.js}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-5KUROAEP.js";
 
 // core/Dropzone/Dropzone.tsx
-import React2, { useState as useState2 } from "react";
+import React, { useState as useState2 } from "react";
 
 // core/Dropzone/DropzoneThumbnail.tsx
 import { useEffect, useState } from "react";
@@ -93,7 +93,7 @@ var matchesAccept = (file, accept) => {
     (token) => token.startsWith(".") ? name.endsWith(token) : token.endsWith("/*") ? file.type.toLowerCase().startsWith(token.slice(0, -1)) : file.type.toLowerCase() === token
   );
 };
-var DropzoneComponent = React2.forwardRef(
+var DropzoneComponent = React.forwardRef(
   ({
     accept,
     multiple = false,

package/esm/{chunk-DEMQXB46.js → chunk-EJZLV52Y.js}

@@ -2,12 +2,12 @@ import {
   ColorPicker_default,
   normalizeHex
 } from "./chunk-OKZRHSSG.js";
+import {
+  getColors
+} from "./chunk-CCKWTHUT.js";
 import {
   InputBlockLabel_default
 } from "./chunk-UOGCO6CV.js";
-import {
-  getColors
-} from "./chunk-KBZEYKCZ.js";
 import {
   use_click_away_default
 } from "./chunk-DGXZP4VJ.js";

package/esm/chunk-EKASDDSU.js

@@ -0,0 +1,25 @@
+// core/use-input-state/use-input-state.ts
+import { useCallback, useState } from "react";
+var isEvent = (value) => typeof value === "object" && value !== null && "currentTarget" in value && "nativeEvent" in value;
+var useInputState = (initialValue) => {
+  const [value, setValue] = useState(initialValue);
+  const onChange = useCallback((next) => {
+    if (isEvent(next)) {
+      const { currentTarget } = next;
+      setValue(
+        currentTarget.type === "checkbox" ? currentTarget.checked : currentTarget.value
+      );
+    } else {
+      setValue(next);
+    }
+  }, []);
+  return [value, onChange];
+};
+var use_input_state_default = useInputState;
+
+// core/use-input-state/index.ts
+var use_input_state_default2 = use_input_state_default;
+
+export {
+  use_input_state_default2 as use_input_state_default
+};

package/esm/chunk-EZL2HZZS.js

@@ -0,0 +1,247 @@
+// core/use-form/use-form.ts
+import { useRef, useState } from "react";
+
+// core/use-form/validators.ts
+var isEmpty = (value) => value === null || value === void 0 || value === false || typeof value === "string" && value.trim().length === 0 || Array.isArray(value) && value.length === 0;
+var isNotEmpty = (message) => (value) => isEmpty(value) ? message : null;
+var isEmail = (message) => (value) => typeof value === "string" && /^\S+@\S+\.\S+$/.test(value.trim()) ? null : message;
+var matches = (pattern, message) => (value) => typeof value === "string" && pattern.test(value) ? null : message;
+var hasLength = (length, message) => (value) => {
+  const size = value == null ? void 0 : value.length;
+  const trimmed = typeof value === "string" ? value.trim().length : size;
+  if (typeof trimmed !== "number") return message;
+  const { min, max } = typeof length === "number" ? { min: length, max: length } : length;
+  if (min !== void 0 && trimmed < min) return message;
+  if (max !== void 0 && trimmed > max) return message;
+  return null;
+};
+var isInRange = ({ min, max }, message) => (value) => {
+  if (typeof value !== "number" || Number.isNaN(value)) return message;
+  if (min !== void 0 && value < min) return message;
+  if (max !== void 0 && value > max) return message;
+  return null;
+};
+var matchesField = (path, message) => (value, values) => value === getPath(values, path) ? null : message;
+var getPath = (source, path) => path.split(".").reduce(
+  (current, key) => current == null ? void 0 : current[key],
+  source
+);
+
+// core/use-form/use-form.ts
+var setPath = (source, path, value) => {
+  const [key, ...rest] = path.split(".");
+  const copy = Array.isArray(source) ? [...source] : { ...source };
+  const current = copy[key];
+  copy[key] = rest.length ? setPath(current != null ? current : {}, rest.join("."), value) : value;
+  return copy;
+};
+var collectErrors = (rules, values, prefix = "", errors = {}) => {
+  Object.entries(rules).forEach(([key, rule]) => {
+    const path = prefix ? `${prefix}.${key}` : key;
+    const value = getPath(values, path);
+    if (typeof rule === "function") {
+      const message = rule(value, values, path);
+      if (message) errors[path] = message;
+    } else if (rule && typeof rule === "object") {
+      const nested = rule;
+      if (Array.isArray(value)) {
+        value.forEach(
+          (_, index) => collectErrors(nested, values, `${path}.${index}`, errors)
+        );
+      } else collectErrors(nested, values, path, errors);
+    }
+  });
+  return errors;
+};
+var without = (errors, path) => Object.fromEntries(
+  Object.entries(errors).filter(
+    ([key]) => key !== path && !key.startsWith(`${path}.`)
+  )
+);
+var useForm = ({
+  initialValues,
+  transformValues,
+  validate: rules,
+  validateInputOnChange = false,
+  validateInputOnBlur = false,
+  clearInputErrorOnChange = true,
+  onValuesChange
+}) => {
+  const [initial, setInitial] = useState(initialValues);
+  const valuesRef = useRef(initialValues);
+  const [values, setValuesState] = useState(initialValues);
+  const [errors, setErrorsState] = useState({});
+  const [touched, setTouched] = useState({});
+  const [submitting, setSubmitting] = useState(false);
+  const commit = (next, notify = true) => {
+    valuesRef.current = next;
+    setValuesState(next);
+    if (notify) onValuesChange == null ? void 0 : onValuesChange(next);
+  };
+  const runRules = (current) => {
+    if (!rules) return {};
+    return typeof rules === "function" ? rules(current) : collectErrors(rules, current);
+  };
+  const shouldCheck = (option, path) => Array.isArray(option) ? option.includes(path) : option;
+  const validateField = (path, current = valuesRef.current) => {
+    const message = runRules(current)[path];
+    setErrorsState((last) => ({
+      ...without(last, path),
+      ...message ? { [path]: message } : {}
+    }));
+    return !message;
+  };
+  const validate = () => {
+    const next = runRules(valuesRef.current);
+    setErrorsState(next);
+    return { hasErrors: Object.keys(next).length > 0, errors: next };
+  };
+  const isValid = (path) => {
+    const found = Object.keys(runRules(valuesRef.current));
+    return path ? !found.some((key) => key === path || key.startsWith(`${path}.`)) : found.length === 0;
+  };
+  const clearFieldError = (path) => setErrorsState((last) => without(last, path));
+  const setFieldValue = (path, value) => {
+    const next = setPath(valuesRef.current, path, value);
+    commit(next);
+    setTouched((last) => ({ ...last, [path]: true }));
+    if (shouldCheck(validateInputOnChange, path)) validateField(path, next);
+    else if (clearInputErrorOnChange) clearFieldError(path);
+  };
+  const editList = (path, edit) => {
+    var _a;
+    const list = (_a = getPath(valuesRef.current, path)) != null ? _a : [];
+    commit(setPath(valuesRef.current, path, edit([...list])));
+    setErrorsState((last) => without(last, path));
+  };
+  const isDirty = (path) => {
+    const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+    return path ? !same(getPath(values, path), getPath(initial, path)) : !same(values, initial);
+  };
+  const reset = () => {
+    commit(initial);
+    setErrorsState({});
+    setTouched({});
+  };
+  const initialize = (next) => {
+    setInitial(next);
+    commit(next, false);
+    setErrorsState({});
+    setTouched({});
+  };
+  const getTransformedValues = (current = valuesRef.current) => transformValues ? transformValues(current) : current;
+  const onSubmit = (handleValues, handleErrors) => async (event) => {
+    event == null ? void 0 : event.preventDefault();
+    const result = validate();
+    if (result.hasErrors)
+      return handleErrors == null ? void 0 : handleErrors(result.errors, valuesRef.current);
+    setSubmitting(true);
+    try {
+      await handleValues(getTransformedValues(), event);
+    } finally {
+      setSubmitting(false);
+    }
+  };
+  function getInputProps(path, { type = "input" } = {}) {
+    const message = errors[path];
+    const value = getPath(values, path);
+    const onBlur = () => {
+      setTouched((last) => ({ ...last, [path]: true }));
+      if (shouldCheck(validateInputOnBlur, path)) validateField(path);
+    };
+    const error = message ? { error: true, errorMessage: message } : {};
+    if (type === "checkbox") {
+      return {
+        checked: Boolean(value),
+        onChange: (event) => setFieldValue(path, event.target.checked),
+        onBlur,
+        ...error
+      };
+    }
+    return {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      value,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      onChange: (arg) => setFieldValue(
+        path,
+        arg && typeof arg === "object" && "target" in arg ? arg.target.value : arg
+      ),
+      onBlur,
+      ...error
+    };
+  }
+  return {
+    values,
+    errors,
+    submitting,
+    getInputProps,
+    onSubmit,
+    onReset: (event) => {
+      event == null ? void 0 : event.preventDefault();
+      reset();
+    },
+    reset,
+    initialize,
+    getValues: () => valuesRef.current,
+    getTransformedValues,
+    setInitialValues: setInitial,
+    resetDirty: (next) => setInitial(next != null ? next : valuesRef.current),
+    resetTouched: () => setTouched({}),
+    validate,
+    validateField,
+    setFieldValue,
+    setValues: (next) => commit({ ...valuesRef.current, ...next }),
+    setErrors: setErrorsState,
+    setFieldError: (path, message) => setErrorsState((last) => ({ ...last, [path]: message })),
+    clearErrors: () => setErrorsState({}),
+    clearFieldError,
+    insertListItem: (path, item, index) => editList(path, (list) => {
+      list.splice(index != null ? index : list.length, 0, item);
+      return list;
+    }),
+    removeListItem: (path, index) => editList(path, (list) => list.filter((_, i) => i !== index)),
+    reorderListItem: (path, { from, to }) => editList(path, (list) => {
+      list.splice(to, 0, list.splice(from, 1)[0]);
+      return list;
+    }),
+    isDirty,
+    isValid,
+    isTouched: (path) => path ? Boolean(touched[path]) : Object.values(touched).some(Boolean),
+    getTouched: () => touched,
+    setFieldTouched: (path, value = true) => setTouched((last) => ({ ...last, [path]: value })),
+    replaceListItem: (path, index, item) => editList(path, (list) => {
+      list[index] = item;
+      return list;
+    })
+  };
+};
+var use_form_default = useForm;
+
+// core/use-form/form-context.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var FormContext = createContext(null);
+var FormProvider = ({
+  form,
+  children
+}) => /* @__PURE__ */ jsx(FormContext.Provider, { value: form, children });
+var useFormContext = () => {
+  const form = useContext(FormContext);
+  if (!form) throw new Error("useFormContext must be used inside FormProvider");
+  return form;
+};
+
+// core/use-form/index.ts
+var use_form_default2 = use_form_default;
+
+export {
+  isNotEmpty,
+  isEmail,
+  matches,
+  hasLength,
+  isInRange,
+  matchesField,
+  FormProvider,
+  useFormContext,
+  use_form_default2 as use_form_default
+};

package/esm/chunk-FDKTLB4T.js

@@ -0,0 +1,68 @@
+// core/use-pagination/use-pagination.ts
+import { useCallback, useState } from "react";
+var range = (start, end) => Array.from({ length: Math.max(end - start + 1, 0) }, (_, i) => start + i);
+var usePagination = ({
+  total,
+  page,
+  initialPage = 1,
+  siblings = 1,
+  boundaries = 1,
+  onChange
+}) => {
+  const pages = Math.max(Math.trunc(total), 0);
+  const [inner, setInner] = useState(initialPage);
+  const active = page != null ? page : inner;
+  const setPage = useCallback(
+    (value) => {
+      const next = Math.min(Math.max(value, 1), pages);
+      setInner(next);
+      if (next !== active) onChange == null ? void 0 : onChange(next);
+    },
+    [pages, active, onChange]
+  );
+  const paginationRange = () => {
+    if (siblings * 2 + 3 + boundaries * 2 >= pages) return range(1, pages);
+    const left = Math.max(active - siblings, boundaries);
+    const right = Math.min(active + siblings, pages - boundaries);
+    const dotsLeft = left > boundaries + 2;
+    const dotsRight = right < pages - (boundaries + 1);
+    if (!dotsLeft && dotsRight) {
+      return [
+        ...range(1, siblings * 2 + boundaries + 2),
+        "dots",
+        ...range(pages - (boundaries - 1), pages)
+      ];
+    }
+    if (dotsLeft && !dotsRight) {
+      return [
+        ...range(1, boundaries),
+        "dots",
+        ...range(pages - (boundaries + 1 + 2 * siblings), pages)
+      ];
+    }
+    return [
+      ...range(1, boundaries),
+      "dots",
+      ...range(left, right),
+      "dots",
+      ...range(pages - boundaries + 1, pages)
+    ];
+  };
+  return {
+    range: paginationRange(),
+    active,
+    setPage,
+    next: () => setPage(active + 1),
+    previous: () => setPage(active - 1),
+    first: () => setPage(1),
+    last: () => setPage(pages)
+  };
+};
+var use_pagination_default = usePagination;
+
+// core/use-pagination/index.ts
+var use_pagination_default2 = use_pagination_default;
+
+export {
+  use_pagination_default2 as use_pagination_default
+};

package/esm/chunk-FFYWCFPP.js

@@ -0,0 +1,25 @@
+// core/use-eye-dropper/use-eye-dropper.ts
+import { useCallback, useEffect, useState } from "react";
+var useEyeDropper = () => {
+  const [supported, setSupported] = useState(false);
+  useEffect(() => {
+    setSupported("EyeDropper" in window);
+  }, []);
+  const open = useCallback(
+    async (options) => {
+      if (!supported) return void 0;
+      const Api = window.EyeDropper;
+      return new Api().open(options);
+    },
+    [supported]
+  );
+  return { supported, open };
+};
+var use_eye_dropper_default = useEyeDropper;
+
+// core/use-eye-dropper/index.ts
+var use_eye_dropper_default2 = use_eye_dropper_default;
+
+export {
+  use_eye_dropper_default2 as use_eye_dropper_default
+};

package/esm/chunk-FQGOZ2IF.js

@@ -0,0 +1,14 @@
+import {
+  use_match_media_default
+} from "./chunk-DZHZXUII.js";
+
+// core/use-reduced-motion/use-reduced-motion.ts
+var useReducedMotion = () => use_match_media_default("(prefers-reduced-motion: reduce)");
+var use_reduced_motion_default = useReducedMotion;
+
+// core/use-reduced-motion/index.ts
+var use_reduced_motion_default2 = use_reduced_motion_default;
+
+export {
+  use_reduced_motion_default2 as use_reduced_motion_default
+};

package/esm/chunk-FU73QPTY.js

@@ -0,0 +1,22 @@
+// core/use-merged-ref/use-merged-ref.ts
+import { useCallback } from "react";
+var assignRef = (ref, value) => {
+  if (typeof ref === "function") ref(value);
+  else if (ref) ref.current = value;
+};
+var mergeRefs = (...refs) => (node) => {
+  refs.forEach((ref) => assignRef(ref, node));
+};
+var useMergedRef = (...refs) => (
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  useCallback(mergeRefs(...refs), refs)
+);
+var use_merged_ref_default = useMergedRef;
+
+// core/use-merged-ref/index.ts
+var use_merged_ref_default2 = use_merged_ref_default;
+
+export {
+  mergeRefs,
+  use_merged_ref_default2 as use_merged_ref_default
+};

package/esm/{chunk-WFGUAR7K.js → chunk-FX6BSJJZ.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-AXYDJGTN.js";
 import {
   use_current_state_default
-} from "./chunk-33BUV2RX.js";
+} from "./chunk-E4LPRAZ6.js";
 import {
   use_latest_default
 } from "./chunk-ZRORQ2WH.js";

package/esm/chunk-FZEN4BUH.js

@@ -0,0 +1,14 @@
+// core/use-force-update/use-force-update.ts
+import { useReducer } from "react";
+var useForceUpdate = () => {
+  const [, forceUpdate] = useReducer((tick) => tick + 1, 0);
+  return forceUpdate;
+};
+var use_force_update_default = useForceUpdate;
+
+// core/use-force-update/index.ts
+var use_force_update_default2 = use_force_update_default;
+
+export {
+  use_force_update_default2 as use_force_update_default
+};

package/esm/{chunk-O3RTRCY5.js → chunk-GUILS62W.js}

@@ -1,9 +1,5 @@
 // core/use-body-scroll/use-body-scroll.ts
-import {
-  useEffect,
-  useRef,
-  useState
-} from "react";
+import { useEffect, useRef, useState } from "react";
 var defaultOptions = {
   scrollLayer: false,
   delayReset: 0

package/esm/{chunk-5JLE7KAC.js → chunk-GWUE2IIS.js}

@@ -1,9 +1,12 @@
 import {
   Tooltip_default
-} from "./chunk-CINBZSC5.js";
+} from "./chunk-VXXNERDY.js";
 import {
   use_latest_default
 } from "./chunk-ZRORQ2WH.js";
+import {
+  activateOnKey
+} from "./chunk-YTIXCWZO.js";
 import {
   use_default_props_default
 } from "./chunk-BSDZWWUS.js";
@@ -166,6 +169,7 @@ function PopoverItemComponent({
       {
         className: classes,
         onClick: clickHandler,
+        ...hasHandler && !line && !title ? { role: "button", tabIndex: 0, onKeyDown: activateOnKey } : {},
         ...props,
         style: { ...itemStyle, ...style },
         children

package/esm/chunk-HUK4C3ZR.js

@@ -0,0 +1,44 @@
+import {
+  use_latest_default
+} from "./chunk-ZRORQ2WH.js";
+
+// core/use-headroom/use-headroom.ts
+import { useEffect, useState } from "react";
+var useHeadroom = ({
+  fixedAt = 10,
+  onPin,
+  onFix,
+  onRelease
+} = {}) => {
+  const [pinned, setPinned] = useState(true);
+  const callbacks = use_latest_default({ onPin, onFix, onRelease });
+  useEffect(() => {
+    let previous = window.scrollY;
+    const update = () => {
+      var _a, _b, _c, _d, _e, _f;
+      const current = window.scrollY;
+      if (current <= fixedAt) {
+        setPinned(true);
+        (_b = (_a = callbacks.current).onFix) == null ? void 0 : _b.call(_a);
+      } else if (current < previous) {
+        setPinned(true);
+        (_d = (_c = callbacks.current).onPin) == null ? void 0 : _d.call(_c);
+      } else if (current > previous) {
+        setPinned(false);
+        (_f = (_e = callbacks.current).onRelease) == null ? void 0 : _f.call(_e);
+      }
+      previous = current;
+    };
+    window.addEventListener("scroll", update, { passive: true });
+    return () => window.removeEventListener("scroll", update);
+  }, [fixedAt, callbacks]);
+  return pinned;
+};
+var use_headroom_default = useHeadroom;
+
+// core/use-headroom/index.ts
+var use_headroom_default2 = use_headroom_default;
+
+export {
+  use_headroom_default2 as use_headroom_default
+};

package/esm/chunk-IP4EY3F3.js

@@ -0,0 +1,17 @@
+import {
+  use_intersection_default
+} from "./chunk-5F7SJI6T.js";
+
+// core/use-in-viewport/use-in-viewport.ts
+var useInViewport = () => {
+  const { ref, entry } = use_intersection_default();
+  return { ref, inViewport: Boolean(entry == null ? void 0 : entry.isIntersecting) };
+};
+var use_in_viewport_default = useInViewport;
+
+// core/use-in-viewport/index.ts
+var use_in_viewport_default2 = use_in_viewport_default;
+
+export {
+  use_in_viewport_default2 as use_in_viewport_default
+};