domet 1.0.1 → 1.0.3

package/dist/{useScrowl.js → cjs/index.js}

@@ -1,19 +1,28 @@
-import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } from "react";
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var react = require('react');
+
 const DEFAULT_VISIBILITY_THRESHOLD = 0.6;
 const DEFAULT_HYSTERESIS_MARGIN = 150;
 const SCROLL_IDLE_MS = 100;
-const useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
-export function useDomet(sectionIds, containerRef = null, options = {}) {
-    const { offset = 0, offsetRatio = 0.08, debounceMs = 10, visibilityThreshold = DEFAULT_VISIBILITY_THRESHOLD, hysteresisMargin = DEFAULT_HYSTERESIS_MARGIN, behavior = "auto", onActiveChange, onSectionEnter, onSectionLeave, onScrollStart, onScrollEnd, } = options;
-    const _sectionIdsKey = JSON.stringify(sectionIds);
-    const stableSectionIds = useMemo(() => sectionIds, [sectionIds]);
-    const sectionIndexMap = useMemo(() => {
+const useIsomorphicLayoutEffect = typeof window !== "undefined" ? react.useLayoutEffect : react.useEffect;
+function useDomet(sectionIds, containerRef = null, options = {}) {
+    const { offset = 0, offsetRatio = 0.08, debounceMs = 10, visibilityThreshold = DEFAULT_VISIBILITY_THRESHOLD, hysteresisMargin = DEFAULT_HYSTERESIS_MARGIN, behavior = "auto", onActiveChange, onSectionEnter, onSectionLeave, onScrollStart, onScrollEnd } = options;
+    JSON.stringify(sectionIds);
+    const stableSectionIds = react.useMemo(()=>sectionIds, [
+        sectionIds
+    ]);
+    const sectionIndexMap = react.useMemo(()=>{
         const map = new Map();
-        stableSectionIds.forEach((id, i) => map.set(id, i));
+        for(let i = 0; i < stableSectionIds.length; i++){
+            map.set(stableSectionIds[i], i);
+        }
         return map;
-    }, [stableSectionIds]);
-    const [activeId, setActiveId] = useState(stableSectionIds[0] || null);
-    const [scroll, setScroll] = useState({
+    }, [
+        stableSectionIds
+    ]);
+    const [activeId, setActiveId] = react.useState(stableSectionIds[0] || null);
+    const [scroll, setScroll] = react.useState({
         y: 0,
         progress: 0,
         direction: null,
@@ -21,74 +30,79 @@ export function useDomet(sectionIds, containerRef = null, options = {}) {
         isScrolling: false,
         maxScroll: 0,
         viewportHeight: 0,
-        offset: 0,
+        offset: 0
     });
-    const [sections, setSections] = useState({});
-    const [containerElement, setContainerElement] = useState(null);
-    const refs = useRef({});
-    const refCallbacks = useRef({});
-    const activeIdRef = useRef(stableSectionIds[0] || null);
-    const lastScrollY = useRef(0);
-    const lastScrollTime = useRef(Date.now());
-    const rafId = useRef(null);
-    const isThrottled = useRef(false);
-    const throttleTimeoutId = useRef(null);
-    const hasPendingScroll = useRef(false);
-    const isProgrammaticScrolling = useRef(false);
-    const programmaticScrollTimeoutId = useRef(null);
-    const isScrollingRef = useRef(false);
-    const scrollIdleTimeoutRef = useRef(null);
-    const prevSectionsInViewport = useRef(new Set());
-    const recalculateRef = useRef(() => { });
-    const scrollCleanupRef = useRef(null);
-    const callbackRefs = useRef({
+    const [sections, setSections] = react.useState({});
+    const [containerElement, setContainerElement] = react.useState(null);
+    const refs = react.useRef({});
+    const refCallbacks = react.useRef({});
+    const activeIdRef = react.useRef(stableSectionIds[0] || null);
+    const lastScrollY = react.useRef(0);
+    const lastScrollTime = react.useRef(Date.now());
+    const rafId = react.useRef(null);
+    const isThrottled = react.useRef(false);
+    const throttleTimeoutId = react.useRef(null);
+    const hasPendingScroll = react.useRef(false);
+    const isProgrammaticScrolling = react.useRef(false);
+    const programmaticScrollTimeoutId = react.useRef(null);
+    const isScrollingRef = react.useRef(false);
+    const scrollIdleTimeoutRef = react.useRef(null);
+    const prevSectionsInViewport = react.useRef(new Set());
+    const recalculateRef = react.useRef(()=>{});
+    const scrollCleanupRef = react.useRef(null);
+    const callbackRefs = react.useRef({
         onActiveChange,
         onSectionEnter,
         onSectionLeave,
         onScrollStart,
-        onScrollEnd,
+        onScrollEnd
     });
     callbackRefs.current = {
         onActiveChange,
         onSectionEnter,
         onSectionLeave,
         onScrollStart,
-        onScrollEnd,
+        onScrollEnd
     };
-    const getEffectiveOffset = useCallback(() => {
+    const getEffectiveOffset = react.useCallback(()=>{
         return offset;
-    }, [offset]);
-    const getScrollBehavior = useCallback(() => {
+    }, [
+        offset
+    ]);
+    const getScrollBehavior = react.useCallback(()=>{
         if (behavior === "auto") {
-            if (typeof window === "undefined")
-                return "instant";
+            if (typeof window === "undefined") return "instant";
             const prefersReducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
             return prefersReducedMotion ? "instant" : "smooth";
         }
         return behavior;
-    }, [behavior]);
-    useIsomorphicLayoutEffect(() => {
-        const nextContainer = containerRef?.current ?? null;
+    }, [
+        behavior
+    ]);
+    useIsomorphicLayoutEffect(()=>{
+        var _ref;
+        const nextContainer = (_ref = containerRef == null ? void 0 : containerRef.current) != null ? _ref : null;
         if (nextContainer !== containerElement) {
             setContainerElement(nextContainer);
         }
-    }, [containerRef, containerElement]);
-    const registerRef = useCallback((id) => {
+    }, [
+        containerRef,
+        containerElement
+    ]);
+    const registerRef = react.useCallback((id)=>{
         const existing = refCallbacks.current[id];
-        if (existing)
-            return existing;
-        const callback = (el) => {
+        if (existing) return existing;
+        const callback = (el)=>{
             if (el) {
                 refs.current[id] = el;
-            }
-            else {
+            } else {
                 delete refs.current[id];
             }
         };
         refCallbacks.current[id] = callback;
         return callback;
     }, []);
-    const scrollToSection = useCallback((id) => {
+    const scrollToSection = react.useCallback((id)=>{
         if (!stableSectionIds.includes(id)) {
             if (process.env.NODE_ENV !== "production") {
                 console.warn(`[domet] scrollToSection: id "${id}" not in sectionIds`);
@@ -96,12 +110,11 @@ export function useDomet(sectionIds, containerRef = null, options = {}) {
             return;
         }
         const element = refs.current[id];
-        if (!element)
-            return;
+        if (!element) return;
         if (programmaticScrollTimeoutId.current) {
             clearTimeout(programmaticScrollTimeoutId.current);
         }
-        scrollCleanupRef.current?.();
+        scrollCleanupRef.current == null ? void 0 : scrollCleanupRef.current.call(scrollCleanupRef);
         isProgrammaticScrolling.current = true;
         activeIdRef.current = id;
         setActiveId(id);
@@ -109,19 +122,19 @@ export function useDomet(sectionIds, containerRef = null, options = {}) {
         const elementRect = element.getBoundingClientRect();
         const effectiveOffset = getEffectiveOffset() + 10;
         const scrollTarget = container || window;
-        const unlockScroll = () => {
+        const unlockScroll = ()=>{
             isProgrammaticScrolling.current = false;
             if (programmaticScrollTimeoutId.current) {
                 clearTimeout(programmaticScrollTimeoutId.current);
                 programmaticScrollTimeoutId.current = null;
             }
-            requestAnimationFrame(() => {
+            requestAnimationFrame(()=>{
                 recalculateRef.current();
             });
         };
         let debounceTimer = null;
         let isUnlocked = false;
-        const cleanup = () => {
+        const cleanup = ()=>{
             if (debounceTimer) {
                 clearTimeout(debounceTimer);
                 debounceTimer = null;
@@ -132,31 +145,30 @@ export function useDomet(sectionIds, containerRef = null, options = {}) {
             }
             scrollCleanupRef.current = null;
         };
-        const doUnlock = () => {
-            if (isUnlocked)
-                return;
+        const doUnlock = ()=>{
+            if (isUnlocked) return;
             isUnlocked = true;
             cleanup();
             unlockScroll();
         };
-        const resetDebounce = () => {
+        const resetDebounce = ()=>{
             if (debounceTimer) {
                 clearTimeout(debounceTimer);
             }
             debounceTimer = setTimeout(doUnlock, SCROLL_IDLE_MS);
         };
-        const handleScrollActivity = () => {
+        const handleScrollActivity = ()=>{
             resetDebounce();
         };
-        const handleScrollEnd = () => {
+        const handleScrollEnd = ()=>{
             doUnlock();
         };
         scrollTarget.addEventListener("scroll", handleScrollActivity, {
-            passive: true,
+            passive: true
         });
         if ("onscrollend" in scrollTarget) {
             scrollTarget.addEventListener("scrollend", handleScrollEnd, {
-                once: true,
+                once: true
             });
         }
         scrollCleanupRef.current = cleanup;
@@ -166,121 +178,117 @@ export function useDomet(sectionIds, containerRef = null, options = {}) {
             const relativeTop = elementRect.top - containerRect.top + container.scrollTop;
             container.scrollTo({
                 top: relativeTop - effectiveOffset,
-                behavior: scrollBehavior,
+                behavior: scrollBehavior
             });
-        }
-        else {
+        } else {
             const absoluteTop = elementRect.top + window.scrollY;
             window.scrollTo({
                 top: absoluteTop - effectiveOffset,
-                behavior: scrollBehavior,
+                behavior: scrollBehavior
             });
         }
         if (scrollBehavior === "instant") {
             doUnlock();
-        }
-        else {
+        } else {
             resetDebounce();
         }
-    }, [stableSectionIds, containerElement, getEffectiveOffset, getScrollBehavior]);
-    const sectionProps = useCallback((id) => ({
-        id,
-        ref: registerRef(id),
-        "data-domet": id,
-    }), [registerRef]);
-    const navProps = useCallback((id) => ({
-        onClick: () => scrollToSection(id),
-        "aria-current": activeId === id ? "page" : undefined,
-        "data-active": activeId === id,
-    }), [activeId, scrollToSection]);
-    useEffect(() => {
+    }, [
+        stableSectionIds,
+        containerElement,
+        getEffectiveOffset,
+        getScrollBehavior
+    ]);
+    const sectionProps = react.useCallback((id)=>({
+            id,
+            ref: registerRef(id),
+            "data-domet": id
+        }), [
+        registerRef
+    ]);
+    const navProps = react.useCallback((id)=>({
+            onClick: ()=>scrollToSection(id),
+            "aria-current": activeId === id ? "page" : undefined,
+            "data-active": activeId === id
+        }), [
+        activeId,
+        scrollToSection
+    ]);
+    react.useEffect(()=>{
+        var _stableSectionIds_;
         const idsSet = new Set(stableSectionIds);
-        for (const id of Object.keys(refs.current)) {
+        for (const id of Object.keys(refs.current)){
             if (!idsSet.has(id)) {
                 delete refs.current[id];
             }
         }
-        for (const id of Object.keys(refCallbacks.current)) {
+        for (const id of Object.keys(refCallbacks.current)){
             if (!idsSet.has(id)) {
                 delete refCallbacks.current[id];
             }
         }
         const currentActive = activeIdRef.current;
-        const nextActive = currentActive && idsSet.has(currentActive)
-            ? currentActive
-            : (stableSectionIds[0] ?? null);
+        const nextActive = currentActive && idsSet.has(currentActive) ? currentActive : (_stableSectionIds_ = stableSectionIds[0]) != null ? _stableSectionIds_ : null;
         if (nextActive !== currentActive) {
             activeIdRef.current = nextActive;
         }
-        setActiveId((prev) => (prev !== nextActive ? nextActive : prev));
-    }, [stableSectionIds]);
-    const getSectionBounds = useCallback(() => {
+        setActiveId((prev)=>prev !== nextActive ? nextActive : prev);
+    }, [
+        stableSectionIds
+    ]);
+    const getSectionBounds = react.useCallback(()=>{
         const container = containerElement;
         const scrollTop = container ? container.scrollTop : window.scrollY;
         const containerTop = container ? container.getBoundingClientRect().top : 0;
-        return stableSectionIds
-            .map((id) => {
+        return stableSectionIds.map((id)=>{
             const el = refs.current[id];
-            if (!el)
-                return null;
+            if (!el) return null;
             const rect = el.getBoundingClientRect();
-            const relativeTop = container
-                ? rect.top - containerTop + scrollTop
-                : rect.top + window.scrollY;
+            const relativeTop = container ? rect.top - containerTop + scrollTop : rect.top + window.scrollY;
             return {
                 id,
                 top: relativeTop,
                 bottom: relativeTop + rect.height,
-                height: rect.height,
+                height: rect.height
             };
-        })
-            .filter((bounds) => bounds !== null);
-    }, [stableSectionIds, containerElement]);
-    const calculateActiveSection = useCallback(() => {
-        if (isProgrammaticScrolling.current)
-            return;
+        }).filter((bounds)=>bounds !== null);
+    }, [
+        stableSectionIds,
+        containerElement
+    ]);
+    const calculateActiveSection = react.useCallback(()=>{
+        if (isProgrammaticScrolling.current) return;
         const container = containerElement;
         const currentActiveId = activeIdRef.current;
         const now = Date.now();
         const scrollY = container ? container.scrollTop : window.scrollY;
-        const viewportHeight = container
-            ? container.clientHeight
-            : window.innerHeight;
-        const scrollHeight = container
-            ? container.scrollHeight
-            : document.documentElement.scrollHeight;
+        const viewportHeight = container ? container.clientHeight : window.innerHeight;
+        const scrollHeight = container ? container.scrollHeight : document.documentElement.scrollHeight;
         const maxScroll = Math.max(0, scrollHeight - viewportHeight);
         const scrollProgress = maxScroll > 0 ? scrollY / maxScroll : 0;
-        const scrollDirection = scrollY === lastScrollY.current
-            ? null
-            : scrollY > lastScrollY.current
-                ? "down"
-                : "up";
+        const scrollDirection = scrollY === lastScrollY.current ? null : scrollY > lastScrollY.current ? "down" : "up";
         const deltaTime = now - lastScrollTime.current;
         const deltaY = scrollY - lastScrollY.current;
         const velocity = deltaTime > 0 ? Math.abs(deltaY) / deltaTime : 0;
         lastScrollY.current = scrollY;
         lastScrollTime.current = now;
         const sectionBounds = getSectionBounds();
-        if (sectionBounds.length === 0)
-            return;
+        if (sectionBounds.length === 0) return;
         const baseOffset = getEffectiveOffset();
         const effectiveOffset = Math.max(baseOffset, viewportHeight * offsetRatio);
         const triggerLine = scrollY + effectiveOffset;
         const viewportTop = scrollY;
         const viewportBottom = scrollY + viewportHeight;
-        const scores = sectionBounds.map((section) => {
+        const scores = sectionBounds.map((section)=>{
+            var _sectionIndexMap_get;
             const visibleTop = Math.max(section.top, viewportTop);
             const visibleBottom = Math.min(section.bottom, viewportBottom);
             const visibleHeight = Math.max(0, visibleBottom - visibleTop);
             const visibilityRatio = section.height > 0 ? visibleHeight / section.height : 0;
             const visibleInViewportRatio = viewportHeight > 0 ? visibleHeight / viewportHeight : 0;
             const isInViewport = section.bottom > viewportTop && section.top < viewportBottom;
-            const sectionProgress = (() => {
-                if (section.height === 0)
-                    return 0;
+            const sectionProgress = (()=>{
+                if (section.height === 0) return 0;
                 const entryPoint = viewportBottom;
-                const _exitPoint = viewportTop;
                 const totalTravel = viewportHeight + section.height;
                 const traveled = entryPoint - section.top;
                 return Math.max(0, Math.min(1, traveled / totalTravel));
@@ -288,15 +296,11 @@ export function useDomet(sectionIds, containerRef = null, options = {}) {
             let score = 0;
             if (visibilityRatio >= visibilityThreshold) {
                 score += 1000 + visibilityRatio * 500;
-            }
-            else if (isInViewport) {
+            } else if (isInViewport) {
                 score += visibleInViewportRatio * 800;
             }
-            const sectionIndex = sectionIndexMap.get(section.id) ?? 0;
-            if (scrollDirection &&
-                isInViewport &&
-                section.top <= triggerLine &&
-                section.bottom > triggerLine) {
+            const sectionIndex = (_sectionIndexMap_get = sectionIndexMap.get(section.id)) != null ? _sectionIndexMap_get : 0;
+            if (scrollDirection && isInViewport && section.top <= triggerLine && section.bottom > triggerLine) {
                 score += 200;
             }
             score -= sectionIndex * 0.1;
@@ -306,47 +310,43 @@ export function useDomet(sectionIds, containerRef = null, options = {}) {
                 visibilityRatio,
                 isInViewport,
                 bounds: section,
-                progress: sectionProgress,
+                progress: sectionProgress
             };
         });
-        const isAtBottom = scrollY + viewportHeight >= scrollHeight - 5;
-        const isAtTop = scrollY <= 5;
+        const hasScroll = maxScroll > 10;
+        const isAtBottom = hasScroll && scrollY + viewportHeight >= scrollHeight - 5;
+        const isAtTop = hasScroll && scrollY <= 5;
         let newActiveId = null;
         if (isAtBottom && stableSectionIds.length > 0) {
             newActiveId = stableSectionIds[stableSectionIds.length - 1];
-        }
-        else if (isAtTop && stableSectionIds.length > 0) {
+        } else if (isAtTop && stableSectionIds.length > 0) {
             newActiveId = stableSectionIds[0];
-        }
-        else {
-            const visibleScores = scores.filter((s) => s.isInViewport);
+        } else {
+            const visibleScores = scores.filter((s)=>s.isInViewport);
             const candidates = visibleScores.length > 0 ? visibleScores : scores;
-            candidates.sort((a, b) => b.score - a.score);
+            candidates.sort((a, b)=>b.score - a.score);
             if (candidates.length > 0) {
                 const bestCandidate = candidates[0];
-                const currentScore = scores.find((s) => s.id === currentActiveId);
-                const shouldSwitch = !currentScore ||
-                    !currentScore.isInViewport ||
-                    bestCandidate.score > currentScore.score + hysteresisMargin ||
-                    bestCandidate.id === currentActiveId;
+                const currentScore = scores.find((s)=>s.id === currentActiveId);
+                const shouldSwitch = !currentScore || !currentScore.isInViewport || bestCandidate.score > currentScore.score + hysteresisMargin || bestCandidate.id === currentActiveId;
                 newActiveId = shouldSwitch ? bestCandidate.id : currentActiveId;
             }
         }
         if (newActiveId !== currentActiveId) {
             activeIdRef.current = newActiveId;
             setActiveId(newActiveId);
-            callbackRefs.current.onActiveChange?.(newActiveId, currentActiveId);
+            callbackRefs.current.onActiveChange == null ? void 0 : callbackRefs.current.onActiveChange.call(callbackRefs.current, newActiveId, currentActiveId);
         }
-        const currentInViewport = new Set(scores.filter((s) => s.isInViewport).map((s) => s.id));
+        const currentInViewport = new Set(scores.filter((s)=>s.isInViewport).map((s)=>s.id));
         const prevInViewport = prevSectionsInViewport.current;
-        for (const id of currentInViewport) {
+        for (const id of currentInViewport){
             if (!prevInViewport.has(id)) {
-                callbackRefs.current.onSectionEnter?.(id);
+                callbackRefs.current.onSectionEnter == null ? void 0 : callbackRefs.current.onSectionEnter.call(callbackRefs.current, id);
             }
         }
-        for (const id of prevInViewport) {
+        for (const id of prevInViewport){
             if (!currentInViewport.has(id)) {
-                callbackRefs.current.onSectionLeave?.(id);
+                callbackRefs.current.onSectionLeave == null ? void 0 : callbackRefs.current.onSectionLeave.call(callbackRefs.current, id);
             }
         }
         prevSectionsInViewport.current = currentInViewport;
@@ -358,20 +358,20 @@ export function useDomet(sectionIds, containerRef = null, options = {}) {
             isScrolling: isScrollingRef.current,
             maxScroll,
             viewportHeight,
-            offset: effectiveOffset,
+            offset: effectiveOffset
         };
         const newSections = {};
-        for (const s of scores) {
+        for (const s of scores){
             newSections[s.id] = {
                 bounds: {
                     top: s.bounds.top,
                     bottom: s.bounds.bottom,
-                    height: s.bounds.height,
+                    height: s.bounds.height
                 },
                 visibility: Math.round(s.visibilityRatio * 100) / 100,
                 progress: Math.round(s.progress * 100) / 100,
                 isInViewport: s.isInViewport,
-                isActive: s.id === newActiveId,
+                isActive: s.id === newActiveId
             };
         }
         setScroll(newScrollState);
@@ -384,31 +384,37 @@ export function useDomet(sectionIds, containerRef = null, options = {}) {
         visibilityThreshold,
         hysteresisMargin,
         getSectionBounds,
-        containerElement,
+        containerElement
     ]);
     recalculateRef.current = calculateActiveSection;
-    useEffect(() => {
+    react.useEffect(()=>{
         const container = containerElement;
         const scrollTarget = container || window;
-        const scheduleCalculate = () => {
+        const scheduleCalculate = ()=>{
             if (rafId.current) {
                 cancelAnimationFrame(rafId.current);
             }
-            rafId.current = requestAnimationFrame(() => {
+            rafId.current = requestAnimationFrame(()=>{
                 rafId.current = null;
                 calculateActiveSection();
             });
         };
-        const handleScrollEnd = () => {
+        const handleScrollEnd = ()=>{
             isScrollingRef.current = false;
-            setScroll((prev) => ({ ...prev, isScrolling: false }));
-            callbackRefs.current.onScrollEnd?.();
+            setScroll((prev)=>({
+                    ...prev,
+                    isScrolling: false
+                }));
+            callbackRefs.current.onScrollEnd == null ? void 0 : callbackRefs.current.onScrollEnd.call(callbackRefs.current);
         };
-        const handleScroll = () => {
+        const handleScroll = ()=>{
             if (!isScrollingRef.current) {
                 isScrollingRef.current = true;
-                setScroll((prev) => ({ ...prev, isScrolling: true }));
-                callbackRefs.current.onScrollStart?.();
+                setScroll((prev)=>({
+                        ...prev,
+                        isScrolling: true
+                    }));
+                callbackRefs.current.onScrollStart == null ? void 0 : callbackRefs.current.onScrollStart.call(callbackRefs.current);
             }
             if (scrollIdleTimeoutRef.current) {
                 clearTimeout(scrollIdleTimeoutRef.current);
@@ -424,7 +430,7 @@ export function useDomet(sectionIds, containerRef = null, options = {}) {
                 clearTimeout(throttleTimeoutId.current);
             }
             scheduleCalculate();
-            throttleTimeoutId.current = setTimeout(() => {
+            throttleTimeoutId.current = setTimeout(()=>{
                 isThrottled.current = false;
                 throttleTimeoutId.current = null;
                 if (hasPendingScroll.current) {
@@ -433,16 +439,20 @@ export function useDomet(sectionIds, containerRef = null, options = {}) {
                 }
             }, debounceMs);
         };
-        const handleResize = () => {
+        const handleResize = ()=>{
             scheduleCalculate();
         };
         calculateActiveSection();
-        const deferredRecalcId = setTimeout(() => {
+        const deferredRecalcId = setTimeout(()=>{
             calculateActiveSection();
         }, 0);
-        scrollTarget.addEventListener("scroll", handleScroll, { passive: true });
-        window.addEventListener("resize", handleResize, { passive: true });
-        return () => {
+        scrollTarget.addEventListener("scroll", handleScroll, {
+            passive: true
+        });
+        window.addEventListener("resize", handleResize, {
+            passive: true
+        });
+        return ()=>{
             clearTimeout(deferredRecalcId);
             scrollTarget.removeEventListener("scroll", handleScroll);
             window.removeEventListener("resize", handleResize);
@@ -462,18 +472,25 @@ export function useDomet(sectionIds, containerRef = null, options = {}) {
                 clearTimeout(scrollIdleTimeoutRef.current);
                 scrollIdleTimeoutRef.current = null;
             }
-            scrollCleanupRef.current?.();
+            scrollCleanupRef.current == null ? void 0 : scrollCleanupRef.current.call(scrollCleanupRef);
             isThrottled.current = false;
             hasPendingScroll.current = false;
             isProgrammaticScrolling.current = false;
             isScrollingRef.current = false;
         };
-    }, [calculateActiveSection, debounceMs, containerElement]);
-    const activeIndex = useMemo(() => {
-        if (!activeId)
-            return -1;
-        return sectionIndexMap.get(activeId) ?? -1;
-    }, [activeId, sectionIndexMap]);
+    }, [
+        calculateActiveSection,
+        debounceMs,
+        containerElement
+    ]);
+    const activeIndex = react.useMemo(()=>{
+        var _sectionIndexMap_get;
+        if (!activeId) return -1;
+        return (_sectionIndexMap_get = sectionIndexMap.get(activeId)) != null ? _sectionIndexMap_get : -1;
+    }, [
+        activeId,
+        sectionIndexMap
+    ]);
     return {
         activeId,
         activeIndex,
@@ -482,7 +499,9 @@ export function useDomet(sectionIds, containerRef = null, options = {}) {
         registerRef,
         scrollToSection,
         sectionProps,
-        navProps,
+        navProps
     };
 }
-export default useDomet;
+
+exports.default = useDomet;
+exports.useDomet = useDomet;