@therealtinhtute/baroiplayer 1.0.0 → 1.0.2

package/src/core/performance/media-loading-optimizer.d.ts

@@ -0,0 +1,105 @@
+export interface NetworkInfo {
+    effectiveType: '2g' | '3g' | '4g' | '5g' | 'unknown';
+    downlink: number;
+    rtt: number;
+    saveData: boolean;
+    isOnline: boolean;
+}
+export interface MediaLoadingConfig {
+    preloadStrategy: 'none' | 'metadata' | 'auto';
+    adaptiveBitrate: boolean;
+    maxPreloadSize: number;
+    networkThresholds: {
+        '2g': {
+            maxBitrate: number;
+            preload: boolean;
+        };
+        '3g': {
+            maxBitrate: number;
+            preload: boolean;
+        };
+        '4g': {
+            maxBitrate: number;
+            preload: boolean;
+        };
+        '5g': {
+            maxBitrate: number;
+            preload: boolean;
+        };
+    };
+    bufferSize: number;
+    enableServiceWorker: boolean;
+}
+export declare const defaultMediaLoadingConfig: MediaLoadingConfig;
+export interface MediaLoadingMetrics {
+    loadStartTime: number;
+    firstByteTime?: number;
+    loadCompleteTime?: number;
+    totalLoadTime?: number;
+    bytesLoaded: number;
+    loadSpeed: number;
+    networkType: string;
+    quality: string;
+    bufferHealth: number;
+    stallsCount: number;
+    stallsDuration: number;
+}
+export declare class NetworkMonitor {
+    private connection;
+    private listeners;
+    private currentInfo;
+    constructor();
+    private getNetworkInfo;
+    private initializeListeners;
+    private handleNetworkChange;
+    getCurrentNetworkInfo(): NetworkInfo;
+    subscribe(listener: (info: NetworkInfo) => void): () => void;
+    estimateBandwidth(): Promise<number>;
+}
+export declare class MediaLoadingOptimizer {
+    private config;
+    private networkMonitor;
+    private loadingMetrics;
+    private preloadCache;
+    constructor(config?: Partial<MediaLoadingConfig>);
+    private initializeNetworkMonitoring;
+    private handleNetworkChange;
+    optimizeMediaLoading(mediaUrl: string, element: HTMLMediaElement, options?: {
+        quality?: string;
+        preload?: boolean;
+        priority?: 'high' | 'normal' | 'low';
+    }): Promise<MediaLoadingMetrics>;
+    private chooseLoadingStrategy;
+    private getPreloadAttribute;
+    private getSuggestedQuality;
+    private getBufferTarget;
+    preloadMedia(url: string, maxSize: number): Promise<void>;
+    private fetchWithProgress;
+    private monitorLoadingProgress;
+    private applyQualitySettings;
+    private adjustQualityForNetwork;
+    clearPreloadCache(): void;
+    getLoadingMetrics(url: string): MediaLoadingMetrics | undefined;
+    getAllMetrics(): MediaLoadingMetrics[];
+    getAverageLoadingTime(): number;
+    getNetworkPerformanceStats(): {
+        networkType: string;
+        avgLoadTime: number;
+        avgStalls: number;
+        avgBufferHealth: number;
+    }[];
+}
+export declare const mediaLoadingOptimizer: MediaLoadingOptimizer;
+export declare function useMediaLoadingOptimizer(config?: Partial<MediaLoadingConfig>): {
+    networkInfo: NetworkInfo | null;
+    loadingMetrics: MediaLoadingMetrics[];
+    optimizeLoading: (mediaUrl: string, element: HTMLMediaElement, options?: any) => Promise<MediaLoadingMetrics>;
+    averageLoadTime: number;
+    networkStats: {
+        networkType: string;
+        avgLoadTime: number;
+        avgStalls: number;
+        avgBufferHealth: number;
+    }[];
+};
+//# sourceMappingURL=media-loading-optimizer.d.ts.map

