@therealtinhtute/baroiplayer 1.0.5 → 1.0.7

package/dist/src/core/performance/cicd.js

@@ -1,83 +0,0 @@
-// CI/CD integration utilities - Node.js only
-import { performanceBudgetMonitor } from './performance-budgets';
-export const cicdIntegration = {
-    // Check if running in CI environment
-    isCI() {
-        return !!(process.env.CI ||
-            process.env.CONTINUOUS_INTEGRATION ||
-            process.env.BUILD_NUMBER ||
-            process.env.GITHUB_ACTIONS ||
-            process.env.GITLAB_CI ||
-            process.env.CIRCLE_CI);
-    },
-    // Exit with error code if budget violations found
-    async enforcebudgets(distPath) {
-        const violations = await performanceBudgetMonitor.checkBundleSizes(distPath);
-        const errorViolations = violations.filter(v => v.budget.severity === 'error');
-        if (errorViolations.length > 0) {
-            console.error(`❌ Performance budget violations detected: ${errorViolations.length} errors`);
-            errorViolations.forEach(violation => {
-                console.error(`  - ${violation.budget.name}: ${this.formatValue(violation.actualValue, violation.budget.unit)} (limit: ${this.formatValue(violation.budget.limit, violation.budget.unit)})`);
-            });
-            if (this.isCI()) {
-                process.exit(1);
-            }
-        }
-        else {
-            console.log('✅ All performance budgets passed');
-        }
-    },
-    // Generate budget report for CI
-    generateCIReport() {
-        const summary = performanceBudgetMonitor.getViolationSummary();
-        const violations = performanceBudgetMonitor.getViolations();
-        let report = '## Performance Budget Report\n\n';
-        if (summary.total === 0) {
-            report += '✅ **All performance budgets passed!**\n\n';
-        }
-        else {
-            report += `❌ **${summary.total} budget violations detected**\n\n`;
-            report += '### Violations by Category\n';
-            Object.entries(summary.byCategory).forEach(([category, count]) => {
-                report += `- ${category}: ${count}\n`;
-            });
-            report += '\n### Violations by Severity\n';
-            Object.entries(summary.bySeverity).forEach(([severity, count]) => {
-                const emoji = severity === 'error' ? '🔴' : severity === 'warning' ? '🟡' : '🔵';
-                report += `- ${emoji} ${severity}: ${count}\n`;
-            });
-            report += '\n### Detailed Violations\n';
-            violations.forEach(violation => {
-                const emoji = violation.budget.severity === 'error' ? '🔴' : '🟡';
-                report += `${emoji} **${violation.budget.name}**\n`;
-                report += `- Limit: ${this.formatValue(violation.budget.limit, violation.budget.unit)}\n`;
-                report += `- Actual: ${this.formatValue(violation.actualValue, violation.budget.unit)}\n`;
-                report += `- Overage: +${violation.overagePercentage.toFixed(1)}%\n\n`;
-            });
-        }
-        return report;
-    },
-    formatValue(value, unit) {
-        switch (unit) {
-            case 'bytes':
-                return this.formatBytes(value);
-            case 'ms':
-                return `${value.toFixed(2)}ms`;
-            case 'score':
-                return value.toFixed(3);
-            case 'percent':
-                return `${value.toFixed(1)}%`;
-            default:
-                return value.toString();
-        }
-    },
-    formatBytes(bytes) {
-        if (bytes >= 1024 * 1024) {
-            return `${(bytes / 1024 / 1024).toFixed(2)}MB`;
-        }
-        if (bytes >= 1024) {
-            return `${(bytes / 1024).toFixed(2)}KB`;
-        }
-        return `${bytes}B`;
-    }
-};

package/dist/src/core/performance/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AACA,cAAc,uBAAuB,CAAC;AACtC,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAGtE,cAAc,uBAAuB,CAAC;AAGtC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,2BAA2B,CAAC;AAG1C,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACrB,yBAAyB,EAC1B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,wBAAwB,EACzB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,wBAAwB,EACxB,yBAAyB,EAC1B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,qBAAqB,EACrB,wBAAwB,EACxB,cAAc,EACd,qBAAqB,EACtB,MAAM,2BAA2B,CAAC"}

package/dist/src/core/performance/index.js

@@ -1,14 +0,0 @@
-// Performance Monitoring
-export * from './performance-monitor';
-export { default as PerformanceMonitor } from './performance-monitor';
-// Performance Testing
-export * from './performance-testing';
-// Performance Budgets and CI/CD
-export * from './performance-budgets';
-// Media Loading Optimization
-export * from './media-loading-optimizer';
-// Re-export key classes and utilities for convenience
-export { performanceMonitor, PerformanceDashboard, usePerformanceMonitor, withPerformanceMonitoring } from './performance-monitor';
-export { performanceBenchmark, performanceTestUtils, performanceTestFramework } from './performance-testing';
-export { performanceBudgetMonitor, defaultPerformanceBudgets } from './performance-budgets';
-export { mediaLoadingOptimizer, useMediaLoadingOptimizer, NetworkMonitor, MediaLoadingOptimizer } from './media-loading-optimizer';

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

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

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

@@ -1,404 +0,0 @@
-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/dist/src/core/performance/performance-budgets.d.ts.map

@@ -1 +0,0 @@
-{"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"}