@therealtinhtute/baroiplayer 1.0.6 → 1.0.8

package/dist/src/hooks/use-enhanced-media-player.js

@@ -1,395 +0,0 @@
-"use client";
-import React, { useCallback, useEffect, useRef, useMemo, useTransition, useOptimistic } from "react";
-import { useMediaStore, useMediaSelector } from "../context/media-context";
-import { useMediaOptimistic } from "./use-media-optimistic";
-import { useMediaActions } from "./use-media-actions";
-// Performance-optimized media player hook with React 19 features
-export function useEnhancedMediaPlayer(options) {
-    const mediaRef = useRef(null);
-    const containerRef = useRef(null);
-    // React 19 concurrent features
-    const [isPending, startTransition] = useTransition();
-    const [isSeeking, startSeekTransition] = useTransition();
-    // Performance monitoring
-    const renderStartTime = React.useRef(0);
-    const frameCount = React.useRef(0);
-    const lastFrameTime = React.useRef(0);
-    // Throttled time update
-    const timeUpdateTimeoutRef = useRef();
-    const lastTimeUpdate = useRef(0);
-    // Store integration
-    const store = useMediaStore();
-    const isEnhanced = 'getOptimisticState' in store;
-    // Select only the state we need to minimize re-renders
-    const isPlaying = useMediaSelector(state => state.isPlaying);
-    const currentTime = useMediaSelector(state => state.currentTime);
-    const duration = useMediaSelector(state => state.duration);
-    const volume = useMediaSelector(state => state.volume);
-    const isMuted = useMediaSelector(state => state.isMuted);
-    const isLoading = useMediaSelector(state => state.isLoading);
-    const isBuffering = useMediaSelector(state => state.isBuffering);
-    const error = useMediaSelector(state => state.error);
-    const buffered = useMediaSelector(state => state.buffered);
-    const isFullscreen = useMediaSelector(state => state.isFullscreen);
-    // Enhanced features if available
-    const enhancedStore = store;
-    const optimisticState = isEnhanced ? useMediaOptimistic(enhancedStore) : null;
-    const actions = isEnhanced ? useMediaActions(enhancedStore) : null;
-    // Performance state
-    const [performanceMetrics, setPerformanceMetrics] = React.useState({
-        frameRate: 0,
-        averageRenderTime: 0,
-        droppedFrames: 0,
-        bufferHealth: 0
-    });
-    // Optimistic state updates for immediate UI feedback
-    const [optimisticVolume, setOptimisticVolume] = useOptimistic(volume, (state, newVolume) => {
-        return Math.max(0, Math.min(1, newVolume));
-    });
-    const [optimisticTime, setOptimisticTime] = useOptimistic(currentTime, (state, newTime) => {
-        return Math.max(0, Math.min(duration || 0, newTime));
-    });
-    // Initialize media element with performance optimizations
-    useEffect(() => {
-        const media = mediaRef.current;
-        if (!media)
-            return;
-        // Set initial properties
-        const initProps = {
-            volume: options.volume,
-            muted: options.muted,
-            autoplay: options.autoPlay,
-            loop: options.loop,
-            preload: options.preload,
-            crossOrigin: options.crossOrigin
-        };
-        Object.entries(initProps).forEach(([key, value]) => {
-            if (value !== undefined) {
-                media[key] = value;
-            }
-        });
-        // Performance optimizations
-        media.setAttribute('preload', options.preloadStrategy === 'eager' ? 'auto' : 'metadata');
-        if (options.bufferingStrategy === 'aggressive') {
-            media.setAttribute('buffered', 'auto');
-        }
-        // Hardware acceleration
-        if (media instanceof HTMLVideoElement) {
-            media.style.willChange = 'transform';
-            media.style.transform = 'translateZ(0)';
-        }
-    }, [
-        options.volume,
-        options.muted,
-        options.autoPlay,
-        options.loop,
-        options.preload,
-        options.crossOrigin,
-        options.preloadStrategy,
-        options.bufferingStrategy
-    ]);
-    // Optimized event handlers with React 19 patterns
-    const handleTimeUpdate = useCallback(() => {
-        const media = mediaRef.current;
-        if (!media)
-            return;
-        const now = performance.now();
-        // Throttle time updates for performance
-        if (options.enableTimeUpdateThrottling !== false) {
-            if (now - lastTimeUpdate.current < (options.timeUpdateThrottleMs || 100)) {
-                return;
-            }
-            lastTimeUpdate.current = now;
-        }
-        startTransition(() => {
-            if (isEnhanced && actions) {
-                actions.setCurrentTime(media.currentTime);
-            }
-        });
-    }, [options.enableTimeUpdateThrottling, options.timeUpdateThrottleMs, isEnhanced, actions]);
-    const handlePlay = useCallback(() => {
-        startTransition(() => {
-            if (isEnhanced && actions) {
-                actions.play(true); // Optimistic update
-            }
-        });
-        options.onPlay?.();
-    }, [isEnhanced, actions, options.onPlay]);
-    const handlePause = useCallback(() => {
-        startTransition(() => {
-            if (isEnhanced && actions) {
-                actions.pause(true); // Optimistic update
-            }
-        });
-        options.onPause?.();
-    }, [isEnhanced, actions, options.onPause]);
-    const handleVolumeChange = useCallback(() => {
-        const media = mediaRef.current;
-        if (!media)
-            return;
-        startTransition(() => {
-            if (isEnhanced && actions) {
-                actions.setVolume(media.volume, true); // Optimistic update
-                media.muted ? actions.mute(true) : actions.unmute(true);
-            }
-        });
-    }, [isEnhanced, actions]);
-    const handleSeeking = useCallback(() => {
-        startSeekTransition(() => {
-            // Seek operations get their own transition
-        });
-    }, []);
-    const handleSeeked = useCallback(() => {
-        // Seek completed
-    }, []);
-    const handleProgress = useCallback(() => {
-        const media = mediaRef.current;
-        if (!media)
-            return;
-        startTransition(() => {
-            if (isEnhanced && actions) {
-                actions.setBuffered(media.buffered);
-            }
-        });
-    }, [isEnhanced, actions]);
-    // Performance monitoring
-    const measureRenderTime = useCallback(() => {
-        const now = performance.now();
-        const deltaTime = now - lastFrameTime.current;
-        if (deltaTime > 0) {
-            frameCount.current++;
-            // Calculate frame rate every second
-            if (frameCount.current >= 60) {
-                const fps = Math.round((frameCount.current * 1000) / (now - lastFrameTime.current));
-                setPerformanceMetrics(prev => ({
-                    ...prev,
-                    frameRate: fps,
-                    droppedFrames: Math.max(0, 60 - fps)
-                }));
-                frameCount.current = 0;
-                lastFrameTime.current = now;
-            }
-        }
-    }, []);
-    // Attach event listeners with performance optimization
-    useEffect(() => {
-        const media = mediaRef.current;
-        if (!media)
-            return;
-        // Use passive listeners where possible for better performance
-        const eventListeners = [
-            { event: "timeupdate", handler: handleTimeUpdate, passive: true },
-            { event: "play", handler: handlePlay },
-            { event: "pause", handler: handlePause },
-            { event: "volumechange", handler: handleVolumeChange },
-            { event: "seeking", handler: handleSeeking },
-            { event: "seeked", handler: handleSeeked },
-            { event: "progress", handler: handleProgress, passive: true },
-            { event: "loadedmetadata", handler: () => measureRenderTime() },
-            { event: "loadeddata", handler: () => measureRenderTime() }
-        ];
-        eventListeners.forEach(({ event, handler, passive }) => {
-            const options = passive ? { passive: true } : {};
-            media.addEventListener(event, handler, options);
-        });
-        // Performance monitoring frame loop
-        let rafId;
-        const performanceLoop = () => {
-            measureRenderTime();
-            rafId = requestAnimationFrame(performanceLoop);
-        };
-        if (options.enablePerformanceMonitoring) {
-            performanceLoop();
-        }
-        return () => {
-            eventListeners.forEach(({ event, handler }) => {
-                media.removeEventListener(event, handler);
-            });
-            if (rafId) {
-                cancelAnimationFrame(rafId);
-            }
-        };
-    }, [
-        handleTimeUpdate,
-        handlePlay,
-        handlePause,
-        handleVolumeChange,
-        handleSeeking,
-        handleSeeked,
-        handleProgress,
-        measureRenderTime,
-        options.enablePerformanceMonitoring
-    ]);
-    // Optimized control functions with React 19 features
-    const controls = useMemo(() => {
-        const play = async () => {
-            const media = mediaRef.current;
-            if (!media)
-                return;
-            if (isEnhanced && actions) {
-                await actions.play(true); // Optimistic
-            }
-            else {
-                try {
-                    await media.play();
-                }
-                catch (error) {
-                    console.error("Failed to play media:", error);
-                }
-            }
-        };
-        const pause = () => {
-            const media = mediaRef.current;
-            if (!media)
-                return;
-            if (isEnhanced && actions) {
-                actions.pause(true); // Optimistic
-            }
-            else {
-                media.pause();
-            }
-        };
-        const toggle = () => {
-            if (isPlaying) {
-                pause();
-            }
-            else {
-                play();
-            }
-        };
-        const seek = (time) => {
-            const media = mediaRef.current;
-            if (!media)
-                return;
-            const clampedTime = Math.max(0, Math.min(time, duration || 0));
-            if (isEnhanced && actions) {
-                startSeekTransition(() => {
-                    actions.seek(clampedTime, true); // Optimistic
-                });
-            }
-            else {
-                media.currentTime = clampedTime;
-            }
-        };
-        const setVolume = (volume) => {
-            const media = mediaRef.current;
-            if (!media)
-                return;
-            const clampedVolume = Math.max(0, Math.min(1, volume));
-            if (isEnhanced && actions) {
-                setOptimisticVolume(clampedVolume);
-                startTransition(() => {
-                    actions.setVolume(clampedVolume, true);
-                });
-            }
-            else {
-                media.volume = clampedVolume;
-            }
-        };
-        const toggleMute = () => {
-            const media = mediaRef.current;
-            if (!media)
-                return;
-            if (isEnhanced && actions) {
-                actions.toggleMute(true); // Optimistic
-            }
-            else {
-                media.muted = !media.muted;
-            }
-        };
-        const enterFullscreen = async () => {
-            const container = containerRef.current;
-            if (!container || !document.fullscreenEnabled)
-                return;
-            try {
-                await container.requestFullscreen();
-                if (isEnhanced && actions) {
-                    actions.enterFullscreen(true);
-                }
-            }
-            catch (error) {
-                console.error("Failed to enter fullscreen:", error);
-            }
-        };
-        const exitFullscreen = async () => {
-            if (!document.fullscreenElement)
-                return;
-            try {
-                await document.exitFullscreen();
-                if (isEnhanced && actions) {
-                    actions.exitFullscreen(true);
-                }
-            }
-            catch (error) {
-                console.error("Failed to exit fullscreen:", error);
-            }
-        };
-        return {
-            play,
-            pause,
-            toggle,
-            seek,
-            setVolume,
-            toggleMute,
-            enterFullscreen,
-            exitFullscreen
-        };
-    }, [
-        isPlaying,
-        duration,
-        isEnhanced,
-        actions,
-        startTransition,
-        startSeekTransition,
-        setOptimisticVolume
-    ]);
-    // Computed state
-    const computedState = useMemo(() => ({
-        isPlaying: optimisticState?.isPlaying ?? isPlaying,
-        currentTime: optimisticState?.currentTime ?? currentTime,
-        duration: optimisticState?.duration ?? duration,
-        volume: optimisticState?.volume ?? optimisticVolume,
-        isMuted: optimisticState?.isMuted ?? isMuted,
-        isLoading: optimisticState?.isBuffering ?? isLoading,
-        isBuffering: optimisticState?.isBuffering ?? isBuffering,
-        error: optimisticState?.error ?? error,
-        buffered: optimisticState?.buffered ?? buffered,
-        isFullscreen: optimisticState?.isFullscreen ?? isFullscreen,
-        progress: duration > 0 ? currentTime / duration : 0,
-        isTransitioning: isPending || isSeeking,
-        canPlay: !isLoading && !isBuffering && !error
-    }), [
-        optimisticState,
-        isPlaying,
-        currentTime,
-        duration,
-        optimisticVolume,
-        isMuted,
-        isLoading,
-        isBuffering,
-        error,
-        buffered,
-        isFullscreen,
-        isPending,
-        isSeeking
-    ]);
-    return {
-        // Refs
-        mediaRef,
-        containerRef,
-        // State
-        state: computedState,
-        actualState: optimisticState?.actualState,
-        // Controls
-        controls,
-        // Performance metrics
-        performanceMetrics,
-        isTransitioning: isPending || isSeeking,
-        // Enhanced features
-        actions: optimisticState?.actions,
-        actionState: optimisticState?.actionState,
-        // Optimistic features
-        optimisticState,
-        isEnhanced
-    };
-}