package/src/core/performance/media-loading-optimizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-loading-optimizer.d.ts","sourceRoot":"","sources":["media-loading-optimizer.ts"],"names":[],"mappings":"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"}

package/src/core/performance/media-loading-optimizer.js

@@ -0,0 +1,404 @@
+import React from 'react';
+export const defaultMediaLoadingConfig = {
+    preloadStrategy: 'metadata',
+    adaptiveBitrate: true,
+    maxPreloadSize: 2 * 1024 * 1024, // 2MB
+    networkThresholds: {
+        '2g': { maxBitrate: 128, preload: false }, // 128 kbps
+        '3g': { maxBitrate: 500, preload: false }, // 500 kbps  
+        '4g': { maxBitrate: 2000, preload: true }, // 2 Mbps
+        '5g': { maxBitrate: 10000, preload: true } // 10 Mbps
+    },
+    bufferSize: 10, // 10 seconds
+    enableServiceWorker: true
+};
+// Network monitoring utility
+export class NetworkMonitor {
+    connection;
+    listeners = new Set();
+    currentInfo;
+    constructor() {
+        if (typeof window === 'undefined' || typeof navigator === 'undefined') {
+            // Server-side rendering fallback
+            this.connection = null;
+            this.currentInfo = {
+                effectiveType: 'unknown',
+                downlink: 0,
+                rtt: 0,
+                saveData: false,
+                isOnline: true
+            };
+            return;
+        }
+        this.connection = navigator.connection ||
+            navigator.mozConnection ||
+            navigator.webkitConnection;
+        this.currentInfo = this.getNetworkInfo();
+        this.initializeListeners();
+    }
+    getNetworkInfo() {
+        if (typeof navigator === 'undefined') {
+            // Server-side rendering fallback
+            return {
+                effectiveType: 'unknown',
+                downlink: 0,
+                rtt: 0,
+                saveData: false,
+                isOnline: true
+            };
+        }
+        const isOnline = navigator.onLine;
+        if (this.connection) {
+            return {
+                effectiveType: this.connection.effectiveType || 'unknown',
+                downlink: this.connection.downlink || 0,
+                rtt: this.connection.rtt || 0,
+                saveData: this.connection.saveData || false,
+                isOnline
+            };
+        }
+        // Fallback for browsers without Network Information API
+        return {
+            effectiveType: 'unknown',
+            downlink: 0,
+            rtt: 0,
+            saveData: false,
+            isOnline
+        };
+    }
+    initializeListeners() {
+        if (typeof window === 'undefined') {
+            // Server-side rendering - skip event listeners
+            return;
+        }
+        if (this.connection) {
+            this.connection.addEventListener('change', this.handleNetworkChange.bind(this));
+        }
+        window.addEventListener('online', this.handleNetworkChange.bind(this));
+        window.addEventListener('offline', this.handleNetworkChange.bind(this));
+    }
+    handleNetworkChange() {
+        const newInfo = this.getNetworkInfo();
+        this.currentInfo = newInfo;
+        this.listeners.forEach(listener => listener(newInfo));
+    }
+    getCurrentNetworkInfo() {
+        return { ...this.currentInfo };
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    // Estimate available bandwidth with fallback detection
+    async estimateBandwidth() {
+        if (this.connection && this.connection.downlink) {
+            return this.connection.downlink * 1000; // Convert to kbps
+        }
+        // Fallback: simple bandwidth test
+        try {
+            const startTime = performance.now();
+            const testUrl = '/api/bandwidth-test?size=100kb'; // Would need to be implemented
+            const response = await fetch(testUrl);
+            const blob = await response.blob();
+            const endTime = performance.now();
+            const timeInSeconds = (endTime - startTime) / 1000;
+            const bytesLoaded = blob.size;
+            const bitsPerSecond = (bytesLoaded * 8) / timeInSeconds;
+            return bitsPerSecond / 1000; // Return in kbps
+        }
+        catch (error) {
+            console.warn('Bandwidth estimation failed:', error);
+            return 1000; // Default to 1Mbps
+        }
+    }
+}
+// Media loading optimizer
+export class MediaLoadingOptimizer {
+    config;
+    networkMonitor;
+    loadingMetrics = new Map();
+    preloadCache = new Map();
+    constructor(config = {}) {
+        this.config = { ...defaultMediaLoadingConfig, ...config };
+        this.networkMonitor = new NetworkMonitor();
+        this.initializeNetworkMonitoring();
+    }
+    initializeNetworkMonitoring() {
+        this.networkMonitor.subscribe((networkInfo) => {
+            this.handleNetworkChange(networkInfo);
+        });
+    }
+    handleNetworkChange(networkInfo) {
+        console.log('Network changed:', networkInfo);
+        // Adjust quality based on network conditions
+        if (this.config.adaptiveBitrate) {
+            this.adjustQualityForNetwork(networkInfo);
+        }
+        // Clear preload cache if on slow network
+        if (networkInfo.effectiveType === '2g' || networkInfo.saveData) {
+            this.clearPreloadCache();
+        }
+    }
+    // Optimize media loading based on network conditions
+    async optimizeMediaLoading(mediaUrl, element, options = {}) {
+        const startTime = performance.now();
+        const networkInfo = this.networkMonitor.getCurrentNetworkInfo();
+        const metrics = {
+            loadStartTime: startTime,
+            bytesLoaded: 0,
+            loadSpeed: 0,
+            networkType: networkInfo.effectiveType,
+            quality: options.quality || 'auto',
+            bufferHealth: 0,
+            stallsCount: 0,
+            stallsDuration: 0
+        };
+        this.loadingMetrics.set(mediaUrl, metrics);
+        try {
+            // Choose optimal loading strategy
+            const loadingStrategy = this.chooseLoadingStrategy(networkInfo, options);
+            // Apply preload strategy
+            if (loadingStrategy.shouldPreload) {
+                await this.preloadMedia(mediaUrl, loadingStrategy.preloadAmount);
+            }
+            // Set appropriate preload attribute
+            element.preload = loadingStrategy.preloadAttribute;
+            // Monitor loading progress
+            this.monitorLoadingProgress(element, metrics);
+            // Apply quality adjustments
+            if (this.config.adaptiveBitrate && loadingStrategy.suggestedQuality) {
+                this.applyQualitySettings(element, loadingStrategy.suggestedQuality);
+            }
+            return metrics;
+        }
+        catch (error) {
+            console.error('Media loading optimization failed:', error);
+            return metrics;
+        }
+    }
+    chooseLoadingStrategy(networkInfo, options) {
+        const effectiveType = networkInfo.effectiveType === 'unknown' ? '4g' : networkInfo.effectiveType;
+        const threshold = this.config.networkThresholds[effectiveType] ||
+            this.config.networkThresholds['4g'];
+        return {
+            shouldPreload: options.preload !== false && threshold.preload && !networkInfo.saveData,
+            preloadAmount: networkInfo.saveData ? 0 : this.config.maxPreloadSize,
+            preloadAttribute: this.getPreloadAttribute(networkInfo),
+            suggestedQuality: this.getSuggestedQuality(networkInfo, threshold.maxBitrate),
+            bufferTarget: this.getBufferTarget(networkInfo)
+        };
+    }
+    getPreloadAttribute(networkInfo) {
+        if (networkInfo.saveData || networkInfo.effectiveType === '2g') {
+            return 'none';
+        }
+        if (networkInfo.effectiveType === '3g') {
+            return 'metadata';
+        }
+        return this.config.preloadStrategy;
+    }
+    getSuggestedQuality(networkInfo, maxBitrate) {
+        const availableBandwidth = networkInfo.downlink * 1000; // Convert to kbps
+        if (availableBandwidth >= maxBitrate * 2)
+            return 'high';
+        if (availableBandwidth >= maxBitrate)
+            return 'medium';
+        return 'low';
+    }
+    getBufferTarget(networkInfo) {
+        switch (networkInfo.effectiveType) {
+            case '2g': return 2; // 2 seconds
+            case '3g': return 5; // 5 seconds
+            case '4g': return this.config.bufferSize;
+            case '5g': return this.config.bufferSize * 1.5;
+            default: return this.config.bufferSize;
+        }
+    }
+    // Preload media content
+    async preloadMedia(url, maxSize) {
+        if (this.preloadCache.has(url)) {
+            return; // Already preloading or preloaded
+        }
+        const preloadPromise = this.fetchWithProgress(url, maxSize);
+        this.preloadCache.set(url, preloadPromise);
+        try {
+            await preloadPromise;
+        }
+        catch (error) {
+            console.warn(`Preload failed for ${url}:`, error);
+            this.preloadCache.delete(url);
+        }
+    }
+    async fetchWithProgress(url, maxSize) {
+        const response = await fetch(url, {
+            headers: {
+                'Range': `bytes=0-${maxSize - 1}` // Limit preload size
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to preload: ${response.status}`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new Error('Response body not readable');
+        }
+        const chunks = [];
+        let bytesRead = 0;
+        try {
+            while (bytesRead < maxSize) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                chunks.push(value);
+                bytesRead += value.length;
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        return new Blob(chunks);
+    }
+    // Monitor loading progress and update metrics
+    monitorLoadingProgress(element, metrics) {
+        let stallStartTime = null;
+        const updateMetrics = () => {
+            if (element.buffered.length > 0) {
+                const bufferedEnd = element.buffered.end(element.buffered.length - 1);
+                const currentTime = element.currentTime;
+                metrics.bufferHealth = Math.min((bufferedEnd - currentTime) / this.config.bufferSize, 1);
+            }
+        };
+        // Track first byte
+        const onLoadStart = () => {
+            metrics.firstByteTime = performance.now();
+        };
+        // Track load completion
+        const onCanPlay = () => {
+            metrics.loadCompleteTime = performance.now();
+            metrics.totalLoadTime = metrics.loadCompleteTime - metrics.loadStartTime;
+            // Calculate load speed
+            if (metrics.totalLoadTime && metrics.bytesLoaded > 0) {
+                metrics.loadSpeed = metrics.bytesLoaded / (metrics.totalLoadTime / 1000);
+            }
+        };
+        // Track stalls
+        const onWaiting = () => {
+            if (stallStartTime === null) {
+                stallStartTime = performance.now();
+                metrics.stallsCount++;
+            }
+        };
+        const onPlaying = () => {
+            if (stallStartTime !== null) {
+                metrics.stallsDuration += performance.now() - stallStartTime;
+                stallStartTime = null;
+            }
+            updateMetrics();
+        };
+        // Track progress
+        const onProgress = () => {
+            if (element.buffered.length > 0) {
+                const bufferedBytes = element.buffered.end(0) * 1000; // Rough estimate
+                metrics.bytesLoaded = bufferedBytes;
+            }
+            updateMetrics();
+        };
+        // Add event listeners
+        element.addEventListener('loadstart', onLoadStart);
+        element.addEventListener('canplay', onCanPlay);
+        element.addEventListener('waiting', onWaiting);
+        element.addEventListener('playing', onPlaying);
+        element.addEventListener('progress', onProgress);
+        // Cleanup function
+        const cleanup = () => {
+            element.removeEventListener('loadstart', onLoadStart);
+            element.removeEventListener('canplay', onCanPlay);
+            element.removeEventListener('waiting', onWaiting);
+            element.removeEventListener('playing', onPlaying);
+            element.removeEventListener('progress', onProgress);
+        };
+        // Auto-cleanup after 5 minutes
+        setTimeout(cleanup, 5 * 60 * 1000);
+    }
+    // Apply quality settings (would integrate with HLS.js or similar)
+    applyQualitySettings(element, quality) {
+        // This would integrate with your video streaming library
+        console.log(`Applying quality setting: ${quality} to`, element);
+        // Example integration with HLS.js:
+        // if (element.hls) {
+        //   element.hls.currentLevel = this.getQualityLevel(quality);
+        // }
+    }
+    adjustQualityForNetwork(networkInfo) {
+        // Auto-adjust quality for all active media elements
+        console.log('Adjusting quality for network conditions:', networkInfo.effectiveType);
+    }
+    // Clear preload cache to save memory
+    clearPreloadCache() {
+        this.preloadCache.clear();
+    }
+    // Get loading metrics for a specific media URL
+    getLoadingMetrics(url) {
+        return this.loadingMetrics.get(url);
+    }
+    // Get all loading metrics
+    getAllMetrics() {
+        return Array.from(this.loadingMetrics.values());
+    }
+    // Calculate average loading performance
+    getAverageLoadingTime() {
+        const metrics = this.getAllMetrics();
+        const completedLoads = metrics.filter(m => m.totalLoadTime !== undefined);
+        if (completedLoads.length === 0)
+            return 0;
+        const total = completedLoads.reduce((sum, m) => sum + (m.totalLoadTime || 0), 0);
+        return total / completedLoads.length;
+    }
+    // Get network-specific performance stats
+    getNetworkPerformanceStats() {
+        const statsByNetwork = new Map();
+        this.getAllMetrics().forEach(metrics => {
+            const network = metrics.networkType;
+            if (!statsByNetwork.has(network)) {
+                statsByNetwork.set(network, []);
+            }
+            statsByNetwork.get(network).push(metrics);
+        });
+        return Array.from(statsByNetwork.entries()).map(([networkType, metrics]) => ({
+            networkType,
+            avgLoadTime: metrics.reduce((sum, m) => sum + (m.totalLoadTime || 0), 0) / metrics.length,
+            avgStalls: metrics.reduce((sum, m) => sum + m.stallsCount, 0) / metrics.length,
+            avgBufferHealth: metrics.reduce((sum, m) => sum + m.bufferHealth, 0) / metrics.length
+        }));
+    }
+}
+// Global media loading optimizer instance
+export const mediaLoadingOptimizer = new MediaLoadingOptimizer();
+// React hook for media loading optimization
+export function useMediaLoadingOptimizer(config) {
+    const [optimizer] = React.useState(() => config ? new MediaLoadingOptimizer(config) : mediaLoadingOptimizer);
+    const [networkInfo, setNetworkInfo] = React.useState(null);
+    const [loadingMetrics, setLoadingMetrics] = React.useState([]);
+    React.useEffect(() => {
+        const unsubscribe = optimizer['networkMonitor'].subscribe(setNetworkInfo);
+        setNetworkInfo(optimizer['networkMonitor'].getCurrentNetworkInfo());
+        // Update metrics periodically
+        const interval = setInterval(() => {
+            setLoadingMetrics(optimizer.getAllMetrics());
+        }, 1000);
+        return () => {
+            unsubscribe();
+            clearInterval(interval);
+        };
+    }, [optimizer]);
+    const optimizeLoading = React.useCallback((mediaUrl, element, options) => {
+        return optimizer.optimizeMediaLoading(mediaUrl, element, options);
+    }, [optimizer]);
+    return {
+        networkInfo,
+        loadingMetrics,
+        optimizeLoading,
+        averageLoadTime: optimizer.getAverageLoadingTime(),
+        networkStats: optimizer.getNetworkPerformanceStats()
+    };
+}

package/src/core/performance/performance-budgets.d.ts

@@ -0,0 +1,68 @@
+export interface PerformanceBudget {
+    name: string;
+    category: 'bundle' | 'runtime' | 'network' | 'memory';
+    limit: number;
+    unit: 'bytes' | 'ms' | 'score' | 'percent';
+    severity: 'error' | 'warning' | 'info';
+    description: string;
+}
+export interface BudgetViolation {
+    budget: PerformanceBudget;
+    actualValue: number;
+    overageAmount: number;
+    overagePercentage: number;
+    timestamp: number;
+}
+export interface AlertConfig {
+    enabled: boolean;
+    channels: AlertChannel[];
+    threshold: number;
+    cooldown: number;
+}
+export interface AlertChannel {
+    type: 'console' | 'webhook' | 'email' | 'slack';
+    config: {
+        url?: string;
+        email?: string;
+        token?: string;
+        channel?: string;
+    };
+}
+export declare const defaultPerformanceBudgets: PerformanceBudget[];
+export declare class PerformanceBudgetMonitor {
+    private budgets;
+    private violations;
+    private alertConfig;
+    private lastAlertTime;
+    constructor(budgets?: PerformanceBudget[], alertConfig?: AlertConfig);
+    checkMetric(metricName: string, value: number, category?: PerformanceBudget['category']): BudgetViolation[];
+    checkBundleSizes(distPath: string): Promise<BudgetViolation[]>;
+    checkRuntimeMetrics(metrics: {
+        renderTime?: number;
+        fid?: number;
+        lcp?: number;
+        cls?: number;
+        memoryUsage?: number;
+        mediaLoadTime?: number;
+    }): BudgetViolation[];
+    private handleViolations;
+    private sendAlerts;
+    private formatAlertMessage;
+    private sendAlert;
+    private formatValue;
+    private formatBytes;
+    private getUnitDisplay;
+    addBudget(budget: PerformanceBudget): void;
+    removeBudget(name: string): void;
+    updateBudget(name: string, updates: Partial<PerformanceBudget>): void;
+    getBudgets(): PerformanceBudget[];
+    getViolations(since?: number): BudgetViolation[];
+    clearViolations(): void;
+    getViolationSummary(): {
+        total: number;
+        byCategory: Record<string, number>;
+        bySeverity: Record<string, number>;
+    };
+}
+export declare const performanceBudgetMonitor: PerformanceBudgetMonitor;
+//# sourceMappingURL=performance-budgets.d.ts.map

package/src/core/performance/performance-budgets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance-budgets.d.ts","sourceRoot":"","sources":["performance-budgets.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,GAAG,SAAS,CAAC;IAC3C,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;IACvC,WAAW,EAAE,MAAM,CAAC;CACrB;AAGD,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CACnB;AAGD,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,CAAC;IAChD,MAAM,EAAE;QACN,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAGD,eAAO,MAAM,yBAAyB,EAAE,iBAAiB,EAgGxD,CAAC;AAGF,qBAAa,wBAAwB;IACnC,OAAO,CAAC,OAAO,CAA6C;IAC5D,OAAO,CAAC,UAAU,CAAyB;IAC3C,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,aAAa,CAAK;gBAGxB,OAAO,GAAE,iBAAiB,EAA8B,EACxD,WAAW,GAAE,WAKZ;IASH,WAAW,CACT,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,QAAQ,GAAE,iBAAiB,CAAC,UAAU,CAAa,GAClD,eAAe,EAAE;IA8Bd,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAgBpE,mBAAmB,CAAC,OAAO,EAAE;QAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB,GAAG,eAAe,EAAE;YA+BP,gBAAgB;YAgBhB,UAAU;IAaxB,OAAO,CAAC,kBAAkB;YAqBZ,SAAS;IA0CvB,OAAO,CAAC,WAAW;IAenB,OAAO,CAAC,WAAW;IAUnB,OAAO,CAAC,cAAc;IAWtB,SAAS,CAAC,MAAM,EAAE,iBAAiB;IAInC,YAAY,CAAC,IAAI,EAAE,MAAM;IAIzB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,iBAAiB,CAAC;IAO9D,UAAU,IAAI,iBAAiB,EAAE;IAIjC,aAAa,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,eAAe,EAAE;IAOhD,eAAe;IAIf,mBAAmB,IAAI;QACrB,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACnC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACpC;CAkBF;AAGD,eAAO,MAAM,wBAAwB,0BAAiC,CAAC"}