@rakeyshgidwani/roger-ui-bank-theme-jeremy 0.5.3

package/dist/hooks/use-battery-optimization.esm.js

@@ -0,0 +1,268 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+export const useBatteryOptimization = (config = {}, callbacks = {}) => {
+    const { enableBatteryMonitoring = true, enablePerformanceThrottling = true, enableUserPreferences = true, enableAdaptiveOptimization = true, lowBatteryThreshold = 0.2, criticalBatteryThreshold = 0.1, userPreferenceLevel = 'balanced' } = config;
+    const [batteryStatus, setBatteryStatus] = useState({
+        level: 1,
+        charging: false,
+        chargingTime: 0,
+        dischargingTime: 0,
+        isLow: false,
+        isCritical: false
+    });
+    const [isOptimizing, setIsOptimizing] = useState(false);
+    const [optimizations, setOptimizations] = useState([]);
+    const [currentThrottleLevel, setCurrentThrottleLevel] = useState('none');
+    const [userPreferences, setUserPreferences] = useState(userPreferenceLevel);
+    const batteryRef = useRef(null);
+    const batteryCheckIntervalRef = useRef(null);
+    const optimizationTimerRef = useRef(null);
+    // Get battery status
+    const getBatteryStatus = useCallback(async () => {
+        if (!enableBatteryMonitoring || !('getBattery' in navigator))
+            return null;
+        try {
+            const battery = await navigator.getBattery();
+            batteryRef.current = battery;
+            const status = {
+                level: battery.level,
+                charging: battery.charging,
+                chargingTime: battery.chargingTime,
+                dischargingTime: battery.dischargingTime,
+                isLow: battery.level <= lowBatteryThreshold,
+                isCritical: battery.level <= criticalBatteryThreshold
+            };
+            setBatteryStatus(status);
+            callbacks.onBatteryStatusChange?.(status);
+            // Check for warnings
+            if (status.isCritical) {
+                callbacks.onCriticalBatteryWarning?.(status);
+            }
+            else if (status.isLow) {
+                callbacks.onLowBatteryWarning?.(status);
+            }
+            return status;
+        }
+        catch (error) {
+            console.warn('Battery API not available:', error);
+            return null;
+        }
+    }, [enableBatteryMonitoring, lowBatteryThreshold, criticalBatteryThreshold, callbacks]);
+    // Apply performance throttling based on battery level
+    const applyPerformanceThrottling = useCallback((level) => {
+        if (!enablePerformanceThrottling)
+            return;
+        setIsOptimizing(true);
+        setCurrentThrottleLevel(level);
+        setTimeout(() => {
+            let optimizations = [];
+            switch (level) {
+                case 'light':
+                    optimizations = [
+                        'Light performance throttling applied',
+                        'Animation complexity reduced by 20%',
+                        'Hardware acceleration optimized for battery'
+                    ];
+                    break;
+                case 'moderate':
+                    optimizations = [
+                        'Moderate performance throttling applied',
+                        'Animation complexity reduced by 40%',
+                        'GPU utilization limited for battery efficiency',
+                        'Non-essential animations disabled'
+                    ];
+                    break;
+                case 'aggressive':
+                    optimizations = [
+                        'Aggressive performance throttling applied',
+                        'Animation complexity reduced by 70%',
+                        'Hardware acceleration minimized',
+                        'Only essential animations enabled',
+                        'Background processes optimized'
+                    ];
+                    break;
+                default:
+                    optimizations = ['Performance throttling disabled'];
+            }
+            setOptimizations(prev => [...prev, ...optimizations]);
+            setIsOptimizing(false);
+            callbacks.onPerformanceThrottled?.(level, 'Battery optimization');
+            optimizations.forEach(optimization => {
+                callbacks.onOptimizationApplied?.(optimization);
+            });
+        }, 300);
+    }, [enablePerformanceThrottling, callbacks]);
+    // Apply battery optimizations
+    const applyBatteryOptimizations = useCallback(() => {
+        if (!enableAdaptiveOptimization)
+            return;
+        setIsOptimizing(true);
+        setTimeout(() => {
+            const optimizations = [];
+            if (batteryStatus.isCritical) {
+                optimizations.push('Critical battery mode: Maximum power saving enabled');
+                optimizations.push('All non-essential features disabled');
+                optimizations.push('Hardware acceleration completely disabled');
+                applyPerformanceThrottling('aggressive');
+            }
+            else if (batteryStatus.isLow) {
+                optimizations.push('Low battery mode: Enhanced power saving enabled');
+                optimizations.push('Performance throttling applied');
+                optimizations.push('Hardware acceleration optimized for battery');
+                applyPerformanceThrottling('moderate');
+            }
+            else if (batteryStatus.level < 0.5) {
+                optimizations.push('Medium battery: Light optimization applied');
+                optimizations.push('Hardware acceleration optimized');
+                applyPerformanceThrottling('light');
+            }
+            else {
+                optimizations.push('High battery: Performance mode enabled');
+                optimizations.push('Hardware acceleration at full capacity');
+                applyPerformanceThrottling('none');
+            }
+            setOptimizations(prev => [...prev, ...optimizations]);
+            setIsOptimizing(false);
+            optimizations.forEach(optimization => {
+                callbacks.onOptimizationApplied?.(optimization);
+            });
+        }, 200);
+    }, [enableAdaptiveOptimization, batteryStatus, applyPerformanceThrottling, callbacks]);
+    // Handle user preferences
+    const updateUserPreferences = useCallback((preference) => {
+        if (!enableUserPreferences)
+            return;
+        setUserPreferences(preference);
+        let optimizations = [];
+        switch (preference) {
+            case 'performance':
+                optimizations = [
+                    'User preference: Performance mode enabled',
+                    'Hardware acceleration at maximum',
+                    'Battery optimization disabled'
+                ];
+                applyPerformanceThrottling('none');
+                break;
+            case 'balanced':
+                optimizations = [
+                    'User preference: Balanced mode enabled',
+                    'Hardware acceleration optimized',
+                    'Battery and performance balanced'
+                ];
+                applyPerformanceThrottling('light');
+                break;
+            case 'battery':
+                optimizations = [
+                    'User preference: Battery saver mode enabled',
+                    'Hardware acceleration optimized for battery',
+                    'Performance throttling applied'
+                ];
+                applyPerformanceThrottling('moderate');
+                break;
+        }
+        setOptimizations(prev => [...prev, ...optimizations]);
+        optimizations.forEach(optimization => {
+            callbacks.onOptimizationApplied?.(optimization);
+        });
+    }, [enableUserPreferences, applyPerformanceThrottling, callbacks]);
+    // Get optimization recommendations
+    const getOptimizationRecommendations = useCallback(() => {
+        const recommendations = [];
+        if (batteryStatus.isCritical) {
+            recommendations.push('Critical battery: Disable all non-essential features');
+            recommendations.push('Reduce screen brightness and disable animations');
+            recommendations.push('Close unnecessary applications and tabs');
+        }
+        else if (batteryStatus.isLow) {
+            recommendations.push('Low battery: Enable battery saver mode');
+            recommendations.push('Reduce animation complexity and GPU usage');
+            recommendations.push('Optimize background processes');
+        }
+        else if (batteryStatus.level < 0.5) {
+            recommendations.push('Medium battery: Consider light optimizations');
+            recommendations.push('Monitor hardware acceleration usage');
+            recommendations.push('Balance performance and battery life');
+        }
+        else {
+            recommendations.push('High battery: Full performance available');
+            recommendations.push('Hardware acceleration at maximum capacity');
+            recommendations.push('Monitor for optimal performance');
+        }
+        return recommendations;
+    }, [batteryStatus]);
+    // Initialize battery monitoring
+    useEffect(() => {
+        if (!enableBatteryMonitoring)
+            return;
+        try {
+            // Get initial battery status
+            getBatteryStatus();
+            // Set up battery monitoring interval
+            batteryCheckIntervalRef.current = window.setInterval(getBatteryStatus, 10000); // Check every 10 seconds
+            return () => {
+                if (batteryCheckIntervalRef.current) {
+                    clearInterval(batteryCheckIntervalRef.current);
+                }
+            };
+        }
+        catch (error) {
+            console.warn('Battery optimization initialization failed:', error);
+        }
+    }, [enableBatteryMonitoring, getBatteryStatus]);
+    // Apply optimizations when battery status changes
+    useEffect(() => {
+        if (enableAdaptiveOptimization) {
+            applyBatteryOptimizations();
+        }
+    }, [enableAdaptiveOptimization, applyBatteryOptimizations]);
+    // Set initial user preferences
+    useEffect(() => {
+        if (enableUserPreferences) {
+            updateUserPreferences(userPreferenceLevel);
+        }
+    }, [enableUserPreferences, userPreferenceLevel, updateUserPreferences]);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            if (batteryCheckIntervalRef.current) {
+                clearInterval(batteryCheckIntervalRef.current);
+            }
+            if (optimizationTimerRef.current) {
+                clearTimeout(optimizationTimerRef.current);
+            }
+        };
+    }, []);
+    return {
+        // State
+        batteryStatus,
+        isOptimizing,
+        optimizations,
+        currentThrottleLevel,
+        userPreferences,
+        // Actions
+        getBatteryStatus,
+        applyPerformanceThrottling,
+        applyBatteryOptimizations,
+        updateUserPreferences,
+        // Computed values
+        isLowBattery: batteryStatus.isLow,
+        isCriticalBattery: batteryStatus.isCritical,
+        batteryPercentage: Math.round(batteryStatus.level * 100),
+        optimizationRecommendations: getOptimizationRecommendations(),
+        isCharging: batteryStatus.charging,
+        estimatedTimeRemaining: batteryStatus.charging ?
+            batteryStatus.chargingTime : batteryStatus.dischargingTime,
+        // Utility functions
+        getBatteryHealth: () => {
+            if (batteryStatus.level >= 0.8)
+                return 'excellent';
+            if (batteryStatus.level >= 0.6)
+                return 'good';
+            if (batteryStatus.level >= 0.4)
+                return 'fair';
+            if (batteryStatus.level >= 0.2)
+                return 'poor';
+            return 'critical';
+        }
+    };
+};
+export default useBatteryOptimization;