package/dist/src/hooks/use-intelligent-preloading.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-intelligent-preloading.d.ts","sourceRoot":"","sources":["use-intelligent-preloading.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEvC,UAAU,4BAA4B;IACrC,oCAAoC;IACpC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,kCAAkC;IAClC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,uBAAuB;IACvB,QAAQ,CAAC,EAAE,cAAc,GAAG,UAAU,GAAG,YAAY,CAAC;IACtD,yCAAyC;IACzC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,wCAAwC;IACxC,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB;AAkBD,eAAO,MAAM,wBAAwB,GACpC,SAAS,WAAW,EAAE,EACtB,UAAS,4BAAiC;IAwRzC;;OAEG;4BACqB,MAAM;IAI9B;;OAEG;;wBAlTY,MAAM;sBACR,MAAM;oBACR,MAAM;qBACL,MAAM;oBACP,MAAM;yBACD,MAAM;yBACN,MAAM;;IA+StB;;OAEG;;;;;;;;;;;;;;IAGH;;OAEG;;IAKH;;OAEG;;;;;;;CAUJ,CAAC;AAEF,eAAe,wBAAwB,CAAC"}

package/dist/src/hooks/use-intelligent-preloading.js

@@ -1,258 +0,0 @@
-/**
- * Intelligent Preloading Hook
- * Combines user behavior analysis with network conditions for optimal preloading
- */
-import { useEffect, useRef, useCallback, useMemo } from 'react';
-export const useIntelligentPreloading = (sources, options = {}) => {
-    const { trackUserBehavior = true, adaptToNetwork = true, strategy = 'balanced', maxPreloadItems = 3, preloadRadius = 2, } = options;
-    const userBehaviorRef = useRef({
-        mouseMovements: 0,
-        scrollEvents: 0,
-        keyPresses: 0,
-        focusEvents: 0,
-        timeOnPage: 0,
-        engagementScore: 0,
-        lastInteraction: Date.now(),
-    });
-    const networkInfoRef = useRef(null);
-    const preloadedItemsRef = useRef(new Set());
-    const preloadQueueRef = useRef([]);
-    // Calculate user engagement score
-    const calculateEngagementScore = useCallback(() => {
-        const behavior = userBehaviorRef.current;
-        const timeFactor = Math.min(behavior.timeOnPage / 60000, 1); // Cap at 1 minute
-        const interactionFactor = Math.min((behavior.mouseMovements + behavior.scrollEvents + behavior.keyPresses) / 100, 1);
-        return (timeFactor * 0.4 + interactionFactor * 0.6) * 100;
-    }, []);
-    // Update user behavior tracking
-    const updateUserBehavior = useCallback((type, increment = 1) => {
-        const behavior = userBehaviorRef.current;
-        behavior[type] = typeof behavior[type] === 'number' ? behavior[type] + increment : Date.now();
-        behavior.engagementScore = calculateEngagementScore();
-        behavior.lastInteraction = Date.now();
-    }, [calculateEngagementScore]);
-    // Get current network conditions
-    const getNetworkConditions = useCallback(() => {
-        if (!networkInfoRef.current || !adaptToNetwork) {
-            return { type: 'unknown', downlink: 10, effectiveType: '4g', saveData: false };
-        }
-        const network = networkInfoRef.current;
-        return {
-            type: network.type,
-            downlink: network.downlink || 10,
-            effectiveType: network.effectiveType || '4g',
-            saveData: network.saveData || false,
-            rtt: network.rtt || 100,
-        };
-    }, [adaptToNetwork]);
-    // Determine if a source should be preloaded
-    const shouldPreloadSource = useCallback((source, index, currentIndex = 0) => {
-        // Skip if already preloaded
-        if (preloadedItemsRef.current.has(source.src)) {
-            return { shouldPreload: false, priority: 'low', reason: 'Already preloaded' };
-        }
-        // Check if within preload radius
-        const distance = Math.abs(index - currentIndex);
-        if (distance > preloadRadius) {
-            return { shouldPreload: false, priority: 'low', reason: 'Outside preload radius' };
-        }
-        const behavior = userBehaviorRef.current;
-        const network = getNetworkConditions();
-        const engagementScore = behavior.engagementScore;
-        const timeSinceInteraction = Date.now() - behavior.lastInteraction;
-        // Network-based decisions
-        if (network.saveData) {
-            return { shouldPreload: false, priority: 'low', reason: 'Data saver mode' };
-        }
-        // Strategy-based filtering
-        let shouldPreload = false;
-        let priority = 'medium';
-        let reason = '';
-        switch (strategy) {
-            case 'conservative':
-                shouldPreload = engagementScore > 70 && network.effectiveType !== '2g' && distance === 1;
-                priority = shouldPreload ? 'medium' : 'low';
-                reason = shouldPreload ? 'High engagement and optimal network' : 'Conservative strategy';
-                break;
-            case 'aggressive':
-                shouldPreload = engagementScore > 30 && network.effectiveType !== 'slow-2g';
-                priority = engagementScore > 70 ? 'high' : engagementScore > 50 ? 'medium' : 'low';
-                reason = shouldPreload ? 'Aggressive preloading' : 'Low engagement';
-                break;
-            case 'balanced':
-            default:
-                const networkMultiplier = network.effectiveType === '4g' ? 1 :
-                    network.effectiveType === '3g' ? 0.7 : 0.3;
-                const adjustedScore = engagementScore * networkMultiplier;
-                shouldPreload = adjustedScore > 40 && distance <= 2;
-                priority = adjustedScore > 70 ? 'high' : adjustedScore > 55 ? 'medium' : 'low';
-                reason = shouldPreload ? `Balanced: score ${adjustedScore.toFixed(1)}` : 'Low adjusted score';
-                break;
-        }
-        // Additional heuristics
-        if (shouldPreload) {
-            // Prioritize HLS and adaptive streaming
-            if (source.type === 'hls' || source.type === 'm3u8') {
-                priority = priority === 'low' ? 'medium' : 'high';
-            }
-            // Boost priority for recent user interaction
-            if (timeSinceInteraction < 5000) { // Within 5 seconds
-                priority = 'high';
-                reason += ' + Recent interaction';
-            }
-            // Consider content type (video gets higher priority than audio)
-            if (source.type === 'mp4' || source.type === 'webm') {
-                priority = priority === 'low' ? 'medium' : priority;
-            }
-        }
-        return { shouldPreload, priority, reason };
-    }, [strategy, preloadRadius, getNetworkConditions, calculateEngagementScore]);
-    // Preload a specific source
-    const preloadSource = useCallback(async (source, priority) => {
-        try {
-            // Create a preload link element
-            const link = document.createElement('link');
-            link.rel = 'preload';
-            link.href = source.src;
-            // Determine the correct 'as' attribute
-            switch (source.type) {
-                case 'hls':
-                case 'm3u8':
-                    link.as = 'fetch';
-                    break;
-                case 'mp4':
-                case 'webm':
-                    link.as = 'video';
-                    break;
-                case 'mp3':
-                case 'wav':
-                case 'ogg':
-                    link.as = 'audio';
-                    break;
-                default:
-                    link.as = 'fetch';
-            }
-            link.crossOrigin = 'anonymous';
-            // Add to document head
-            document.head.appendChild(link);
-            // Mark as preloaded
-            preloadedItemsRef.current.add(source.src);
-            console.debug(`Preloaded: ${source.src} (${priority})`);
-            // Cleanup after 30 seconds to prevent memory issues
-            setTimeout(() => {
-                if (document.head.contains(link)) {
-                    document.head.removeChild(link);
-                }
-            }, 30000);
-        }
-        catch (error) {
-            console.warn('Failed to preload source:', source.src, error);
-        }
-    }, []);
-    // Process preload queue
-    const processPreloadQueue = useCallback(() => {
-        if (preloadQueueRef.current.length === 0)
-            return;
-        // Sort by priority (higher number = higher priority)
-        const sortedQueue = [...preloadQueueRef.current].sort((a, b) => b.priority - a.priority);
-        // Take top items based on maxPreloadItems
-        const itemsToPreload = sortedQueue.slice(0, maxPreloadItems);
-        // Clear queue
-        preloadQueueRef.current = [];
-        // Preload items
-        itemsToPreload.forEach(({ source, priority }) => {
-            preloadSource(source, priority);
-        });
-    }, [maxPreloadItems, preloadSource]);
-    // Update preloading decisions
-    const updatePreloading = useCallback((currentIndex = 0) => {
-        preloadQueueRef.current = [];
-        sources.forEach((source, index) => {
-            const decision = shouldPreloadSource(source, index, currentIndex);
-            if (decision.shouldPreload) {
-                const priority = decision.priority === 'high' ? 3 :
-                    decision.priority === 'medium' ? 2 : 1;
-                preloadQueueRef.current.push({ source, priority });
-            }
-        });
-        processPreloadQueue();
-    }, [sources, shouldPreloadSource, processPreloadQueue]);
-    // Set up user behavior tracking
-    useEffect(() => {
-        if (!trackUserBehavior)
-            return;
-        const handleMouseMove = () => updateUserBehavior('mouseMovements');
-        const handleScroll = () => updateUserBehavior('scrollEvents');
-        const handleKeyPress = () => updateUserBehavior('keyPresses');
-        const handleFocus = () => updateUserBehavior('focusEvents');
-        // Add event listeners
-        document.addEventListener('mousemove', handleMouseMove, { passive: true });
-        document.addEventListener('scroll', handleScroll, { passive: true });
-        document.addEventListener('keydown', handleKeyPress, { passive: true });
-        document.addEventListener('focusin', handleFocus, { passive: true });
-        // Update time on page every second
-        const timeInterval = setInterval(() => {
-            updateUserBehavior('timeOnPage', 1);
-        }, 1000);
-        return () => {
-            document.removeEventListener('mousemove', handleMouseMove);
-            document.removeEventListener('scroll', handleScroll);
-            document.removeEventListener('keydown', handleKeyPress);
-            document.removeEventListener('focusin', handleFocus);
-            clearInterval(timeInterval);
-        };
-    }, [trackUserBehavior, updateUserBehavior]);
-    // Set up network monitoring
-    useEffect(() => {
-        if (!adaptToNetwork || !('connection' in navigator))
-            return;
-        const network = navigator.connection;
-        networkInfoRef.current = network;
-        const handleNetworkChange = () => {
-            // Re-evaluate preloading when network conditions change
-            updatePreloading();
-        };
-        network.addEventListener('change', handleNetworkChange);
-        return () => {
-            network.removeEventListener('change', handleNetworkChange);
-        };
-    }, [adaptToNetwork, updatePreloading]);
-    // Initial preloading
-    useEffect(() => {
-        updatePreloading();
-    }, [updatePreloading]);
-    // Memoize return values
-    const controls = useMemo(() => ({
-        /**
-         * Manually trigger preloading for specific index
-         */
-        preloadAtIndex: (index) => {
-            updatePreloading(index);
-        },
-        /**
-         * Get current user behavior data
-         */
-        getUserBehavior: () => ({ ...userBehaviorRef.current }),
-        /**
-         * Get current network conditions
-         */
-        getNetworkConditions: getNetworkConditions,
-        /**
-         * Clear preloaded items cache
-         */
-        clearCache: () => {
-            preloadedItemsRef.current.clear();
-        },
-        /**
-         * Get preloading statistics
-         */
-        getStats: () => ({
-            preloadedItems: preloadedItemsRef.current.size,
-            engagementScore: userBehaviorRef.current.engagementScore,
-            queueLength: preloadQueueRef.current.length,
-            maxPreloadItems,
-        }),
-    }), [updatePreloading, getNetworkConditions, maxPreloadItems]);
-    return controls;
-};
-export default useIntelligentPreloading;

package/dist/src/hooks/use-keyboard-controls.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-keyboard-controls.d.ts","sourceRoot":"","sources":["use-keyboard-controls.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAE3E,UAAU,0BAA0B;IACnC,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,KAAK,EAAE,gBAAgB,CAAA;IACvB,QAAQ,EAAE,mBAAmB,CAAA;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,wBAAgB,mBAAmB,CAAC,EACnC,OAAc,EACd,KAAK,EACL,QAAQ,EACR,QAAa,EACb,UAAgB,EAChB,EAAE,0BAA0B;2BACE,aAAa;EA8F3C"}