package/dist/hooks/use-battery-optimization.js

@@ -0,0 +1,268 @@
+import { useState, useEffect, useCallback, useRef } from 'react';
+export const useBatteryOptimization = (config = {}, callbacks = {}) => {
+    const { enableBatteryMonitoring = true, enablePerformanceThrottling = true, enableUserPreferences = true, enableAdaptiveOptimization = true, lowBatteryThreshold = 0.2, criticalBatteryThreshold = 0.1, userPreferenceLevel = 'balanced' } = config;
+    const [batteryStatus, setBatteryStatus] = useState({
+        level: 1,
+        charging: false,
+        chargingTime: 0,
+        dischargingTime: 0,
+        isLow: false,
+        isCritical: false
+    });
+    const [isOptimizing, setIsOptimizing] = useState(false);
+    const [optimizations, setOptimizations] = useState([]);
+    const [currentThrottleLevel, setCurrentThrottleLevel] = useState('none');
+    const [userPreferences, setUserPreferences] = useState(userPreferenceLevel);
+    const batteryRef = useRef(null);
+    const batteryCheckIntervalRef = useRef(null);
+    const optimizationTimerRef = useRef(null);
+    // Get battery status
+    const getBatteryStatus = useCallback(async () => {
+        if (!enableBatteryMonitoring || !('getBattery' in navigator))
+            return null;
+        try {
+            const battery = await navigator.getBattery();
+            batteryRef.current = battery;
+            const status = {
+                level: battery.level,
+                charging: battery.charging,
+                chargingTime: battery.chargingTime,
+                dischargingTime: battery.dischargingTime,
+                isLow: battery.level <= lowBatteryThreshold,
+                isCritical: battery.level <= criticalBatteryThreshold
+            };
+            setBatteryStatus(status);
+            callbacks.onBatteryStatusChange?.(status);
+            // Check for warnings
+            if (status.isCritical) {
+                callbacks.onCriticalBatteryWarning?.(status);
+            }
+            else if (status.isLow) {
+                callbacks.onLowBatteryWarning?.(status);
+            }
+            return status;
+        }
+        catch (error) {
+            console.warn('Battery API not available:', error);
+            return null;
+        }
+    }, [enableBatteryMonitoring, lowBatteryThreshold, criticalBatteryThreshold, callbacks]);
+    // Apply performance throttling based on battery level
+    const applyPerformanceThrottling = useCallback((level) => {
+        if (!enablePerformanceThrottling)
+            return;
+        setIsOptimizing(true);
+        setCurrentThrottleLevel(level);
+        setTimeout(() => {
+            let optimizations = [];
+            switch (level) {
+                case 'light':
+                    optimizations = [
+                        'Light performance throttling applied',
+                        'Animation complexity reduced by 20%',
+                        'Hardware acceleration optimized for battery'
+                    ];
+                    break;
+                case 'moderate':
+                    optimizations = [
+                        'Moderate performance throttling applied',
+                        'Animation complexity reduced by 40%',
+                        'GPU utilization limited for battery efficiency',
+                        'Non-essential animations disabled'
+                    ];
+                    break;
+                case 'aggressive':
+                    optimizations = [
+                        'Aggressive performance throttling applied',
+                        'Animation complexity reduced by 70%',
+                        'Hardware acceleration minimized',
+                        'Only essential animations enabled',
+                        'Background processes optimized'
+                    ];
+                    break;
+                default:
+                    optimizations = ['Performance throttling disabled'];
+            }
+            setOptimizations(prev => [...prev, ...optimizations]);
+            setIsOptimizing(false);
+            callbacks.onPerformanceThrottled?.(level, 'Battery optimization');
+            optimizations.forEach(optimization => {
+                callbacks.onOptimizationApplied?.(optimization);
+            });
+        }, 300);
+    }, [enablePerformanceThrottling, callbacks]);
+    // Apply battery optimizations
+    const applyBatteryOptimizations = useCallback(() => {
+        if (!enableAdaptiveOptimization)
+            return;
+        setIsOptimizing(true);
+        setTimeout(() => {
+            const optimizations = [];
+            if (batteryStatus.isCritical) {
+                optimizations.push('Critical battery mode: Maximum power saving enabled');
+                optimizations.push('All non-essential features disabled');
+                optimizations.push('Hardware acceleration completely disabled');
+                applyPerformanceThrottling('aggressive');
+            }
+            else if (batteryStatus.isLow) {
+                optimizations.push('Low battery mode: Enhanced power saving enabled');
+                optimizations.push('Performance throttling applied');
+                optimizations.push('Hardware acceleration optimized for battery');
+                applyPerformanceThrottling('moderate');
+            }
+            else if (batteryStatus.level < 0.5) {
+                optimizations.push('Medium battery: Light optimization applied');
+                optimizations.push('Hardware acceleration optimized');
+                applyPerformanceThrottling('light');
+            }
+            else {
+                optimizations.push('High battery: Performance mode enabled');
+                optimizations.push('Hardware acceleration at full capacity');
+                applyPerformanceThrottling('none');
+            }
+            setOptimizations(prev => [...prev, ...optimizations]);
+            setIsOptimizing(false);
+            optimizations.forEach(optimization => {
+                callbacks.onOptimizationApplied?.(optimization);
+            });
+        }, 200);
+    }, [enableAdaptiveOptimization, batteryStatus, applyPerformanceThrottling, callbacks]);
+    // Handle user preferences
+    const updateUserPreferences = useCallback((preference) => {
+        if (!enableUserPreferences)
+            return;
+        setUserPreferences(preference);
+        let optimizations = [];
+        switch (preference) {
+            case 'performance':
+                optimizations = [
+                    'User preference: Performance mode enabled',
+                    'Hardware acceleration at maximum',
+                    'Battery optimization disabled'
+                ];
+                applyPerformanceThrottling('none');
+                break;
+            case 'balanced':
+                optimizations = [
+                    'User preference: Balanced mode enabled',
+                    'Hardware acceleration optimized',
+                    'Battery and performance balanced'
+                ];
+                applyPerformanceThrottling('light');
+                break;
+            case 'battery':
+                optimizations = [
+                    'User preference: Battery saver mode enabled',
+                    'Hardware acceleration optimized for battery',
+                    'Performance throttling applied'
+                ];
+                applyPerformanceThrottling('moderate');
+                break;
+        }
+        setOptimizations(prev => [...prev, ...optimizations]);
+        optimizations.forEach(optimization => {
+            callbacks.onOptimizationApplied?.(optimization);
+        });
+    }, [enableUserPreferences, applyPerformanceThrottling, callbacks]);
+    // Get optimization recommendations
+    const getOptimizationRecommendations = useCallback(() => {
+        const recommendations = [];
+        if (batteryStatus.isCritical) {
+            recommendations.push('Critical battery: Disable all non-essential features');
+            recommendations.push('Reduce screen brightness and disable animations');
+            recommendations.push('Close unnecessary applications and tabs');
+        }
+        else if (batteryStatus.isLow) {
+            recommendations.push('Low battery: Enable battery saver mode');
+            recommendations.push('Reduce animation complexity and GPU usage');
+            recommendations.push('Optimize background processes');
+        }
+        else if (batteryStatus.level < 0.5) {
+            recommendations.push('Medium battery: Consider light optimizations');
+            recommendations.push('Monitor hardware acceleration usage');
+            recommendations.push('Balance performance and battery life');
+        }
+        else {
+            recommendations.push('High battery: Full performance available');
+            recommendations.push('Hardware acceleration at maximum capacity');
+            recommendations.push('Monitor for optimal performance');
+        }
+        return recommendations;
+    }, [batteryStatus]);
+    // Initialize battery monitoring
+    useEffect(() => {
+        if (!enableBatteryMonitoring)
+            return;
+        try {
+            // Get initial battery status
+            getBatteryStatus();
+            // Set up battery monitoring interval
+            batteryCheckIntervalRef.current = window.setInterval(getBatteryStatus, 10000); // Check every 10 seconds
+            return () => {
+                if (batteryCheckIntervalRef.current) {
+                    clearInterval(batteryCheckIntervalRef.current);
+                }
+            };
+        }
+        catch (error) {
+            console.warn('Battery optimization initialization failed:', error);
+        }
+    }, [enableBatteryMonitoring, getBatteryStatus]);
+    // Apply optimizations when battery status changes
+    useEffect(() => {
+        if (enableAdaptiveOptimization) {
+            applyBatteryOptimizations();
+        }
+    }, [enableAdaptiveOptimization, applyBatteryOptimizations]);
+    // Set initial user preferences
+    useEffect(() => {
+        if (enableUserPreferences) {
+            updateUserPreferences(userPreferenceLevel);
+        }
+    }, [enableUserPreferences, userPreferenceLevel, updateUserPreferences]);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            if (batteryCheckIntervalRef.current) {
+                clearInterval(batteryCheckIntervalRef.current);
+            }
+            if (optimizationTimerRef.current) {
+                clearTimeout(optimizationTimerRef.current);
+            }
+        };
+    }, []);
+    return {
+        // State
+        batteryStatus,
+        isOptimizing,
+        optimizations,
+        currentThrottleLevel,
+        userPreferences,
+        // Actions
+        getBatteryStatus,
+        applyPerformanceThrottling,
+        applyBatteryOptimizations,
+        updateUserPreferences,
+        // Computed values
+        isLowBattery: batteryStatus.isLow,
+        isCriticalBattery: batteryStatus.isCritical,
+        batteryPercentage: Math.round(batteryStatus.level * 100),
+        optimizationRecommendations: getOptimizationRecommendations(),
+        isCharging: batteryStatus.charging,
+        estimatedTimeRemaining: batteryStatus.charging ?
+            batteryStatus.chargingTime : batteryStatus.dischargingTime,
+        // Utility functions
+        getBatteryHealth: () => {
+            if (batteryStatus.level >= 0.8)
+                return 'excellent';
+            if (batteryStatus.level >= 0.6)
+                return 'good';
+            if (batteryStatus.level >= 0.4)
+                return 'fair';
+            if (batteryStatus.level >= 0.2)
+                return 'poor';
+            return 'critical';
+        }
+    };
+};
+export default useBatteryOptimization;

package/dist/hooks/use-battery-status.d.ts

@@ -0,0 +1,57 @@
+export interface BatteryMetrics {
+    level: number;
+    charging: boolean;
+    chargingTime: number;
+    dischargingTime: number;
+    isLowPowerMode: boolean;
+    isCriticalBattery: boolean;
+    performanceMode: 'high' | 'medium' | 'low';
+    throttlingEnabled: boolean;
+    throttlingReason?: string;
+}
+export interface BatteryThresholds {
+    low: number;
+    critical: number;
+    warning: number;
+}
+export interface BatteryCallbacks {
+    onBatteryLow?: (level: number) => void;
+    onBatteryCritical?: (level: number) => void;
+    onChargingStateChange?: (charging: boolean) => void;
+    onPerformanceModeChange?: (mode: BatteryMetrics['performanceMode']) => void;
+    onThrottlingChange?: (enabled: boolean, reason?: string) => void;
+}
+export interface BatteryOptions {
+    updateInterval?: number;
+    thresholds?: Partial<BatteryThresholds>;
+    enableThrottling?: boolean;
+    callbacks?: BatteryCallbacks;
+}
+export declare const useBatteryStatus: (options?: BatteryOptions) => {
+    metrics: BatteryMetrics;
+    startMonitoring: () => void;
+    stopMonitoring: () => void;
+    isMonitoring: boolean;
+    enableThrottlingMode: (reason?: string) => void;
+    disableThrottlingMode: () => void;
+    batteryLevel: number;
+    isCharging: boolean;
+    isLowPowerMode: boolean;
+    isCriticalBattery: boolean;
+    performanceMode: "low" | "medium" | "high";
+    throttlingEnabled: boolean;
+    throttlingReason: string;
+    getOptimizationRecommendations: () => string[];
+    getPowerSavingSuggestions: () => string[];
+    getBatteryStatus: () => string;
+    level: number;
+    charging: boolean;
+    chargingTime: number;
+    dischargingTime: number;
+    thresholds: {
+        low: number;
+        critical: number;
+        warning: number;
+    };
+};
+//# sourceMappingURL=use-battery-status.d.ts.map

package/dist/hooks/use-battery-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-battery-status.d.ts","sourceRoot":"","sources":["../../src/hooks/use-battery-status.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,OAAO,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;IACpB,eAAe,EAAE,MAAM,CAAA;IACvB,cAAc,EAAE,OAAO,CAAA;IACvB,iBAAiB,EAAE,OAAO,CAAA;IAC1B,eAAe,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAA;IAC1C,iBAAiB,EAAE,OAAO,CAAA;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;AAED,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACtC,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IAC3C,qBAAqB,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,IAAI,CAAA;IACnD,uBAAuB,CAAC,EAAE,CAAC,IAAI,EAAE,cAAc,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAA;IAC3E,kBAAkB,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;CACjE;AAED,MAAM,WAAW,cAAc;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAA;IACvC,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,SAAS,CAAC,EAAE,gBAAgB,CAAA;CAC7B;AAQD,eAAO,MAAM,gBAAgB,GAAI,UAAS,cAAmB;;;;;oCAyIR,MAAM;;;;;;;;;;;;;;;;;aAnKpD,MAAM;kBACD,MAAM;iBACP,MAAM;;CAyRhB,CAAA"}