diff --git a/dockmon/.dockerignore b/dockmon/.dockerignore
new file mode 100644
index 0000000..3cd7b04
--- /dev/null
+++ b/dockmon/.dockerignore
@@ -0,0 +1,54 @@
+# Git
+.git
+.gitignore
+.github
+
+# Documentation
+README.md
+*.md
+wiki-content
+
+# Tests
+tests
+test-results
+playwright-report
+node_modules
+package.json
+package-lock.json
+
+# Screenshots (keep in git for README, but not in Docker image)
+screenshots
+
+# Development
+.claude
+.vscode
+.idea
+
+# Python
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info
+dist
+build
+venv
+env
+
+# Docker
+docker-compose.yml
+.dockerignore
+
+# Scripts (if not needed in image)
+scripts
+
+# Temporary files
+*.tmp
+*.bak
+*.swp
+*.swo
+*~
+.DS_Store
diff --git a/dockmon/.gitignore b/dockmon/.gitignore
new file mode 100644
index 0000000..1f7154e
--- /dev/null
+++ b/dockmon/.gitignore
@@ -0,0 +1,79 @@
+
+# Claude Development Context and Internal Files
+CLAUDE_CONTEXT.md
+BASELINE_STATUS.md
+
+# Wiki Content (lives in wiki repo, not main repo)
+wiki-content/
+wiki-repo/
+
+# Documentation (internal development docs)
+docs/
+
+# Test Infrastructure (Development Only)
+tests/
+test-results/
+test-results.json
+playwright-report/
+*-results.log
+baseline*.log
+pre-refactor*.log
+post-refactor*.log
+
+# Node.js Dependencies (from test setup)
+node_modules/
+package-lock.json
+npm-debug.log*
+
+# SSL Certificates
+docker/certs/
+*.crt
+*.key
+*.pem
+*.csr
+
+# Database and persistent data
+backend/data/
+*.db
+*.db-journal
+*.db-wal
+*.db-shm
+
+# Environment files
+.env
+.env.*
+!.env.example
+
+# Python
+__pycache__/
+backend/__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+venv/
+env/
+*.egg-info/
+dist/
+build/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Temporary files
+*.tmp
+*.bak
+.coverage
+htmlcov/
diff --git a/dockmon/LICENSE b/dockmon/LICENSE
new file mode 100644
index 0000000..f1bc979
--- /dev/null
+++ b/dockmon/LICENSE
@@ -0,0 +1,17 @@
+MIT License
+
+Copyright (c) 2024 darthnorse
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
diff --git a/dockmon/README.md b/dockmon/README.md
new file mode 100644
index 0000000..3fd5a17
--- /dev/null
+++ b/dockmon/README.md
@@ -0,0 +1,135 @@
+# DockMon
+
+A comprehensive Docker container monitoring and management platform with real-time monitoring, intelligent auto-restart, multi-channel alerting, and complete event logging.
+
+![DockMon](https://img.shields.io/badge/DockMon-v1.1.0-blue.svg)
+![Docker](https://img.shields.io/badge/Docker-Ready-2496ED?logo=docker&logoColor=white)
+![Python](https://img.shields.io/badge/Python-3.11+-3776AB?logo=python&logoColor=white)
+![FastAPI](https://img.shields.io/badge/FastAPI-Backend-009688?logo=fastapi&logoColor=white)
+![License](https://img.shields.io/badge/license-MIT-green.svg)
+
+<p align="center">
+  <img src="screenshots/dashboard.png" alt="DockMon Dashboard" width="800">
+</p>
+
+## Key Features
+
+- **Multi-Host Monitoring** - Monitor containers across unlimited Docker hosts (local and remote)
+- **Real-Time Statistics** - Live CPU, memory, network, and disk I/O metrics for hosts and containers
+- **Real-Time Container Logs** - View logs from multiple containers simultaneously with live updates
+- **Event Viewer** - Comprehensive audit trail with filtering, search, and real-time updates
+- **Intelligent Auto-Restart** - Per-container auto-restart with configurable retry logic
+- **Advanced Alerting** - Discord, Slack, Telegram, Pushover, Gotify, SMTP with customizable templates
+- **Real-Time Dashboard** - Drag-and-drop customizable widgets with WebSocket updates
+- **Secure by Design** - Session-based auth, rate limiting, mTLS for remote hosts
+- **Mobile-Friendly** - Responsive design that works seamlessly on all devices
+
+## Documentation
+
+- **[Complete User Guide](https://github.com/darthnorse/dockmon/wiki)** - Full documentation
+- **[Quick Start](https://github.com/darthnorse/dockmon/wiki/Quick-Start)** - Get started in 5 minutes
+- **[Installation](https://github.com/darthnorse/dockmon/wiki/Installation)** - Docker, unRAID, Synology, QNAP
+- **[Configuration](https://github.com/darthnorse/dockmon/wiki/Notifications)** - Alerts, notifications, settings
+- **[Security](https://github.com/darthnorse/dockmon/wiki/Security-Guide)** - Best practices and mTLS setup
+- **[Remote Monitoring](https://github.com/darthnorse/dockmon/wiki/Remote-Docker-Setup)** - Monitor remote Docker hosts
+- **[Event Viewer](https://github.com/darthnorse/dockmon/wiki/Event-Viewer)** - Comprehensive audit trail with filtering
+- **[Container Logs](https://github.com/darthnorse/dockmon/wiki/Container-Logs)** - Real-time multi-container log viewer
+- **[API Reference](https://github.com/darthnorse/dockmon/wiki/API-Reference)** - REST and WebSocket APIs
+- **[FAQ](https://github.com/darthnorse/dockmon/wiki/FAQ)** - Frequently asked questions
+- **[Troubleshooting](https://github.com/darthnorse/dockmon/wiki/Troubleshooting)** - Common issues
+
+## Use Cases
+
+### Home Lab
+- Monitor all your Docker containers in one place
+- Get notified when critical services go down
+- Automatically restart failed containers
+- Track container events and changes
+
+### Small Business
+- Centralized monitoring across multiple servers
+- Multi-channel alerting (Discord, Slack, Telegram, Pushover, Gotify, SMTP)
+- Schedule maintenance windows with blackout periods
+- Audit trail of all container operations
+
+### Development Teams
+- Monitor dev, staging, and production environments
+- Quick container management (start, stop, restart, logs)
+- Test notifications before deploying to production
+- Share monitoring dashboard with team
+
+## Support & Community
+
+- **[Report Issues](https://github.com/darthnorse/dockmon/issues)** - Found a bug?
+- **[Discussions](https://github.com/darthnorse/dockmon/discussions)** - Ask questions, share ideas
+- **[Wiki](https://github.com/darthnorse/dockmon/wiki)** - Complete documentation
+- **[Star on GitHub](https://github.com/darthnorse/dockmon)** - Show your support!
+
+## Roadmap
+
+### Completed (v1.0)
+- [x] Full backend API with FastAPI
+- [x] WebSocket real-time updates
+- [x] Multi-channel notifications
+- [x] Comprehensive event logging
+- [x] Event log viewer with filtering and search
+- [x] Real-time container logs viewer (multi-container support)
+- [x] Drag-and-drop dashboard
+- [x] Auto-restart with retry logic
+
+### Completed (v1.1)
+- [x] Real-time performance metrics (CPU, memory, network, disk I/O)
+- [x] Host-level and container-level statistics
+- [x] TLS/mTLS support for secure remote Docker connections
+- [x] Optimized streaming architecture with Go backend
+
+### Planned (v1.5+)
+- [ ] Performance metrics dashboard with historical graphs
+- [ ] Container auto-update feature with version tracking
+- [ ] Configuration export/import
+- [ ] Automatic Proxmox LXC installation script
+
+See the [full roadmap](https://github.com/darthnorse/dockmon/wiki/Roadmap) for details.
+
+## Contributing
+
+Contributions are welcome! Here's how you can help:
+
+- Report bugs via [GitHub Issues](https://github.com/darthnorse/dockmon/issues)
+- Suggest features in [Discussions](https://github.com/darthnorse/dockmon/discussions)
+- Improve documentation (edit the [Wiki](https://github.com/darthnorse/dockmon/wiki))
+- Submit pull requests (see [Contributing Guide](https://github.com/darthnorse/dockmon/wiki/Contributing))
+
+## Development
+
+Want to contribute code or run DockMon in development mode?
+
+See [Development Setup](https://github.com/darthnorse/dockmon/wiki/Development-Setup) for:
+- Local development environment setup
+- Architecture overview
+- Running tests
+- Building from source
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## Author
+
+Created by [darthnorse](https://github.com/darthnorse)
+
+## Acknowledgments
+
+This project has been developed with **vibe coding** and **AI assistance** using Claude Code. The codebase includes clean, well-documented code with proper error handling, comprehensive testing considerations, modern async/await patterns, robust database design, and production-ready deployment configurations.
+
+---
+
+<p align="center">
+  <strong>If DockMon helps you, please consider giving it a star!</strong>
+</p>
+
+<p align="center">
+  <a href="https://github.com/darthnorse/dockmon/wiki">Documentation</a> •
+  <a href="https://github.com/darthnorse/dockmon/issues">Issues</a> •
+  <a href="https://github.com/darthnorse/dockmon/discussions">Discussions</a>
+</p>
\ No newline at end of file
diff --git a/dockmon/backend/auth/__init__.py b/dockmon/backend/auth/__init__.py
new file mode 100644
index 0000000..a906ca5
--- /dev/null
+++ b/dockmon/backend/auth/__init__.py
@@ -0,0 +1 @@
+# Authentication module for DockMon
\ No newline at end of file
diff --git a/dockmon/backend/auth/routes.py b/dockmon/backend/auth/routes.py
new file mode 100644
index 0000000..6cdfd7e
--- /dev/null
+++ b/dockmon/backend/auth/routes.py
@@ -0,0 +1,260 @@
+"""
+Authentication Routes for DockMon
+Handles login, logout, API key access, and session management endpoints
+"""
+
+import os
+import secrets
+import logging
+from typing import Optional
+
+from fastapi import APIRouter, Request, Response, HTTPException, Depends
+from fastapi.responses import JSONResponse
+
+from models.auth_models import LoginRequest, ChangePasswordRequest
+from security.rate_limiting import rate_limit_auth
+from security.audit import security_audit
+from auth.session_manager import session_manager
+from database import DatabaseManager
+
+
+logger = logging.getLogger(__name__)
+
+
+router = APIRouter(prefix="/api/auth", tags=["authentication"])
+
+
+def _is_localhost_or_internal(client_ip: str) -> bool:
+    """Check if request is from localhost or internal network"""
+    import ipaddress
+    try:
+        addr = ipaddress.ip_address(client_ip)
+
+        # Allow localhost
+        if addr.is_loopback:
+            return True
+
+        # Allow private networks (RFC 1918) - for Docker networks and internal deployments
+        if addr.is_private:
+            return True
+
+        return False
+    except ValueError:
+        # Invalid IP format
+        return False
+
+
+from config.paths import DATABASE_PATH
+
+# Initialize database for user management - use centralized path config
+db = DatabaseManager(DATABASE_PATH)
+
+# Ensure default user exists on startup
+db.get_or_create_default_user()
+
+
+def _get_session_from_cookie(request: Request) -> Optional[str]:
+    """Extract session ID from cookie"""
+    return request.cookies.get("dockmon_session")
+
+
+async def verify_frontend_session(request: Request) -> bool:
+    """Dependency to verify frontend session authentication"""
+    session_id = _get_session_from_cookie(request)
+
+    if not session_manager.validate_session(session_id, request):
+        raise HTTPException(
+            status_code=401,
+            detail="Authentication required"
+        )
+
+    return True
+
+
+# Note: This endpoint will be implemented in main.py since it needs monitor instance
+# @router.get("/key") - implemented directly in main.py
+
+
+@router.post("/login")
+async def login(login_data: LoginRequest, request: Request, response: Response, rate_limit_check: bool = rate_limit_auth):
+    """Frontend login endpoint"""
+    client_ip = request.client.host
+    user_agent = request.headers.get("user-agent", "Unknown")
+
+    # Verify credentials using database
+    user_info = db.verify_user_credentials(login_data.username, login_data.password)
+    if not user_info:
+        security_audit.log_login_failure(client_ip, user_agent, "Invalid credentials")
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid username or password"
+        )
+
+    # Create session with username
+    session_id = session_manager.create_session(request, user_info["username"])
+
+    # Set secure cookie
+    # Detect if we're using HTTPS based on common headers
+    is_https = request.url.scheme == "https" or request.headers.get("x-forwarded-proto") == "https"
+
+    response.set_cookie(
+        key="dockmon_session",
+        value=session_id,
+        httponly=True,  # Prevent XSS access to cookie
+        secure=is_https,   # Use secure flag when on HTTPS
+        samesite="lax", # CSRF protection
+        max_age=24*60*60  # 24 hours
+    )
+
+    return {
+        "success": True,
+        "message": "Login successful",
+        "username": user_info["username"],
+        "must_change_password": user_info["must_change_password"],
+        "is_first_login": user_info["is_first_login"]
+    }
+
+
+@router.post("/logout")
+async def logout(request: Request, response: Response, authenticated: bool = Depends(verify_frontend_session)):
+    """Frontend logout endpoint"""
+    session_id = _get_session_from_cookie(request)
+
+    if session_id:
+        session_manager.delete_session(session_id)
+
+    # Clear cookie
+    response.delete_cookie("dockmon_session")
+
+    return {"success": True, "message": "Logout successful"}
+
+
+@router.get("/status")
+async def auth_status(request: Request):
+    """Check authentication status"""
+    session_id = _get_session_from_cookie(request)
+    authenticated = session_manager.validate_session(session_id, request) if session_id else False
+
+    response = {
+        "authenticated": authenticated,
+        "session_valid": authenticated
+    }
+
+    # If authenticated, include username and password change requirement
+    if authenticated:
+        username = session_manager.get_session_username(session_id)
+        if username:
+            response["username"] = username
+            # Check if user must change password
+            with db.get_session() as session:
+                from database import User
+                user = session.query(User).filter(User.username == username).first()
+                if user:
+                    response["must_change_password"] = user.must_change_password
+                    response["is_first_login"] = user.is_first_login
+
+    return response
+
+
+@router.post("/change-password")
+async def change_password(password_data: ChangePasswordRequest, request: Request, authenticated: bool = Depends(verify_frontend_session)):
+    """Change user password"""
+    session_id = _get_session_from_cookie(request)
+    username = session_manager.get_session_username(session_id)
+
+    if not username:
+        raise HTTPException(
+            status_code=401,
+            detail="Session invalid"
+        )
+
+    # Verify current password
+    user_info = db.verify_user_credentials(username, password_data.current_password)
+    if not user_info:
+        raise HTTPException(
+            status_code=401,
+            detail="Current password is incorrect"
+        )
+
+    # Change password
+    success = db.change_user_password(username, password_data.new_password)
+    if not success:
+        raise HTTPException(
+            status_code=500,
+            detail="Failed to change password"
+        )
+
+    # Log security event
+    client_ip = request.client.host
+    user_agent = request.headers.get("user-agent", "Unknown")
+    security_audit.log_password_change(client_ip, user_agent, username)
+
+    return {
+        "success": True,
+        "message": "Password changed successfully"
+    }
+
+
+@router.post("/change-username")
+async def change_username(username_data: dict, request: Request, authenticated: bool = Depends(verify_frontend_session)):
+    """Change username"""
+    session_id = _get_session_from_cookie(request)
+    current_username = session_manager.get_session_username(session_id)
+
+    if not current_username:
+        raise HTTPException(
+            status_code=401,
+            detail="Session invalid"
+        )
+
+    # Verify current password
+    current_password = username_data.get("current_password")
+    new_username = username_data.get("new_username", "").strip()
+
+    if not current_password or not new_username:
+        raise HTTPException(
+            status_code=400,
+            detail="Current password and new username required"
+        )
+
+    # Verify current credentials
+    user_info = db.verify_user_credentials(current_username, current_password)
+    if not user_info:
+        raise HTTPException(
+            status_code=401,
+            detail="Current password is incorrect"
+        )
+
+    # Validate new username
+    if len(new_username) < 3 or len(new_username) > 50:
+        raise HTTPException(
+            status_code=400,
+            detail="Username must be between 3 and 50 characters"
+        )
+
+    # Check if new username already exists (but allow keeping the same username)
+    if new_username != current_username and db.username_exists(new_username):
+        raise HTTPException(
+            status_code=400,
+            detail="Username already exists"
+        )
+
+    # Change username
+    if not db.change_username(current_username, new_username):
+        raise HTTPException(
+            status_code=500,
+            detail="Failed to change username"
+        )
+
+    # Update session with new username
+    session_manager.update_session_username(session_id, new_username)
+
+    # Log security event
+    client_ip = request.client.host
+    user_agent = request.headers.get("user-agent", "Unknown")
+    security_audit.log_username_change(client_ip, user_agent, current_username, new_username)
+
+    return {
+        "success": True,
+        "message": "Username changed successfully"
+    }
\ No newline at end of file
diff --git a/dockmon/backend/auth/session_manager.py b/dockmon/backend/auth/session_manager.py
new file mode 100644
index 0000000..6f547f8
--- /dev/null
+++ b/dockmon/backend/auth/session_manager.py
@@ -0,0 +1,138 @@
+"""
+Session Management System for DockMon
+Provides secure session tokens with IP validation and automatic cleanup
+"""
+
+import logging
+import secrets
+import threading
+import time
+from datetime import datetime, timedelta
+from typing import Dict, Optional
+
+from fastapi import Request
+
+from security.audit import security_audit
+
+logger = logging.getLogger(__name__)
+
+
+class SessionManager:
+    """
+    Custom session management for frontend authentication
+    Provides secure session tokens with configurable expiry
+    """
+    def __init__(self):
+        self.sessions: Dict[str, dict] = {}
+        self.session_timeout = timedelta(hours=24)  # 24 hour sessions
+        self._sessions_lock = threading.Lock()
+        self._shutdown_event = threading.Event()
+        self._cleanup_thread = threading.Thread(target=self._periodic_cleanup, daemon=True)
+        self._cleanup_thread.start()
+
+    def _periodic_cleanup(self):
+        """Run cleanup every hour"""
+        while not self._shutdown_event.wait(timeout=3600):
+            try:
+                deleted = self.cleanup_expired_sessions()
+                if deleted > 0:
+                    logger.info(f"Cleaned up {deleted} expired sessions")
+            except Exception as e:
+                logger.error(f"Session cleanup failed: {e}", exc_info=True)
+
+    def create_session(self, request: Request, username: str = None) -> str:
+        """Create a new session token"""
+        session_id = secrets.token_urlsafe(32)
+        client_ip = request.client.host
+        user_agent = request.headers.get("user-agent", "Unknown")
+
+        with self._sessions_lock:
+            self.sessions[session_id] = {
+                "created_at": datetime.utcnow(),
+                "last_accessed": datetime.utcnow(),
+                "client_ip": client_ip,
+                "user_agent": user_agent,
+                "authenticated": True,
+                "username": username
+            }
+
+        # Security audit log
+        security_audit.log_login_success(client_ip, user_agent, session_id)
+
+        return session_id
+
+    def validate_session(self, session_id: Optional[str], request: Request) -> bool:
+        """Validate session token and update last accessed time"""
+        if not session_id:
+            return False
+
+        with self._sessions_lock:
+            if session_id not in self.sessions:
+                return False
+
+            session = self.sessions[session_id]
+            current_time = datetime.utcnow()
+            client_ip = request.client.host
+
+            # Check if session has expired
+            if current_time - session["created_at"] > self.session_timeout:
+                del self.sessions[session_id]
+                security_audit.log_session_expired(client_ip, session_id)
+                return False
+
+            # Validate IP consistency for security
+            if session["client_ip"] != client_ip:
+                security_audit.log_session_hijack_attempt(
+                    original_ip=session["client_ip"],
+                    attempted_ip=client_ip,
+                    session_id=session_id
+                )
+                del self.sessions[session_id]
+                return False
+
+            # Update last accessed time
+            session["last_accessed"] = current_time
+            return True
+
+    def delete_session(self, session_id: str):
+        """Delete a session (logout)"""
+        with self._sessions_lock:
+            if session_id in self.sessions:
+                del self.sessions[session_id]
+
+    def get_session_username(self, session_id: str) -> Optional[str]:
+        """Get username from session"""
+        with self._sessions_lock:
+            if session_id in self.sessions:
+                return self.sessions[session_id].get("username")
+            return None
+
+    def update_session_username(self, session_id: str, new_username: str):
+        """Update username in session"""
+        with self._sessions_lock:
+            if session_id in self.sessions:
+                self.sessions[session_id]["username"] = new_username
+
+    def cleanup_expired_sessions(self):
+        """Clean up expired sessions periodically"""
+        current_time = datetime.utcnow()
+        expired_sessions = []
+
+        with self._sessions_lock:
+            for session_id, session_data in self.sessions.items():
+                if current_time - session_data["created_at"] > self.session_timeout:
+                    expired_sessions.append(session_id)
+
+        for session_id in expired_sessions:
+            self.delete_session(session_id)
+
+        return len(expired_sessions)
+
+    def shutdown(self):
+        """Shutdown the session manager and cleanup thread"""
+        self._shutdown_event.set()
+        self._cleanup_thread.join(timeout=5)
+
+
+# Global session manager instance
+session_manager = SessionManager()
\ No newline at end of file
diff --git a/dockmon/backend/blackout_manager.py b/dockmon/backend/blackout_manager.py
new file mode 100644
index 0000000..9fae432
--- /dev/null
+++ b/dockmon/backend/blackout_manager.py
@@ -0,0 +1,268 @@
+"""
+Blackout Window Management for DockMon
+Handles alert suppression during maintenance windows
+"""
+
+import asyncio
+import logging
+from datetime import datetime, time, timedelta, timezone
+from typing import Dict, List, Optional, Tuple
+from database import DatabaseManager
+
+logger = logging.getLogger(__name__)
+
+
+class BlackoutManager:
+    """Manages blackout windows and deferred alerts"""
+
+    def __init__(self, db: DatabaseManager):
+        self.db = db
+        self._check_task: Optional[asyncio.Task] = None
+        self._last_check: Optional[datetime] = None
+        self._connection_manager = None  # Will be set when monitoring starts
+
+    def is_in_blackout_window(self) -> Tuple[bool, Optional[str]]:
+        """
+        Check if current time is within any blackout window
+        Returns: (is_blackout, window_name)
+        """
+        try:
+            settings = self.db.get_settings()
+            if not settings or not settings.blackout_windows:
+                return False, None
+
+            # Get timezone offset from settings (in minutes), default to 0 (UTC)
+            timezone_offset = getattr(settings, 'timezone_offset', 0)
+
+            # Get current time in UTC and convert to user's timezone
+            now_utc = datetime.now(timezone.utc)
+            now_local = now_utc + timedelta(minutes=timezone_offset)
+            current_time = now_local.time()
+            current_weekday = now_local.weekday()  # 0=Monday, 6=Sunday
+
+            for window in settings.blackout_windows:
+                if not window.get('enabled', True):
+                    continue
+
+                days = window.get('days', [])
+                start_str = window.get('start', '00:00')
+                end_str = window.get('end', '00:00')
+
+                start_time = datetime.strptime(start_str, '%H:%M').time()
+                end_time = datetime.strptime(end_str, '%H:%M').time()
+
+                # Handle overnight windows (e.g., 23:00 to 02:00)
+                if start_time > end_time:
+                    # For overnight windows, check if we're in the late night part (before midnight)
+                    # or the early morning part (after midnight)
+                    if current_time >= start_time:
+                        # Late night part - check if today is in the window
+                        if current_weekday in days:
+                            window_name = window.get('name', f"{start_str}-{end_str}")
+                            return True, window_name
+                    elif current_time < end_time:
+                        # Early morning part - check if YESTERDAY was in the window
+                        prev_day = (current_weekday - 1) % 7
+                        if prev_day in days:
+                            window_name = window.get('name', f"{start_str}-{end_str}")
+                            return True, window_name
+                else:
+                    # Regular same-day window
+                    if current_weekday in days and start_time <= current_time < end_time:
+                        window_name = window.get('name', f"{start_str}-{end_str}")
+                        return True, window_name
+
+            return False, None
+
+        except Exception as e:
+            logger.error(f"Error checking blackout window: {e}")
+            return False, None
+
+    def get_last_window_end_time(self) -> Optional[datetime]:
+        """Get when the last blackout window ended (for tracking)"""
+        return getattr(self, '_last_window_end', None)
+
+    def set_last_window_end_time(self, end_time: datetime):
+        """Set when the last blackout window ended"""
+        self._last_window_end = end_time
+
+    async def check_container_states_after_blackout(self, notification_service, monitor) -> Dict:
+        """
+        Check all container states after blackout window ends.
+        Alert if any containers are in problematic states.
+        Returns summary of what was found.
+
+        Args:
+            notification_service: The notification service instance
+            monitor: The DockerMonitor instance (reused, not created)
+        """
+        summary = {
+            'containers_down': [],
+            'total_checked': 0,
+            'window_name': None
+        }
+
+        try:
+
+            problematic_states = ['exited', 'dead', 'paused', 'removing']
+
+            # Check all containers across all hosts
+            for host_id, host in monitor.hosts.items():
+                if not host.client:
+                    continue
+
+                try:
+                    containers = host.client.containers.list(all=True)
+                    summary['total_checked'] += len(containers)
+
+                    for container in containers:
+                        if container.status in problematic_states:
+                            # Get exit code if container exited
+                            exit_code = None
+                            if container.status == 'exited':
+                                try:
+                                    exit_code = container.attrs.get('State', {}).get('ExitCode')
+                                except (AttributeError, KeyError, TypeError) as e:
+                                    logger.debug(f"Could not get exit code for container {container.id[:12]}: {e}")
+
+                            summary['containers_down'].append({
+                                'id': container.id[:12],
+                                'name': container.name,
+                                'host_id': host_id,
+                                'host_name': host.name,
+                                'state': container.status,
+                                'exit_code': exit_code,
+                                'image': container.image.tags[0] if container.image.tags else 'unknown'
+                            })
+
+                except Exception as e:
+                    logger.error(f"Error checking containers on host {host.name}: {e}")
+
+            # Send alert if any containers are down
+            if summary['containers_down'] and notification_service:
+                await self._send_post_blackout_alert(notification_service, summary)
+
+        except Exception as e:
+            logger.error(f"Error checking container states after blackout: {e}")
+
+        return summary
+
+    async def _send_post_blackout_alert(self, notification_service, summary: Dict):
+        """Send alert for containers found in problematic state after blackout"""
+        try:
+            containers_down = summary['containers_down']
+
+            # Get all alert rules that monitor state changes
+            alert_rules = self.db.get_alert_rules()
+
+            # For each container that's down, check if it matches any alert rules
+            for container_info in containers_down:
+                # Find matching alert rules for this container
+                matching_rules = []
+                for rule in alert_rules:
+                    if not rule.enabled:
+                        continue
+
+                    # Check if this rule monitors the problematic state
+                    if rule.trigger_states and container_info['state'] in rule.trigger_states:
+                        # Check if container matches rule's container pattern
+                        if self._container_matches_rule(container_info, rule):
+                            matching_rules.append(rule)
+
+                # Send alert through matching rules
+                if matching_rules:
+                    from notifications import AlertEvent
+                    event = AlertEvent(
+                        container_id=container_info['id'],
+                        container_name=container_info['name'],
+                        host_id=container_info['host_id'],
+                        host_name=container_info['host_name'],
+                        old_state='unknown_during_blackout',
+                        new_state=container_info['state'],
+                        exit_code=container_info.get('exit_code'),
+                        timestamp=datetime.now(),
+                        image=container_info['image'],
+                        triggered_by='post_blackout_check'
+                    )
+
+                    # Send through each matching rule's channels
+                    for rule in matching_rules:
+                        try:
+                            # Add note about blackout in the event
+                            event.notes = f"Container found in {container_info['state']} state after maintenance window ended"
+                            await notification_service.send_alert(event, rule)
+                        except Exception as e:
+                            logger.error(f"Failed to send post-blackout alert for {container_info['name']}: {e}")
+
+        except Exception as e:
+            logger.error(f"Error sending post-blackout alerts: {e}")
+
+    def _container_matches_rule(self, container_info: Dict, rule) -> bool:
+        """Check if container matches an alert rule's container criteria"""
+        try:
+            # If rule has specific container+host pairs
+            if hasattr(rule, 'containers') and rule.containers:
+                for container_spec in rule.containers:
+                    if (container_spec.container_name == container_info['name'] and
+                        container_spec.host_id == container_info['host_id']):
+                        return True
+                return False
+
+            # Otherwise, rule applies to all containers
+            return True
+
+        except Exception as e:
+            logger.error(f"Error matching container to rule: {e}")
+            return False
+
+    async def start_monitoring(self, notification_service, monitor, connection_manager=None):
+        """Start monitoring for blackout window transitions
+
+        Args:
+            notification_service: The notification service instance
+            monitor: The DockerMonitor instance (reused, not created)
+            connection_manager: Optional WebSocket connection manager
+        """
+        self._connection_manager = connection_manager
+        self._monitor = monitor  # Store monitor reference
+
+        async def monitor_loop():
+            was_in_blackout = False
+
+            while True:
+                try:
+                    is_blackout, window_name = self.is_in_blackout_window()
+
+                    # Check if blackout status changed
+                    if was_in_blackout != is_blackout:
+                        # Broadcast status change to all WebSocket clients
+                        if self._connection_manager:
+                            await self._connection_manager.broadcast({
+                                'type': 'blackout_status_changed',
+                                'data': {
+                                    'is_blackout': is_blackout,
+                                    'window_name': window_name
+                                }
+                            })
+
+                        # If we just exited blackout, process suppressed alerts
+                        if was_in_blackout and not is_blackout:
+                            logger.info(f"Blackout window ended. Processing suppressed alerts...")
+                            await notification_service.process_suppressed_alerts(self._monitor)
+
+                    was_in_blackout = is_blackout
+
+                    # Check every 15 seconds for more responsive updates
+                    await asyncio.sleep(15)
+
+                except Exception as e:
+                    logger.error(f"Error in blackout monitoring: {e}")
+                    await asyncio.sleep(15)
+
+        self._check_task = asyncio.create_task(monitor_loop())
+
+    def stop_monitoring(self):
+        """Stop the monitoring task"""
+        if self._check_task:
+            self._check_task.cancel()
+            self._check_task = None
\ No newline at end of file
diff --git a/dockmon/backend/config/__init__.py b/dockmon/backend/config/__init__.py
new file mode 100644
index 0000000..0dbcc16
--- /dev/null
+++ b/dockmon/backend/config/__init__.py
@@ -0,0 +1 @@
+# Configuration module for DockMon
\ No newline at end of file
diff --git a/dockmon/backend/config/paths.py b/dockmon/backend/config/paths.py
new file mode 100644
index 0000000..1651c3e
--- /dev/null
+++ b/dockmon/backend/config/paths.py
@@ -0,0 +1,27 @@
+"""
+Centralized path configuration for DockMon
+Ensures all modules use consistent, volume-mounted paths
+"""
+
+import os
+
+# Base paths - these MUST use absolute paths to the volume mount
+# The /app/data directory is mounted as a volume in Docker
+DATA_DIR = os.getenv('DOCKMON_DATA_DIR', '/app/data')
+
+# Database path - MUST be in the volume mount for persistence
+DATABASE_PATH = os.path.join(DATA_DIR, 'dockmon.db')
+DATABASE_URL = f'sqlite:///{DATABASE_PATH}'
+
+# Credentials file - also in volume for persistence
+CREDENTIALS_FILE = os.path.join(DATA_DIR, 'frontend_credentials.txt')
+
+# Certificates directory for TLS
+CERTS_DIR = os.path.join(DATA_DIR, 'certs')
+
+# Ensure data directory exists with proper permissions
+def ensure_data_dirs():
+    """Create data directories if they don't exist"""
+    for directory in [DATA_DIR, CERTS_DIR]:
+        # Use mode parameter to avoid TOCTOU race condition
+        os.makedirs(directory, mode=0o700, exist_ok=True)
\ No newline at end of file
diff --git a/dockmon/backend/config/settings.py b/dockmon/backend/config/settings.py
new file mode 100644
index 0000000..0dd5fbf
--- /dev/null
+++ b/dockmon/backend/config/settings.py
@@ -0,0 +1,165 @@
+"""
+Configuration Management for DockMon
+Centralizes all environment-based configuration and settings
+"""
+
+import os
+import logging
+from logging.handlers import RotatingFileHandler
+from typing import List
+
+
+def setup_logging():
+    """Configure application logging with rotation"""
+    from .paths import DATA_DIR
+
+    # Create logs directory with secure permissions
+    log_dir = os.path.join(DATA_DIR, 'logs')
+    os.makedirs(log_dir, mode=0o700, exist_ok=True)
+
+    # Set up root logger
+    root_logger = logging.getLogger()
+
+    # Check if handlers are already configured (prevent duplicate handlers)
+    if root_logger.handlers:
+        return
+
+    root_logger.setLevel(logging.INFO)
+
+    # Console handler for stdout
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.INFO)
+    console_formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    console_handler.setFormatter(console_formatter)
+
+    # File handler with rotation for application logs
+    # Max 10MB per file, keep 14 backups
+    file_handler = RotatingFileHandler(
+        os.path.join(log_dir, 'dockmon.log'),
+        maxBytes=10*1024*1024,  # 10MB
+        backupCount=14,  # Keep 14 old files
+        encoding='utf-8'
+    )
+    file_handler.setLevel(logging.INFO)
+    file_handler.setFormatter(console_formatter)
+
+    # Add handlers to root logger
+    root_logger.addHandler(console_handler)
+    root_logger.addHandler(file_handler)
+
+
+def _is_docker_container_id(hostname: str) -> bool:
+    """Check if hostname looks like a Docker container ID"""
+    if len(hostname) == 64 or len(hostname) == 12:
+        try:
+            int(hostname, 16)  # Check if it's hexadecimal
+            return True
+        except ValueError:
+            pass
+    return False
+
+
+def get_cors_origins() -> List[str]:
+    """Get CORS origins from environment or use defaults"""
+    # Check for custom origins from environment
+    custom_origins = os.getenv('DOCKMON_CORS_ORIGINS')
+    if custom_origins:
+        return [origin.strip() for origin in custom_origins.split(',')]
+
+    # Default origins for development and common deployment scenarios
+    default_origins = [
+        "http://localhost:3000",
+        "http://localhost:8080",
+        "http://localhost:8081",
+        "http://127.0.0.1:3000",
+        "http://127.0.0.1:8080",
+        "http://127.0.0.1:8081"
+    ]
+
+    # Auto-detect common production patterns (but skip Docker container IDs)
+    hostname = os.getenv('HOSTNAME', 'localhost')
+    if hostname != 'localhost' and not _is_docker_container_id(hostname):
+        default_origins.extend([
+            f"http://{hostname}:3000",
+            f"http://{hostname}:8080",
+            f"https://{hostname}:3000",
+            f"https://{hostname}:8080"
+        ])
+
+    return default_origins
+
+
+class RateLimitConfig:
+    """Rate limiting configuration from environment variables"""
+
+    @staticmethod
+    def get_limits() -> dict:
+        """Get all rate limiting configuration from environment"""
+        return {
+            # endpoint_pattern: (requests_per_minute, burst_limit, violation_threshold)
+            "default": (
+                int(os.getenv('DOCKMON_RATE_LIMIT_DEFAULT', 120)),
+                int(os.getenv('DOCKMON_RATE_BURST_DEFAULT', 20)),
+                int(os.getenv('DOCKMON_RATE_VIOLATIONS_DEFAULT', 8))
+            ),
+            "auth": (
+                int(os.getenv('DOCKMON_RATE_LIMIT_AUTH', 60)),
+                int(os.getenv('DOCKMON_RATE_BURST_AUTH', 15)),
+                int(os.getenv('DOCKMON_RATE_VIOLATIONS_AUTH', 5))
+            ),
+            "hosts": (
+                int(os.getenv('DOCKMON_RATE_LIMIT_HOSTS', 60)),
+                int(os.getenv('DOCKMON_RATE_BURST_HOSTS', 15)),
+                int(os.getenv('DOCKMON_RATE_VIOLATIONS_HOSTS', 8))
+            ),
+            "containers": (
+                int(os.getenv('DOCKMON_RATE_LIMIT_CONTAINERS', 200)),
+                int(os.getenv('DOCKMON_RATE_BURST_CONTAINERS', 40)),
+                int(os.getenv('DOCKMON_RATE_VIOLATIONS_CONTAINERS', 15))
+            ),
+            "notifications": (
+                int(os.getenv('DOCKMON_RATE_LIMIT_NOTIFICATIONS', 30)),
+                int(os.getenv('DOCKMON_RATE_BURST_NOTIFICATIONS', 10)),
+                int(os.getenv('DOCKMON_RATE_VIOLATIONS_NOTIFICATIONS', 5))
+            ),
+        }
+
+
+class AppConfig:
+    """Main application configuration"""
+
+    # Server settings
+    HOST = os.getenv('DOCKMON_HOST', '0.0.0.0')
+    PORT = int(os.getenv('DOCKMON_PORT', 8080))
+
+    # Security settings
+    CORS_ORIGINS = get_cors_origins()
+
+    # Import centralized paths
+    from .paths import DATABASE_URL as DEFAULT_DATABASE_URL, CREDENTIALS_FILE as DEFAULT_CREDENTIALS_FILE
+
+    # Database settings
+    DATABASE_URL = os.getenv('DOCKMON_DATABASE_URL', DEFAULT_DATABASE_URL)
+
+    # Logging
+    LOG_LEVEL = os.getenv('DOCKMON_LOG_LEVEL', 'INFO')
+
+    # Authentication
+    CREDENTIALS_FILE = os.getenv('DOCKMON_CREDENTIALS_FILE', DEFAULT_CREDENTIALS_FILE)
+    SESSION_TIMEOUT_HOURS = int(os.getenv('DOCKMON_SESSION_TIMEOUT_HOURS', 24))
+
+    # Rate limiting
+    RATE_LIMITS = RateLimitConfig.get_limits()
+
+    @classmethod
+    def validate(cls):
+        """Validate configuration"""
+        if cls.PORT < 1 or cls.PORT > 65535:
+            raise ValueError(f"Invalid port: {cls.PORT}")
+
+        if cls.SESSION_TIMEOUT_HOURS < 1:
+            raise ValueError(f"Session timeout must be at least 1 hour: {cls.SESSION_TIMEOUT_HOURS}")
+
+        return True
\ No newline at end of file
diff --git a/dockmon/backend/database.py b/dockmon/backend/database.py
new file mode 100644
index 0000000..de38200
--- /dev/null
+++ b/dockmon/backend/database.py
@@ -0,0 +1,1091 @@
+"""
+Database models and operations for DockMon
+Uses SQLite for persistent storage of configuration and settings
+"""
+
+from datetime import datetime, timedelta
+from typing import Optional, List, Dict, Any
+from sqlalchemy import create_engine, Column, String, Integer, Boolean, DateTime, JSON, ForeignKey, Text, UniqueConstraint, text
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, Session, relationship
+from sqlalchemy.pool import StaticPool
+import json
+import os
+import logging
+import secrets
+import bcrypt
+
+logger = logging.getLogger(__name__)
+
+Base = declarative_base()
+
+class User(Base):
+    """User authentication and settings"""
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    username = Column(String, nullable=False, unique=True)
+    password_hash = Column(String, nullable=False)
+    is_first_login = Column(Boolean, default=True)
+    must_change_password = Column(Boolean, default=False)
+    dashboard_layout = Column(Text, nullable=True)  # JSON string of GridStack layout
+    event_sort_order = Column(String, default='desc')  # 'desc' (newest first) or 'asc' (oldest first)
+    container_sort_order = Column(String, default='name-asc')  # Container sort preference on dashboard
+    modal_preferences = Column(Text, nullable=True)  # JSON string of modal size/position preferences
+    created_at = Column(DateTime, default=datetime.now)
+    updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)
+    last_login = Column(DateTime, nullable=True)
+
+class DockerHostDB(Base):
+    """Docker host configuration"""
+    __tablename__ = "docker_hosts"
+
+    id = Column(String, primary_key=True)
+    name = Column(String, nullable=False, unique=True)
+    url = Column(String, nullable=False)
+    tls_cert = Column(Text, nullable=True)
+    tls_key = Column(Text, nullable=True)
+    tls_ca = Column(Text, nullable=True)
+    security_status = Column(String, nullable=True)  # 'secure', 'insecure', 'unknown'
+    is_active = Column(Boolean, default=True)
+    created_at = Column(DateTime, default=datetime.now)
+    updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)
+
+    # Relationships
+    auto_restart_configs = relationship("AutoRestartConfig", back_populates="host", cascade="all, delete-orphan")
+
+class AutoRestartConfig(Base):
+    """Auto-restart configuration for containers"""
+    __tablename__ = "auto_restart_configs"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    host_id = Column(String, ForeignKey("docker_hosts.id"))
+    container_id = Column(String, nullable=False)
+    container_name = Column(String, nullable=False)
+    enabled = Column(Boolean, default=True)
+    max_retries = Column(Integer, default=3)
+    retry_delay = Column(Integer, default=30)
+    restart_count = Column(Integer, default=0)
+    last_restart = Column(DateTime, nullable=True)
+    created_at = Column(DateTime, default=datetime.now)
+    updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)
+
+    # Relationships
+    host = relationship("DockerHostDB", back_populates="auto_restart_configs")
+
+
+class GlobalSettings(Base):
+    """Global application settings"""
+    __tablename__ = "global_settings"
+
+    id = Column(Integer, primary_key=True, default=1)
+    max_retries = Column(Integer, default=3)
+    retry_delay = Column(Integer, default=30)
+    default_auto_restart = Column(Boolean, default=False)
+    polling_interval = Column(Integer, default=2)
+    connection_timeout = Column(Integer, default=10)
+    log_retention_days = Column(Integer, default=7)
+    event_retention_days = Column(Integer, default=30)  # Keep events for 30 days
+    enable_notifications = Column(Boolean, default=True)
+    auto_cleanup_events = Column(Boolean, default=True)  # Auto cleanup old events
+    alert_template = Column(Text, nullable=True)  # Global notification template
+    blackout_windows = Column(JSON, nullable=True)  # Array of blackout time windows
+    first_run_complete = Column(Boolean, default=False)  # Track if first run setup is complete
+    polling_interval_migrated = Column(Boolean, default=False)  # Track if polling interval has been migrated to 2s
+    timezone_offset = Column(Integer, default=0)  # Timezone offset in minutes from UTC
+    show_host_stats = Column(Boolean, default=True)  # Show host statistics graphs on dashboard
+    show_container_stats = Column(Boolean, default=True)  # Show container statistics on dashboard
+    updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)
+
+class NotificationChannel(Base):
+    """Notification channel configuration"""
+    __tablename__ = "notification_channels"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    name = Column(String, nullable=False, unique=True)
+    type = Column(String, nullable=False)  # telegram, discord, slack, pushover
+    config = Column(JSON, nullable=False)  # Channel-specific configuration
+    enabled = Column(Boolean, default=True)
+    created_at = Column(DateTime, default=datetime.now)
+    updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)
+
+class AlertRuleDB(Base):
+    """Alert rules for container state changes"""
+    __tablename__ = "alert_rules"
+
+    id = Column(String, primary_key=True)
+    name = Column(String, nullable=False)
+    trigger_events = Column(JSON, nullable=True)  # list of Docker events that trigger alert
+    trigger_states = Column(JSON, nullable=True)  # list of states that trigger alert
+    notification_channels = Column(JSON, nullable=False)  # list of channel IDs
+    cooldown_minutes = Column(Integer, default=15)  # prevent spam
+    enabled = Column(Boolean, default=True)
+    last_triggered = Column(DateTime, nullable=True)
+    created_at = Column(DateTime, default=datetime.now)
+    updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)
+
+    # Relationships
+    containers = relationship("AlertRuleContainer", back_populates="alert_rule", cascade="all, delete-orphan")
+
+class AlertRuleContainer(Base):
+    """Container+Host pairs for alert rules"""
+    __tablename__ = "alert_rule_containers"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    alert_rule_id = Column(String, ForeignKey("alert_rules.id", ondelete="CASCADE"), nullable=False)
+    host_id = Column(String, ForeignKey("docker_hosts.id", ondelete="CASCADE"), nullable=False)
+    container_name = Column(String, nullable=False)
+    created_at = Column(DateTime, default=datetime.now)
+
+    # Relationships
+    alert_rule = relationship("AlertRuleDB", back_populates="containers")
+    host = relationship("DockerHostDB")
+
+    # Unique constraint to prevent duplicates
+    __table_args__ = (
+        UniqueConstraint('alert_rule_id', 'host_id', 'container_name', name='_alert_container_uc'),
+    )
+
+class EventLog(Base):
+    """Comprehensive event logging for all DockMon activities"""
+    __tablename__ = "event_logs"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    correlation_id = Column(String, nullable=True)  # For linking related events
+
+    # Event categorization
+    category = Column(String, nullable=False)  # container, host, system, alert, notification
+    event_type = Column(String, nullable=False)  # state_change, action_taken, error, etc.
+    severity = Column(String, nullable=False, default='info')  # debug, info, warning, error, critical
+
+    # Target information
+    host_id = Column(String, nullable=True)
+    host_name = Column(String, nullable=True)
+    container_id = Column(String, nullable=True)
+    container_name = Column(String, nullable=True)
+
+    # Event details
+    title = Column(String, nullable=False)  # Short description
+    message = Column(Text, nullable=True)  # Detailed description
+    old_state = Column(String, nullable=True)
+    new_state = Column(String, nullable=True)
+    triggered_by = Column(String, nullable=True)  # user, system, auto_restart, alert
+
+    # Additional data
+    details = Column(JSON, nullable=True)  # Structured additional data
+    duration_ms = Column(Integer, nullable=True)  # For performance tracking
+
+    # Timestamps
+    timestamp = Column(DateTime, default=datetime.now, nullable=False)
+
+    # Index for efficient queries
+    __table_args__ = (
+        {"sqlite_autoincrement": True},
+    )
+
+class DatabaseManager:
+    """Database management and operations"""
+
+    def __init__(self, db_path: str = "data/dockmon.db"):
+        """Initialize database connection"""
+        self.db_path = db_path
+
+        # Ensure data directory exists
+        data_dir = os.path.dirname(db_path)
+        os.makedirs(data_dir, exist_ok=True)
+
+        # Set secure permissions on data directory (rwx for owner only)
+        try:
+            os.chmod(data_dir, 0o700)
+            logger.info(f"Set secure permissions (700) on data directory: {data_dir}")
+        except OSError as e:
+            logger.warning(f"Could not set permissions on data directory {data_dir}: {e}")
+
+        # Create engine with connection pooling
+        self.engine = create_engine(
+            f"sqlite:///{db_path}",
+            connect_args={"check_same_thread": False},
+            poolclass=StaticPool,
+            echo=False
+        )
+
+        # Create session factory
+        self.SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=self.engine)
+
+        # Create tables if they don't exist
+        Base.metadata.create_all(bind=self.engine)
+
+        # Run database migrations
+        self._run_migrations()
+
+        # Set secure permissions on database file (rw for owner only)
+        self._secure_database_file()
+
+        # Initialize default settings if needed
+        self._initialize_defaults()
+
+    def _run_migrations(self):
+        """Run database migrations for schema updates"""
+        try:
+            with self.get_session() as session:
+                # Migration: Populate security_status for existing hosts
+                hosts_without_security_status = session.query(DockerHostDB).filter(
+                    DockerHostDB.security_status.is_(None)
+                ).all()
+
+                for host in hosts_without_security_status:
+                    # Determine security status based on existing data
+                    if host.url and not host.url.startswith('unix://'):
+                        if host.tls_cert and host.tls_key:
+                            host.security_status = 'secure'
+                        else:
+                            host.security_status = 'insecure'
+                    # Unix socket connections don't need security status
+
+                if hosts_without_security_status:
+                    session.commit()
+                    print(f"Migrated {len(hosts_without_security_status)} hosts with security status")
+
+                # Migration: Add event_sort_order column to users table if it doesn't exist
+                inspector = session.connection().engine.dialect.get_columns(session.connection(), 'users')
+                column_names = [col.get('name', '') for col in inspector if 'name' in col]
+
+                if 'event_sort_order' not in column_names:
+                    # Add the column using raw SQL
+                    session.execute(text("ALTER TABLE users ADD COLUMN event_sort_order VARCHAR DEFAULT 'desc'"))
+                    session.commit()
+                    print("Added event_sort_order column to users table")
+
+                # Migration: Add container_sort_order column to users table if it doesn't exist
+                if 'container_sort_order' not in column_names:
+                    # Add the column using raw SQL
+                    session.execute(text("ALTER TABLE users ADD COLUMN container_sort_order VARCHAR DEFAULT 'name-asc'"))
+                    session.commit()
+                    print("Added container_sort_order column to users table")
+
+                # Migration: Add modal_preferences column to users table if it doesn't exist
+                if 'modal_preferences' not in column_names:
+                    # Add the column using raw SQL
+                    session.execute(text("ALTER TABLE users ADD COLUMN modal_preferences TEXT"))
+                    session.commit()
+                    print("Added modal_preferences column to users table")
+
+                # Migration: Add show_host_stats and show_container_stats columns to global_settings table
+                settings_inspector = session.connection().engine.dialect.get_columns(session.connection(), 'global_settings')
+                settings_column_names = [col['name'] for col in settings_inspector]
+
+                if 'show_host_stats' not in settings_column_names:
+                    session.execute(text("ALTER TABLE global_settings ADD COLUMN show_host_stats BOOLEAN DEFAULT 1"))
+                    session.commit()
+                    print("Added show_host_stats column to global_settings table")
+
+                if 'show_container_stats' not in settings_column_names:
+                    session.execute(text("ALTER TABLE global_settings ADD COLUMN show_container_stats BOOLEAN DEFAULT 1"))
+                    session.commit()
+                    print("Added show_container_stats column to global_settings table")
+
+                # Migration: Drop deprecated container_history table
+                # This table has been replaced by the EventLog table
+                inspector_result = session.connection().engine.dialect.get_table_names(session.connection())
+                if 'container_history' in inspector_result:
+                    session.execute(text("DROP TABLE container_history"))
+                    session.commit()
+                    print("Dropped deprecated container_history table (replaced by EventLog)")
+
+                # Migration: Add polling_interval_migrated column if it doesn't exist
+                if 'polling_interval_migrated' not in settings_column_names:
+                    session.execute(text("ALTER TABLE global_settings ADD COLUMN polling_interval_migrated BOOLEAN DEFAULT 0"))
+                    session.commit()
+                    print("Added polling_interval_migrated column to global_settings table")
+
+                # Migration: Update polling_interval to 2 seconds (only once, on first startup after this update)
+                settings = session.query(GlobalSettings).first()
+                if settings and not settings.polling_interval_migrated:
+                    # Only update if the user hasn't customized it (still at old default of 5 or 10)
+                    if settings.polling_interval >= 5:
+                        settings.polling_interval = 2
+                        settings.polling_interval_migrated = True
+                        session.commit()
+                        print("Migrated polling_interval to 2 seconds (from previous default)")
+                    else:
+                        # User has already customized to something < 5, just mark as migrated
+                        settings.polling_interval_migrated = True
+                        session.commit()
+
+        except Exception as e:
+            print(f"Migration warning: {e}")
+            # Don't fail startup on migration errors
+
+    def _secure_database_file(self):
+        """Set secure file permissions on the SQLite database file"""
+        try:
+            if os.path.exists(self.db_path):
+                # Set file permissions to 600 (read/write for owner only)
+                os.chmod(self.db_path, 0o600)
+                logger.info(f"Set secure permissions (600) on database file: {self.db_path}")
+            else:
+                # File doesn't exist yet - will be created by SQLAlchemy
+                # Schedule permission setting for after first connection
+                self._schedule_file_permissions()
+        except OSError as e:
+            logger.warning(f"Could not set permissions on database file {self.db_path}: {e}")
+
+    def _schedule_file_permissions(self):
+        """Schedule file permission setting for after database file is created"""
+        # Create a connection to ensure the file exists
+        with self.engine.connect() as conn:
+            pass
+
+        # Now set permissions
+        try:
+            if os.path.exists(self.db_path):
+                os.chmod(self.db_path, 0o600)
+                logger.info(f"Set secure permissions (600) on newly created database file: {self.db_path}")
+        except OSError as e:
+            logger.warning(f"Could not set permissions on newly created database file {self.db_path}: {e}")
+
+    def _initialize_defaults(self):
+        """Initialize default settings if they don't exist"""
+        with self.get_session() as session:
+            # Check if global settings exist
+            settings = session.query(GlobalSettings).first()
+            if not settings:
+                settings = GlobalSettings()
+                session.add(settings)
+                session.commit()
+
+    def get_session(self) -> Session:
+        """Get a database session"""
+        return self.SessionLocal()
+
+    # Docker Host Operations
+    def add_host(self, host_data: dict) -> DockerHostDB:
+        """Add a new Docker host"""
+        with self.get_session() as session:
+            try:
+                host = DockerHostDB(**host_data)
+                session.add(host)
+                session.commit()
+                session.refresh(host)
+                logger.info(f"Added host {host.name} ({host.id[:8]}) to database")
+                return host
+            except Exception as e:
+                logger.error(f"Failed to add host to database: {e}")
+                raise
+
+    def get_hosts(self, active_only: bool = True) -> List[DockerHostDB]:
+        """Get all Docker hosts ordered by creation time"""
+        with self.get_session() as session:
+            query = session.query(DockerHostDB)
+            if active_only:
+                query = query.filter(DockerHostDB.is_active == True)
+            # Order by created_at to ensure consistent ordering (oldest first)
+            query = query.order_by(DockerHostDB.created_at)
+            return query.all()
+
+    def get_host(self, host_id: str) -> Optional[DockerHostDB]:
+        """Get a specific Docker host"""
+        with self.get_session() as session:
+            return session.query(DockerHostDB).filter(DockerHostDB.id == host_id).first()
+
+    def update_host(self, host_id: str, updates: dict) -> Optional[DockerHostDB]:
+        """Update a Docker host"""
+        with self.get_session() as session:
+            try:
+                host = session.query(DockerHostDB).filter(DockerHostDB.id == host_id).first()
+                if host:
+                    for key, value in updates.items():
+                        setattr(host, key, value)
+                    host.updated_at = datetime.now()
+                    session.commit()
+                    session.refresh(host)
+                    logger.info(f"Updated host {host.name} ({host_id[:8]}) in database")
+                return host
+            except Exception as e:
+                logger.error(f"Failed to update host {host_id[:8]} in database: {e}")
+                raise
+
+    def delete_host(self, host_id: str) -> bool:
+        """Delete a Docker host and clean up related alert rules"""
+        with self.get_session() as session:
+            try:
+                host = session.query(DockerHostDB).filter(DockerHostDB.id == host_id).first()
+                if not host:
+                    logger.warning(f"Attempted to delete non-existent host {host_id[:8]}")
+                    return False
+
+                host_name = host.name
+
+                # Get all alert rules
+                all_rules = session.query(AlertRuleDB).all()
+
+                # Process each alert rule to remove containers from the deleted host
+                for rule in all_rules:
+                    if not rule.containers:
+                        continue
+
+                    # Filter out containers from the deleted host
+                    # rule.containers is a list of AlertRuleContainer objects
+                    remaining_containers = [
+                        c for c in rule.containers
+                        if c.host_id != host_id
+                    ]
+
+                    if not remaining_containers:
+                        # No containers left, delete the entire alert
+                        session.delete(rule)
+                        logger.info(f"Deleted alert rule '{rule.name}' (all containers were on deleted host {host_id})")
+                    elif len(remaining_containers) < len(rule.containers):
+                        # Some containers remain, update the alert
+                        rule.containers = remaining_containers
+                        rule.updated_at = datetime.now()
+                        logger.info(f"Updated alert rule '{rule.name}' (removed containers from host {host_id})")
+
+                # Delete the host
+                session.delete(host)
+                session.commit()
+                logger.info(f"Deleted host {host_name} ({host_id[:8]}) from database")
+                return True
+            except Exception as e:
+                logger.error(f"Failed to delete host {host_id[:8]} from database: {e}")
+                raise
+
+    # Auto-Restart Configuration
+    def get_auto_restart_config(self, host_id: str, container_id: str) -> Optional[AutoRestartConfig]:
+        """Get auto-restart configuration for a container"""
+        with self.get_session() as session:
+            return session.query(AutoRestartConfig).filter(
+                AutoRestartConfig.host_id == host_id,
+                AutoRestartConfig.container_id == container_id
+            ).first()
+
+    def set_auto_restart(self, host_id: str, container_id: str, container_name: str, enabled: bool):
+        """Set auto-restart configuration for a container"""
+        with self.get_session() as session:
+            try:
+                config = session.query(AutoRestartConfig).filter(
+                    AutoRestartConfig.host_id == host_id,
+                    AutoRestartConfig.container_id == container_id
+                ).first()
+
+                if config:
+                    config.enabled = enabled
+                    config.updated_at = datetime.now()
+                    if not enabled:
+                        config.restart_count = 0
+                    logger.info(f"Updated auto-restart for {container_name} ({container_id[:12]}): enabled={enabled}")
+                else:
+                    config = AutoRestartConfig(
+                        host_id=host_id,
+                        container_id=container_id,
+                        container_name=container_name,
+                        enabled=enabled
+                    )
+                    session.add(config)
+                    logger.info(f"Created auto-restart config for {container_name} ({container_id[:12]}): enabled={enabled}")
+
+                session.commit()
+            except Exception as e:
+                logger.error(f"Failed to set auto-restart for {container_id[:12]}: {e}")
+                raise
+
+    def increment_restart_count(self, host_id: str, container_id: str):
+        """Increment restart count for a container"""
+        with self.get_session() as session:
+            try:
+                config = session.query(AutoRestartConfig).filter(
+                    AutoRestartConfig.host_id == host_id,
+                    AutoRestartConfig.container_id == container_id
+                ).first()
+
+                if config:
+                    config.restart_count += 1
+                    config.last_restart = datetime.now()
+                    session.commit()
+                    logger.debug(f"Incremented restart count for {container_id[:12]} to {config.restart_count}")
+            except Exception as e:
+                logger.error(f"Failed to increment restart count for {container_id[:12]}: {e}")
+                raise
+
+    def reset_restart_count(self, host_id: str, container_id: str):
+        """Reset restart count for a container"""
+        with self.get_session() as session:
+            try:
+                config = session.query(AutoRestartConfig).filter(
+                    AutoRestartConfig.host_id == host_id,
+                    AutoRestartConfig.container_id == container_id
+                ).first()
+
+                if config:
+                    config.restart_count = 0
+                    session.commit()
+                    logger.debug(f"Reset restart count for {container_id[:12]}")
+            except Exception as e:
+                logger.error(f"Failed to reset restart count for {container_id[:12]}: {e}")
+                raise
+
+    # Global Settings
+    def get_settings(self) -> GlobalSettings:
+        """Get global settings"""
+        with self.get_session() as session:
+            return session.query(GlobalSettings).first()
+
+    def update_settings(self, updates: dict) -> GlobalSettings:
+        """Update global settings"""
+        with self.get_session() as session:
+            try:
+                settings = session.query(GlobalSettings).first()
+                for key, value in updates.items():
+                    if hasattr(settings, key):
+                        setattr(settings, key, value)
+                settings.updated_at = datetime.now()
+                session.commit()
+                session.refresh(settings)
+                logger.info("Changed global settings")
+                return settings
+            except Exception as e:
+                logger.error(f"Failed to update global settings: {e}")
+                raise
+
+    # Notification Channels
+    def add_notification_channel(self, channel_data: dict) -> NotificationChannel:
+        """Add a notification channel"""
+        with self.get_session() as session:
+            try:
+                channel = NotificationChannel(**channel_data)
+                session.add(channel)
+                session.commit()
+                session.refresh(channel)
+                logger.info(f"Added notification channel: {channel.name} (type: {channel.type})")
+                return channel
+            except Exception as e:
+                logger.error(f"Failed to add notification channel: {e}")
+                raise
+
+    def get_notification_channels(self, enabled_only: bool = True) -> List[NotificationChannel]:
+        """Get all notification channels"""
+        with self.get_session() as session:
+            query = session.query(NotificationChannel)
+            if enabled_only:
+                query = query.filter(NotificationChannel.enabled == True)
+            return query.all()
+
+    def get_notification_channels_by_ids(self, channel_ids: List[int]) -> List[NotificationChannel]:
+        """Get notification channels by their IDs"""
+        with self.get_session() as session:
+            channels = session.query(NotificationChannel).filter(
+                NotificationChannel.id.in_(channel_ids),
+                NotificationChannel.enabled == True
+            ).all()
+
+            # Detach from session to avoid lazy loading issues
+            session.expunge_all()
+            return channels
+
+    def update_notification_channel(self, channel_id: int, updates: dict) -> Optional[NotificationChannel]:
+        """Update a notification channel"""
+        with self.get_session() as session:
+            try:
+                channel = session.query(NotificationChannel).filter(NotificationChannel.id == channel_id).first()
+                if channel:
+                    for key, value in updates.items():
+                        setattr(channel, key, value)
+                    channel.updated_at = datetime.now()
+                    session.commit()
+                    session.refresh(channel)
+                    logger.info(f"Updated notification channel: {channel.name} (ID: {channel_id})")
+                return channel
+            except Exception as e:
+                logger.error(f"Failed to update notification channel {channel_id}: {e}")
+                raise
+
+    def delete_notification_channel(self, channel_id: int) -> bool:
+        """Delete a notification channel"""
+        with self.get_session() as session:
+            try:
+                channel = session.query(NotificationChannel).filter(NotificationChannel.id == channel_id).first()
+                if channel:
+                    channel_name = channel.name
+                    session.delete(channel)
+                    session.commit()
+                    logger.info(f"Deleted notification channel: {channel_name} (ID: {channel_id})")
+                    return True
+                logger.warning(f"Attempted to delete non-existent notification channel {channel_id}")
+                return False
+            except Exception as e:
+                logger.error(f"Failed to delete notification channel {channel_id}: {e}")
+                raise
+
+    # Alert Rules
+    def add_alert_rule(self, rule_data: dict) -> AlertRuleDB:
+        """Add an alert rule with container+host pairs"""
+        with self.get_session() as session:
+            try:
+                # Extract containers list if present
+                containers_data = rule_data.pop('containers', None)
+
+                rule = AlertRuleDB(**rule_data)
+                session.add(rule)
+                session.flush()  # Flush to get the ID without committing
+
+                # Add container+host pairs if provided
+                if containers_data:
+                    for container in containers_data:
+                        container_pair = AlertRuleContainer(
+                            alert_rule_id=rule.id,
+                            host_id=container['host_id'],
+                            container_name=container['container_name']
+                        )
+                        session.add(container_pair)
+
+                session.commit()
+                logger.info(f"Added alert rule: {rule.name} (ID: {rule.id})")
+            except Exception as e:
+                logger.error(f"Failed to add alert rule: {e}")
+                raise
+
+            # Create a detached copy with all needed attributes
+            rule_dict = {
+                'id': rule.id,
+                'name': rule.name,
+                'trigger_events': rule.trigger_events,
+                'trigger_states': rule.trigger_states,
+                'notification_channels': rule.notification_channels,
+                'cooldown_minutes': rule.cooldown_minutes,
+                'enabled': rule.enabled,
+                'last_triggered': rule.last_triggered,
+                'created_at': rule.created_at,
+                'updated_at': rule.updated_at
+            }
+
+            # Return a new instance that's not attached to the session
+            detached_rule = AlertRuleDB(**rule_dict)
+            detached_rule.containers = []  # Initialize empty containers list
+
+            return detached_rule
+
+    def get_alert_rule(self, rule_id: str) -> Optional[AlertRuleDB]:
+        """Get a single alert rule by ID"""
+        with self.get_session() as session:
+            from sqlalchemy.orm import joinedload
+            rule = session.query(AlertRuleDB).options(joinedload(AlertRuleDB.containers)).filter(AlertRuleDB.id == rule_id).first()
+            if rule:
+                session.expunge(rule)
+            return rule
+
+    def get_alert_rules(self, enabled_only: bool = True) -> List[AlertRuleDB]:
+        """Get all alert rules"""
+        with self.get_session() as session:
+            from sqlalchemy.orm import joinedload
+            query = session.query(AlertRuleDB).options(joinedload(AlertRuleDB.containers))
+            if enabled_only:
+                query = query.filter(AlertRuleDB.enabled == True)
+            rules = query.all()
+            # Detach from session to avoid lazy loading issues
+            for rule in rules:
+                session.expunge(rule)
+            return rules
+
+    def update_alert_rule(self, rule_id: str, updates: dict) -> Optional[AlertRuleDB]:
+        """Update an alert rule and its container+host pairs"""
+        with self.get_session() as session:
+            try:
+                from sqlalchemy.orm import joinedload
+                rule = session.query(AlertRuleDB).options(joinedload(AlertRuleDB.containers)).filter(AlertRuleDB.id == rule_id).first()
+                if rule:
+                    # Check if containers field is present before extracting it
+                    has_containers_update = 'containers' in updates
+                    containers_data = updates.pop('containers', None)
+
+                    # Update rule fields
+                    for key, value in updates.items():
+                        setattr(rule, key, value)
+                    rule.updated_at = datetime.now()
+
+                    # Update container+host pairs if containers field was explicitly provided
+                    # (could be None for "all containers", empty list, or list with specific containers)
+                    if has_containers_update:
+                        # Delete existing container pairs
+                        session.query(AlertRuleContainer).filter(
+                            AlertRuleContainer.alert_rule_id == rule_id
+                        ).delete()
+
+                        # Add new container pairs (if containers_data is None or empty, no new pairs are added)
+                        if containers_data:
+                            for container in containers_data:
+                                container_pair = AlertRuleContainer(
+                                    alert_rule_id=rule_id,
+                                    host_id=container['host_id'],
+                                    container_name=container['container_name']
+                                )
+                                session.add(container_pair)
+
+                    session.commit()
+                    session.refresh(rule)
+                    # Load containers relationship
+                    _ = rule.containers
+                    session.expunge(rule)
+                    logger.info(f"Updated alert rule: {rule.name} (ID: {rule_id})")
+                return rule
+            except Exception as e:
+                logger.error(f"Failed to update alert rule {rule_id}: {e}")
+                raise
+
+    def delete_alert_rule(self, rule_id: str) -> bool:
+        """Delete an alert rule"""
+        with self.get_session() as session:
+            try:
+                rule = session.query(AlertRuleDB).filter(AlertRuleDB.id == rule_id).first()
+                if rule:
+                    rule_name = rule.name
+                    session.delete(rule)
+                    session.commit()
+                    logger.info(f"Deleted alert rule: {rule_name} (ID: {rule_id})")
+                    return True
+                logger.warning(f"Attempted to delete non-existent alert rule {rule_id}")
+                return False
+            except Exception as e:
+                logger.error(f"Failed to delete alert rule {rule_id}: {e}")
+                raise
+
+    def get_alerts_dependent_on_channel(self, channel_id: int) -> List[dict]:
+        """Find alerts that would be orphaned if this channel is deleted (only have this one channel)"""
+        with self.get_session() as session:
+            all_rules = session.query(AlertRuleDB).all()
+            dependent_alerts = []
+
+            for rule in all_rules:
+                # Parse notification_channels JSON
+                channels = rule.notification_channels if isinstance(rule.notification_channels, list) else []
+                # Check if this is the ONLY channel for this alert
+                if len(channels) == 1 and channel_id in channels:
+                    dependent_alerts.append({
+                        'id': rule.id,
+                        'name': rule.name
+                    })
+
+            return dependent_alerts
+
+    # Event Logging Operations
+    def add_event(self, event_data: dict) -> EventLog:
+        """Add an event to the event log"""
+        with self.get_session() as session:
+            event = EventLog(**event_data)
+            session.add(event)
+            session.commit()
+            session.refresh(event)
+            return event
+
+    def get_events(self,
+                   category: Optional[List[str]] = None,
+                   event_type: Optional[str] = None,
+                   severity: Optional[List[str]] = None,
+                   host_id: Optional[List[str]] = None,
+                   container_id: Optional[str] = None,
+                   container_name: Optional[str] = None,
+                   start_date: Optional[datetime] = None,
+                   end_date: Optional[datetime] = None,
+                   correlation_id: Optional[str] = None,
+                   search: Optional[str] = None,
+                   limit: int = 100,
+                   offset: int = 0) -> tuple[List[EventLog], int]:
+        """Get events with filtering and pagination - returns (events, total_count)
+
+        Multi-select filters (category, severity, host_id) accept lists for OR filtering.
+        """
+        with self.get_session() as session:
+            query = session.query(EventLog)
+
+            # Apply filters - use IN clause for lists
+            if category:
+                if isinstance(category, list) and category:
+                    query = query.filter(EventLog.category.in_(category))
+                elif isinstance(category, str):
+                    query = query.filter(EventLog.category == category)
+            if event_type:
+                query = query.filter(EventLog.event_type == event_type)
+            if severity:
+                if isinstance(severity, list) and severity:
+                    query = query.filter(EventLog.severity.in_(severity))
+                elif isinstance(severity, str):
+                    query = query.filter(EventLog.severity == severity)
+            if host_id:
+                if isinstance(host_id, list) and host_id:
+                    query = query.filter(EventLog.host_id.in_(host_id))
+                elif isinstance(host_id, str):
+                    query = query.filter(EventLog.host_id == host_id)
+            if container_id:
+                query = query.filter(EventLog.container_id == container_id)
+            if container_name:
+                query = query.filter(EventLog.container_name.like(f'%{container_name}%'))
+            if start_date:
+                query = query.filter(EventLog.timestamp >= start_date)
+            if end_date:
+                query = query.filter(EventLog.timestamp <= end_date)
+            if correlation_id:
+                query = query.filter(EventLog.correlation_id == correlation_id)
+            if search:
+                search_term = f'%{search}%'
+                query = query.filter(
+                    (EventLog.title.like(search_term)) |
+                    (EventLog.message.like(search_term)) |
+                    (EventLog.container_name.like(search_term))
+                )
+
+            # Get total count for pagination
+            total_count = query.count()
+
+            # Apply ordering, limit and offset
+            events = query.order_by(EventLog.timestamp.desc()).offset(offset).limit(limit).all()
+
+            return events, total_count
+
+    def get_event_by_id(self, event_id: int) -> Optional[EventLog]:
+        """Get a specific event by ID"""
+        with self.get_session() as session:
+            return session.query(EventLog).filter(EventLog.id == event_id).first()
+
+    def get_events_by_correlation(self, correlation_id: str) -> List[EventLog]:
+        """Get all events with the same correlation ID"""
+        with self.get_session() as session:
+            return session.query(EventLog).filter(
+                EventLog.correlation_id == correlation_id
+            ).order_by(EventLog.timestamp.asc()).all()
+
+    def cleanup_old_events(self, days: int = 30):
+        """Clean up old event logs"""
+        with self.get_session() as session:
+            cutoff_date = datetime.now() - timedelta(days=days)
+            deleted_count = session.query(EventLog).filter(
+                EventLog.timestamp < cutoff_date
+            ).delete()
+            session.commit()
+            return deleted_count
+
+    def get_event_statistics(self,
+                           start_date: Optional[datetime] = None,
+                           end_date: Optional[datetime] = None) -> Dict[str, Any]:
+        """Get event statistics for dashboard"""
+        with self.get_session() as session:
+            query = session.query(EventLog)
+
+            if start_date:
+                query = query.filter(EventLog.timestamp >= start_date)
+            if end_date:
+                query = query.filter(EventLog.timestamp <= end_date)
+
+            total_events = query.count()
+
+            # Count by category
+            category_counts = {}
+            for category, count in session.query(EventLog.category,
+                                               session.func.count(EventLog.id)).group_by(EventLog.category).all():
+                category_counts[category] = count
+
+            # Count by severity
+            severity_counts = {}
+            for severity, count in session.query(EventLog.severity,
+                                               session.func.count(EventLog.id)).group_by(EventLog.severity).all():
+                severity_counts[severity] = count
+
+            return {
+                'total_events': total_events,
+                'category_counts': category_counts,
+                'severity_counts': severity_counts,
+                'period_start': start_date.isoformat() if start_date else None,
+                'period_end': end_date.isoformat() if end_date else None
+            }
+
+
+    # User management methods
+    def _hash_password(self, password: str) -> str:
+        """Hash a password using bcrypt with salt"""
+        # Generate salt and hash password
+        salt = bcrypt.gensalt(rounds=12)  # 12 rounds is a good balance of security/speed
+        hashed = bcrypt.hashpw(password.encode('utf-8'), salt)
+        return hashed.decode('utf-8')
+
+    def _verify_password(self, password: str, hashed: str) -> bool:
+        """Verify a password against a bcrypt hash"""
+        return bcrypt.checkpw(password.encode('utf-8'), hashed.encode('utf-8'))
+
+    def get_or_create_default_user(self) -> None:
+        """Create default admin user if no users exist"""
+        with self.get_session() as session:
+            # Check if ANY user exists (not just 'admin')
+            user_count = session.query(User).count()
+            if user_count == 0:
+                # Only create default admin user if no users exist at all
+                user = User(
+                    username="admin",
+                    password_hash=self._hash_password("dockmon123"),  # Default password
+                    is_first_login=True,
+                    must_change_password=True
+                )
+                session.add(user)
+                session.commit()
+                logger.info("Created default admin user")
+
+    def verify_user_credentials(self, username: str, password: str) -> Optional[Dict[str, Any]]:
+        """Verify user credentials and return user info if valid"""
+        with self.get_session() as session:
+            user = session.query(User).filter(User.username == username).first()
+
+            # Prevent timing attack: always run bcrypt even if user doesn't exist
+            if user:
+                is_valid = self._verify_password(password, user.password_hash)
+            else:
+                # Run dummy bcrypt to maintain constant time
+                dummy_hash = "$2b$12$LQv3c1yqBWVHxkd0LHAkCOYz6TtxMQJqhN8/LewY5GyYFj.N/wx9S"
+                self._verify_password(password, dummy_hash)
+                is_valid = False
+
+            if user and is_valid:
+                # Update last login
+                user.last_login = datetime.now()
+                session.commit()
+                return {
+                    "username": user.username,
+                    "is_first_login": user.is_first_login,
+                    "must_change_password": user.must_change_password
+                }
+            return None
+
+    def change_user_password(self, username: str, new_password: str) -> bool:
+        """Change user password"""
+        with self.get_session() as session:
+            user = session.query(User).filter(User.username == username).first()
+            if user:
+                user.password_hash = self._hash_password(new_password)
+                user.is_first_login = False
+                user.must_change_password = False
+                user.updated_at = datetime.now()
+                session.commit()
+                logger.info(f"Password changed for user: {username}")
+                return True
+            return False
+
+    def username_exists(self, username: str) -> bool:
+        """Check if username already exists"""
+        with self.get_session() as session:
+            user = session.query(User).filter(User.username == username).first()
+            return user is not None
+
+    def change_username(self, old_username: str, new_username: str) -> bool:
+        """Change user's username"""
+        with self.get_session() as session:
+            user = session.query(User).filter(User.username == old_username).first()
+            if user:
+                user.username = new_username
+                user.updated_at = datetime.now()
+                session.commit()
+                logger.info(f"Username changed from {old_username} to {new_username}")
+                return True
+            return False
+
+    def reset_user_password(self, username: str, new_password: str = None) -> str:
+        """Reset user password (for CLI tool)"""
+        with self.get_session() as session:
+            user = session.query(User).filter(User.username == username).first()
+            if not user:
+                return None
+
+            # Generate new password if not provided
+            if not new_password:
+                new_password = secrets.token_urlsafe(12)
+
+            user.password_hash = self._hash_password(new_password)
+            user.must_change_password = True
+            user.updated_at = datetime.now()
+            session.commit()
+            logger.info(f"Password reset for user: {username}")
+            return new_password
+
+    def list_users(self) -> List[str]:
+        """List all usernames"""
+        with self.get_session() as session:
+            users = session.query(User.username).all()
+            return [u[0] for u in users]
+
+    def get_dashboard_layout(self, username: str) -> Optional[str]:
+        """Get dashboard layout for a user"""
+        with self.get_session() as session:
+            user = session.query(User).filter(User.username == username).first()
+            if user:
+                return user.dashboard_layout
+            return None
+
+    def save_dashboard_layout(self, username: str, layout: str) -> bool:
+        """Save dashboard layout for a user"""
+        with self.get_session() as session:
+            user = session.query(User).filter(User.username == username).first()
+            if user:
+                user.dashboard_layout = layout
+                user.updated_at = datetime.now()
+                session.commit()
+                return True
+            return False
+
+    def get_modal_preferences(self, username: str) -> Optional[str]:
+        """Get modal preferences for a user"""
+        with self.get_session() as session:
+            user = session.query(User).filter(User.username == username).first()
+            if user:
+                return user.modal_preferences
+            return None
+
+    def save_modal_preferences(self, username: str, preferences: str) -> bool:
+        """Save modal preferences for a user"""
+        with self.get_session() as session:
+            user = session.query(User).filter(User.username == username).first()
+            if user:
+                user.modal_preferences = preferences
+                user.updated_at = datetime.now()
+                session.commit()
+                return True
+            return False
+
+    def get_event_sort_order(self, username: str) -> str:
+        """Get event sort order preference for a user"""
+        with self.get_session() as session:
+            user = session.query(User).filter(User.username == username).first()
+            if user and user.event_sort_order:
+                return user.event_sort_order
+            return 'desc'  # Default to newest first
+
+    def save_event_sort_order(self, username: str, sort_order: str) -> bool:
+        """Save event sort order preference for a user"""
+        with self.get_session() as session:
+            user = session.query(User).filter(User.username == username).first()
+            if user:
+                # Validate sort order
+                if sort_order not in ['asc', 'desc']:
+                    return False
+                user.event_sort_order = sort_order
+                user.updated_at = datetime.now()
+                session.commit()
+                return True
+            return False
+
+    def get_container_sort_order(self, username: str) -> str:
+        """Get container sort order preference for a user"""
+        with self.get_session() as session:
+            user = session.query(User).filter(User.username == username).first()
+            if user and user.container_sort_order:
+                return user.container_sort_order
+            return 'name-asc'  # Default to name A-Z
+
+    def save_container_sort_order(self, username: str, sort_order: str) -> bool:
+        """Save container sort order preference for a user"""
+        with self.get_session() as session:
+            user = session.query(User).filter(User.username == username).first()
+            if user:
+                # Validate sort order
+                valid_sorts = ['name-asc', 'name-desc', 'status', 'memory-desc', 'memory-asc', 'cpu-desc', 'cpu-asc']
+                if sort_order not in valid_sorts:
+                    return False
+                user.container_sort_order = sort_order
+                user.updated_at = datetime.now()
+                session.commit()
+                return True
+            return False
\ No newline at end of file
diff --git a/dockmon/backend/docker_monitor/__init__.py b/dockmon/backend/docker_monitor/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/dockmon/backend/docker_monitor/monitor.py b/dockmon/backend/docker_monitor/monitor.py
new file mode 100644
index 0000000..e5016f3
--- /dev/null
+++ b/dockmon/backend/docker_monitor/monitor.py
@@ -0,0 +1,1554 @@
+"""
+Docker Monitoring Core for DockMon
+Main monitoring class for Docker containers and hosts
+"""
+
+import asyncio
+import logging
+import os
+import shutil
+import time
+import uuid
+from datetime import datetime
+from typing import Dict, List, Optional
+
+import docker
+from docker import DockerClient
+from fastapi import HTTPException
+
+from config.paths import DATABASE_PATH, CERTS_DIR
+from database import DatabaseManager, AutoRestartConfig, GlobalSettings, DockerHostDB
+from models.docker_models import DockerHost, DockerHostConfig, Container
+from models.settings_models import AlertRule, NotificationSettings
+from websocket.connection import ConnectionManager
+from realtime import RealtimeMonitor
+from notifications import NotificationService, AlertProcessor
+from event_logger import EventLogger, EventSeverity, EventType
+from stats_client import get_stats_client
+from docker_monitor.stats_manager import StatsManager
+from auth.session_manager import session_manager
+
+
+logger = logging.getLogger(__name__)
+
+
+def _handle_task_exception(task: asyncio.Task) -> None:
+    """Handle exceptions from fire-and-forget async tasks"""
+    try:
+        task.result()
+    except asyncio.CancelledError:
+        pass  # Task was cancelled, this is normal
+    except Exception as e:
+        logger.error(f"Unhandled exception in background task: {e}", exc_info=True)
+
+
+def sanitize_host_id(host_id: str) -> str:
+    """
+    Sanitize host ID to prevent path traversal attacks.
+    Only allows valid UUID format or alphanumeric + dash characters.
+    """
+    if not host_id:
+        raise ValueError("Host ID cannot be empty")
+
+    # Check for path traversal attempts
+    if ".." in host_id or "/" in host_id or "\\" in host_id:
+        raise ValueError(f"Invalid host ID format: {host_id}")
+
+    # Try to validate as UUID first
+    try:
+        uuid.UUID(host_id)
+        return host_id
+    except ValueError:
+        # If not a valid UUID, only allow alphanumeric and dashes
+        import re
+        if re.match(r'^[a-zA-Z0-9\-]+$', host_id):
+            return host_id
+        else:
+            raise ValueError(f"Invalid host ID format: {host_id}")
+
+
+class DockerMonitor:
+    """Main monitoring class for Docker containers"""
+
+    def __init__(self):
+        self.hosts: Dict[str, DockerHost] = {}
+        self.clients: Dict[str, DockerClient] = {}
+        self.db = DatabaseManager(DATABASE_PATH)  # Initialize database with centralized path
+        self.settings = self.db.get_settings()  # Load settings from DB
+        self.notification_settings = NotificationSettings()
+        self.auto_restart_status: Dict[str, bool] = {}
+        self.restart_attempts: Dict[str, int] = {}
+        self.restarting_containers: Dict[str, bool] = {}  # Track containers currently being restarted
+        self.monitoring_task: Optional[asyncio.Task] = None
+
+        # Reconnection tracking with exponential backoff
+        self.reconnect_attempts: Dict[str, int] = {}  # Track reconnect attempts per host
+        self.last_reconnect_attempt: Dict[str, float] = {}  # Track last attempt time per host
+        self.manager = ConnectionManager()
+        self.realtime = RealtimeMonitor()  # Real-time monitoring
+        self.event_logger = EventLogger(self.db, self.manager)  # Event logging service with WebSocket support
+        self.notification_service = NotificationService(self.db, self.event_logger)  # Notification service
+        self.alert_processor = AlertProcessor(self.notification_service)  # Alert processor
+        self._container_states: Dict[str, str] = {}  # Track container states for change detection
+        self._recent_user_actions: Dict[str, float] = {}  # Track recent user actions: {container_key: timestamp}
+        self.cleanup_task: Optional[asyncio.Task] = None  # Background cleanup task
+
+        # Locks for shared data structures to prevent race conditions
+        self._state_lock = asyncio.Lock()
+        self._actions_lock = asyncio.Lock()
+        self._restart_lock = asyncio.Lock()
+
+        # Stats collection manager
+        self.stats_manager = StatsManager()
+        self._load_persistent_config()  # Load saved hosts and configs
+
+    def add_host(self, config: DockerHostConfig, existing_id: str = None, skip_db_save: bool = False, suppress_event_loop_errors: bool = False) -> DockerHost:
+        """Add a new Docker host to monitor"""
+        client = None  # Track client for cleanup on error
+        try:
+            # Validate certificates if provided (before trying to use them)
+            if config.tls_cert or config.tls_key or config.tls_ca:
+                self._validate_certificates(config)
+
+            # Create Docker client
+            if config.url.startswith("unix://"):
+                client = docker.DockerClient(base_url=config.url)
+            else:
+                # For TCP connections
+                tls_config = None
+                if config.tls_cert and config.tls_key:
+                    # Create persistent certificate storage directory
+                    safe_id = sanitize_host_id(existing_id or str(uuid.uuid4()))
+                    cert_dir = os.path.join(CERTS_DIR, safe_id)
+
+                    # Create with secure permissions - handle TOCTOU race condition
+                    try:
+                        os.makedirs(cert_dir, mode=0o700, exist_ok=False)
+                    except FileExistsError:
+                        # Verify it's actually a directory and not a symlink/file
+                        import stat
+                        st = os.lstat(cert_dir)  # Use lstat to not follow symlinks
+                        if not stat.S_ISDIR(st.st_mode):
+                            raise ValueError("Certificate path exists but is not a directory")
+
+                    # Write certificate files
+                    cert_file = os.path.join(cert_dir, 'client-cert.pem')
+                    key_file = os.path.join(cert_dir, 'client-key.pem')
+                    ca_file = os.path.join(cert_dir, 'ca.pem') if config.tls_ca else None
+
+                    with open(cert_file, 'w') as f:
+                        f.write(config.tls_cert)
+                    with open(key_file, 'w') as f:
+                        f.write(config.tls_key)
+                    if ca_file and config.tls_ca:
+                        with open(ca_file, 'w') as f:
+                            f.write(config.tls_ca)
+
+                    # Set secure permissions
+                    os.chmod(cert_file, 0o600)
+                    os.chmod(key_file, 0o600)
+                    if ca_file:
+                        os.chmod(ca_file, 0o600)
+
+                    tls_config = docker.tls.TLSConfig(
+                        client_cert=(cert_file, key_file),
+                        ca_cert=ca_file,
+                        verify=bool(config.tls_ca)
+                    )
+
+                client = docker.DockerClient(
+                    base_url=config.url,
+                    tls=tls_config,
+                    timeout=self.settings.connection_timeout
+                )
+
+            # Test connection
+            client.ping()
+
+            # Validate TLS configuration for TCP connections
+            security_status = self._validate_host_security(config)
+
+            # Create host object with existing ID if provided (for persistence after restarts)
+            # Sanitize the ID to prevent path traversal
+            host_id = existing_id or str(uuid.uuid4())
+            try:
+                host_id = sanitize_host_id(host_id)
+            except ValueError as e:
+                logger.error(f"Invalid host ID: {e}")
+                raise HTTPException(status_code=400, detail=str(e))
+
+            host = DockerHost(
+                id=host_id,
+                name=config.name,
+                url=config.url,
+                status="online",
+                security_status=security_status
+            )
+
+            # Store client and host
+            self.clients[host.id] = client
+            self.hosts[host.id] = host
+
+            # Save to database only if not reconnecting to an existing host
+            if not skip_db_save:
+                db_host = self.db.add_host({
+                    'id': host.id,
+                    'name': config.name,
+                    'url': config.url,
+                    'tls_cert': config.tls_cert,
+                    'tls_key': config.tls_key,
+                    'tls_ca': config.tls_ca,
+                    'security_status': security_status
+                })
+
+            # Register host with stats and event services
+            # Only register if we're adding a NEW host (not during startup/reconnect)
+            # During startup, monitor_containers() handles all registrations
+            if not skip_db_save:  # New host being added by user
+                try:
+                    import asyncio
+                    stats_client = get_stats_client()
+
+                    async def register_host():
+                        try:
+                            await stats_client.add_docker_host(host.id, host.url, config.tls_ca, config.tls_cert, config.tls_key)
+                            logger.info(f"Registered {host.name} ({host.id[:8]}) with stats service")
+
+                            await stats_client.add_event_host(host.id, host.url, config.tls_ca, config.tls_cert, config.tls_key)
+                            logger.info(f"Registered {host.name} ({host.id[:8]}) with event service")
+                        except Exception as e:
+                            logger.error(f"Failed to register {host.name} with Go services: {e}")
+
+                    # Try to create task if event loop is running
+                    try:
+                        task = asyncio.create_task(register_host())
+                        task.add_done_callback(_handle_task_exception)
+                    except RuntimeError:
+                        # No event loop running - will be registered by monitor_containers()
+                        logger.debug(f"No event loop yet - {host.name} will be registered when monitoring starts")
+                except Exception as e:
+                    logger.warning(f"Could not register {host.name} with Go services: {e}")
+
+            # Log host connection
+            self.event_logger.log_host_connection(
+                host_name=host.name,
+                host_id=host.id,
+                host_url=config.url,
+                connected=True
+            )
+
+            # Log host added (only for new hosts, not reconnects)
+            if not skip_db_save:
+                self.event_logger.log_host_added(
+                    host_name=host.name,
+                    host_id=host.id,
+                    host_url=config.url,
+                    triggered_by="user"
+                )
+
+            logger.info(f"Added Docker host: {host.name} ({host.url})")
+            return host
+
+        except Exception as e:
+            # Clean up client if it was created but not stored
+            if client is not None:
+                try:
+                    client.close()
+                    logger.debug(f"Closed orphaned Docker client for {config.name}")
+                except Exception as close_error:
+                    logger.debug(f"Error closing Docker client: {close_error}")
+
+            # Suppress event loop errors during first run startup
+            if suppress_event_loop_errors and "no running event loop" in str(e):
+                logger.debug(f"Event loop warning for {config.name} (expected during startup): {e}")
+                # Re-raise so the caller knows host was added but with event loop issue
+                raise
+            else:
+                logger.error(f"Failed to add host {config.name}: {e}")
+                error_msg = self._get_user_friendly_error(str(e))
+                raise HTTPException(status_code=400, detail=error_msg)
+
+    def _get_user_friendly_error(self, error: str) -> str:
+        """Convert technical Docker errors to user-friendly messages"""
+        error_lower = error.lower()
+
+        # SSL/TLS certificate errors
+        if 'ssl' in error_lower or 'tls' in error_lower:
+            if 'pem lib' in error_lower or 'pem' in error_lower:
+                return (
+                    "SSL certificate error: The certificates provided appear to be invalid or don't match. "
+                    "Please verify:\n"
+                    "• The certificates are for the correct server (check hostname/IP)\n"
+                    "• The client certificate and private key are a matching pair\n"
+                    "• The CA certificate matches the server's certificate\n"
+                    "• The certificates haven't expired"
+                )
+            elif 'certificate verify failed' in error_lower:
+                return (
+                    "SSL certificate verification failed: The server's certificate is not trusted by the CA certificate you provided. "
+                    "Make sure you're using the correct CA certificate that signed the server's certificate."
+                )
+            elif 'ssleof' in error_lower or 'connection reset' in error_lower:
+                return (
+                    "SSL connection failed: The server closed the connection during SSL handshake. "
+                    "This usually means the server doesn't recognize the certificates. "
+                    "Verify you're using the correct certificates for this server."
+                )
+            else:
+                return f"SSL/TLS error: Unable to establish secure connection. {error}"
+
+        # Connection errors
+        elif 'connection refused' in error_lower:
+            return (
+                "Connection refused: The Docker daemon is not accepting connections on this address. "
+                "Make sure:\n"
+                "• Docker is running on the remote host\n"
+                "• The Docker daemon is configured to listen on the specified port\n"
+                "• Firewall allows connections to the port"
+            )
+        elif 'timeout' in error_lower or 'timed out' in error_lower:
+            return (
+                "Connection timeout: Unable to reach the Docker daemon. "
+                "Check that the host address is correct and the host is reachable on your network."
+            )
+        elif 'no route to host' in error_lower or 'network unreachable' in error_lower:
+            return (
+                "Network unreachable: Cannot reach the specified host. "
+                "Verify the IP address/hostname is correct and the host is on your network."
+            )
+        elif 'http request to an https server' in error_lower:
+            return (
+                "Protocol mismatch: You're trying to connect without TLS to a server that requires TLS. "
+                "The server expects HTTPS connections. Please provide TLS certificates or change the server configuration."
+            )
+
+        # Return original error if we don't have a friendly version
+        return error
+
+    def _validate_certificates(self, config: DockerHostConfig):
+        """Validate certificate format before attempting to use them"""
+
+        def check_cert_format(cert_data: str, cert_type: str):
+            """Check if certificate has proper PEM format markers"""
+            if not cert_data or not cert_data.strip():
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"{cert_type} is empty. Please paste the certificate content."
+                )
+
+            cert_data = cert_data.strip()
+
+            # Check for BEGIN marker
+            if "-----BEGIN" not in cert_data:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"{cert_type} is missing the '-----BEGIN' header. Make sure you copied the complete certificate including the BEGIN line."
+                )
+
+            # Check for END marker
+            if "-----END" not in cert_data:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"{cert_type} is missing the '-----END' footer. Make sure you copied the complete certificate including the END line."
+                )
+
+            # Check BEGIN comes before END
+            begin_pos = cert_data.find("-----BEGIN")
+            end_pos = cert_data.find("-----END")
+            if begin_pos >= end_pos:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"{cert_type} format is invalid. The '-----BEGIN' line should come before the '-----END' line."
+                )
+
+            # Check for certificate data between markers
+            cert_content = cert_data[begin_pos:end_pos + 50]  # Include END marker
+            lines = cert_content.split('\n')
+            if len(lines) < 3:  # Should have BEGIN, at least one data line, and END
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"{cert_type} appears to be incomplete. Make sure you copied all lines between BEGIN and END."
+                )
+
+        # Validate each certificate type
+        if config.tls_ca:
+            check_cert_format(config.tls_ca, "CA Certificate")
+
+        if config.tls_cert:
+            check_cert_format(config.tls_cert, "Client Certificate")
+
+        if config.tls_key:
+            # Private keys can be PRIVATE KEY or RSA PRIVATE KEY
+            key_data = config.tls_key.strip()
+            if "-----BEGIN" not in key_data or "-----END" not in key_data:
+                raise HTTPException(
+                    status_code=400,
+                    detail="Client Private Key is incomplete. Make sure you copied the complete key including both '-----BEGIN' and '-----END' lines."
+                )
+
+    def _validate_host_security(self, config: DockerHostConfig) -> str:
+        """Validate the security configuration of a Docker host"""
+        if config.url.startswith("unix://"):
+            return "secure"  # Unix sockets are secure (local only)
+        elif config.url.startswith("tcp://"):
+            if config.tls_cert and config.tls_key and config.tls_ca:
+                return "secure"  # Has TLS certificates
+            else:
+                logger.warning(f"Host {config.name} configured without TLS - connection is insecure!")
+                return "insecure"  # TCP without TLS
+        else:
+            return "unknown"  # Unknown protocol
+
+    def _cleanup_host_certificates(self, host_id: str):
+        """Clean up certificate files for a host"""
+        safe_id = sanitize_host_id(host_id)
+        cert_dir = os.path.join(CERTS_DIR, safe_id)
+
+        # Defense in depth: verify path is within CERTS_DIR
+        abs_cert_dir = os.path.abspath(cert_dir)
+        abs_certs_dir = os.path.abspath(CERTS_DIR)
+        if not abs_cert_dir.startswith(abs_certs_dir):
+            logger.error(f"Path traversal attempt detected: {host_id}")
+            raise ValueError("Invalid certificate path")
+
+        if os.path.exists(cert_dir):
+            try:
+                shutil.rmtree(cert_dir)
+                logger.info(f"Cleaned up certificate files for host {host_id}")
+            except Exception as e:
+                logger.warning(f"Failed to clean up certificates for host {host_id}: {e}")
+
+    async def remove_host(self, host_id: str):
+        """Remove a Docker host"""
+        # Validate host_id to prevent path traversal
+        try:
+            host_id = sanitize_host_id(host_id)
+        except ValueError as e:
+            logger.error(f"Invalid host ID: {e}")
+            raise HTTPException(status_code=400, detail=str(e))
+
+        if host_id in self.hosts:
+            # Get host info before removing
+            host = self.hosts[host_id]
+            host_name = host.name
+
+            del self.hosts[host_id]
+            if host_id in self.clients:
+                self.clients[host_id].close()
+                del self.clients[host_id]
+
+            # Remove from Go stats and event services (await to ensure cleanup completes before returning)
+            try:
+                stats_client = get_stats_client()
+
+                try:
+                    # Remove from stats service (closes Docker client and stops all container streams)
+                    await stats_client.remove_docker_host(host_id)
+                    logger.info(f"Removed {host_name} ({host_id[:8]}) from stats service")
+
+                    # Remove from event service
+                    await stats_client.remove_event_host(host_id)
+                    logger.info(f"Removed {host_name} ({host_id[:8]}) from event service")
+                except asyncio.TimeoutError:
+                    # Timeout during cleanup is expected - Go service closes connections immediately
+                    logger.debug(f"Timeout removing {host_name} from Go services (expected during cleanup)")
+                except Exception as e:
+                    logger.error(f"Failed to remove {host_name} from Go services: {e}")
+            except Exception as e:
+                logger.warning(f"Failed to remove host {host_id} from Go services: {e}")
+
+            # Clean up certificate files
+            self._cleanup_host_certificates(host_id)
+            # Remove from database
+            self.db.delete_host(host_id)
+
+            # Clean up container state tracking for this host
+            async with self._state_lock:
+                containers_to_remove = [key for key in self._container_states.keys() if key.startswith(f"{host_id}:")]
+                for container_key in containers_to_remove:
+                    del self._container_states[container_key]
+
+            # Clean up recent user actions for this host
+            async with self._actions_lock:
+                actions_to_remove = [key for key in self._recent_user_actions.keys() if key.startswith(f"{host_id}:")]
+                for container_key in actions_to_remove:
+                    del self._recent_user_actions[container_key]
+
+            # Clean up notification service's container state tracking for this host
+            notification_states_to_remove = [key for key in self.notification_service._last_container_state.keys() if key.startswith(f"{host_id}:")]
+            for container_key in notification_states_to_remove:
+                del self.notification_service._last_container_state[container_key]
+
+            # Clean up alert processor's container state tracking for this host
+            alert_processor_states_to_remove = [key for key in self.alert_processor._container_states.keys() if key.startswith(f"{host_id}:")]
+            for container_key in alert_processor_states_to_remove:
+                del self.alert_processor._container_states[container_key]
+
+            # Clean up notification service's alert cooldown tracking for this host
+            alert_cooldowns_to_remove = [key for key in self.notification_service._last_alerts.keys() if key.startswith(f"{host_id}:")]
+            for container_key in alert_cooldowns_to_remove:
+                del self.notification_service._last_alerts[container_key]
+
+            # Clean up reconnection tracking for this host
+            if host_id in self.reconnect_attempts:
+                del self.reconnect_attempts[host_id]
+            if host_id in self.last_reconnect_attempt:
+                del self.last_reconnect_attempt[host_id]
+
+            # Clean up auto-restart tracking for this host
+            async with self._restart_lock:
+                auto_restart_to_remove = [key for key in self.auto_restart_status.keys() if key.startswith(f"{host_id}:")]
+                for container_key in auto_restart_to_remove:
+                    del self.auto_restart_status[container_key]
+                    if container_key in self.restart_attempts:
+                        del self.restart_attempts[container_key]
+                    if container_key in self.restarting_containers:
+                        del self.restarting_containers[container_key]
+
+            # Clean up stats manager's streaming containers for this host
+            # Remove using the full composite key (format: "host_id:container_id")
+            for container_key in containers_to_remove:
+                self.stats_manager.streaming_containers.discard(container_key)
+
+            if containers_to_remove:
+                logger.debug(f"Cleaned up {len(containers_to_remove)} container state entries for removed host {host_id[:8]}")
+            if notification_states_to_remove:
+                logger.debug(f"Cleaned up {len(notification_states_to_remove)} notification state entries for removed host {host_id[:8]}")
+            if alert_processor_states_to_remove:
+                logger.debug(f"Cleaned up {len(alert_processor_states_to_remove)} alert processor state entries for removed host {host_id[:8]}")
+            if alert_cooldowns_to_remove:
+                logger.debug(f"Cleaned up {len(alert_cooldowns_to_remove)} alert cooldown entries for removed host {host_id[:8]}")
+            if auto_restart_to_remove:
+                logger.debug(f"Cleaned up {len(auto_restart_to_remove)} auto-restart entries for removed host {host_id[:8]}")
+
+            # Log host removed
+            self.event_logger.log_host_removed(
+                host_name=host_name,
+                host_id=host_id,
+                triggered_by="user"
+            )
+
+            logger.info(f"Removed host {host_id}")
+
+    def update_host(self, host_id: str, config: DockerHostConfig):
+        """Update an existing Docker host"""
+        # Validate host_id to prevent path traversal
+        try:
+            host_id = sanitize_host_id(host_id)
+        except ValueError as e:
+            logger.error(f"Invalid host ID: {e}")
+            raise HTTPException(status_code=400, detail=str(e))
+
+        client = None  # Track client for cleanup on error
+        try:
+            # Get existing host from database to check if we need to preserve certificates
+            existing_host = self.db.get_host(host_id)
+            if not existing_host:
+                raise HTTPException(status_code=404, detail=f"Host {host_id} not found")
+
+            # If certificates are not provided in the update, use existing ones
+            # This allows updating just the name without providing certificates again
+            if not config.tls_cert and existing_host.tls_cert:
+                config.tls_cert = existing_host.tls_cert
+            if not config.tls_key and existing_host.tls_key:
+                config.tls_key = existing_host.tls_key
+            if not config.tls_ca and existing_host.tls_ca:
+                config.tls_ca = existing_host.tls_ca
+
+            # Only validate certificates if NEW ones are provided (not using existing)
+            # Check if any NEW certificate data was actually sent in the request
+            if (config.tls_cert and config.tls_cert != existing_host.tls_cert) or \
+               (config.tls_key and config.tls_key != existing_host.tls_key) or \
+               (config.tls_ca and config.tls_ca != existing_host.tls_ca):
+                self._validate_certificates(config)
+
+            # Remove the existing host from memory first
+            if host_id in self.hosts:
+                # Close existing client first (this should stop the monitoring task)
+                if host_id in self.clients:
+                    logger.info(f"Closing Docker client for host {host_id}")
+                    self.clients[host_id].close()
+                    del self.clients[host_id]
+
+                # Remove from memory
+                del self.hosts[host_id]
+
+            # Validate TLS configuration
+            security_status = self._validate_host_security(config)
+
+            # Update database
+            updated_db_host = self.db.update_host(host_id, {
+                'name': config.name,
+                'url': config.url,
+                'tls_cert': config.tls_cert,
+                'tls_key': config.tls_key,
+                'tls_ca': config.tls_ca,
+                'security_status': security_status
+            })
+
+            if not updated_db_host:
+                raise Exception(f"Host {host_id} not found in database")
+
+            # Create new Docker client with updated config
+            if config.url.startswith("unix://"):
+                client = docker.DockerClient(base_url=config.url)
+            else:
+                # For TCP connections
+                tls_config = None
+                if config.tls_cert and config.tls_key:
+                    # Create persistent certificate storage directory
+                    safe_id = sanitize_host_id(host_id)
+                    cert_dir = os.path.join(CERTS_DIR, safe_id)
+                    # Create with secure permissions to avoid TOCTOU race condition
+                    os.makedirs(cert_dir, mode=0o700, exist_ok=True)
+
+                    # Write certificate files
+                    cert_file = os.path.join(cert_dir, 'client-cert.pem')
+                    key_file = os.path.join(cert_dir, 'client-key.pem')
+                    ca_file = os.path.join(cert_dir, 'ca.pem') if config.tls_ca else None
+
+                    with open(cert_file, 'w') as f:
+                        f.write(config.tls_cert)
+                    with open(key_file, 'w') as f:
+                        f.write(config.tls_key)
+                    if ca_file and config.tls_ca:
+                        with open(ca_file, 'w') as f:
+                            f.write(config.tls_ca)
+
+                    # Set secure permissions
+                    os.chmod(cert_file, 0o600)
+                    os.chmod(key_file, 0o600)
+                    if ca_file:
+                        os.chmod(ca_file, 0o600)
+
+                    tls_config = docker.tls.TLSConfig(
+                        client_cert=(cert_file, key_file),
+                        ca_cert=ca_file,
+                        verify=bool(config.tls_ca)
+                    )
+
+                client = docker.DockerClient(
+                    base_url=config.url,
+                    tls=tls_config,
+                    timeout=self.settings.connection_timeout
+                )
+
+            # Test connection
+            client.ping()
+
+            # Create host object with existing ID
+            host = DockerHost(
+                id=host_id,
+                name=config.name,
+                url=config.url,
+                status="online",
+                security_status=security_status
+            )
+
+            # Store client and host
+            self.clients[host.id] = client
+            self.hosts[host.id] = host
+
+            # Re-register host with stats and event services (in case URL changed)
+            # Note: add_docker_host() automatically closes old client if it exists
+            try:
+                import asyncio
+                stats_client = get_stats_client()
+
+                async def reregister_host():
+                    try:
+                        # Re-register with stats service (automatically closes old client)
+                        await stats_client.add_docker_host(host.id, host.url, config.tls_ca, config.tls_cert, config.tls_key)
+                        logger.info(f"Re-registered {host.name} ({host.id[:8]}) with stats service")
+
+                        # Remove and re-add event monitoring
+                        await stats_client.remove_event_host(host.id)
+                        await stats_client.add_event_host(host.id, host.url, config.tls_ca, config.tls_cert, config.tls_key)
+                        logger.info(f"Re-registered {host.name} ({host.id[:8]}) with event service")
+                    except Exception as e:
+                        logger.error(f"Failed to re-register {host.name} with Go services: {e}")
+
+                # Create task to re-register (fire and forget)
+                task = asyncio.create_task(reregister_host())
+                task.add_done_callback(_handle_task_exception)
+            except Exception as e:
+                logger.warning(f"Could not re-register {host.name} with Go services: {e}")
+
+            # Log host update
+            self.event_logger.log_host_connection(
+                host_name=host.name,
+                host_id=host.id,
+                host_url=config.url,
+                connected=True
+            )
+
+            logger.info(f"Successfully updated host {host_id}: {host.name} ({host.url})")
+            return host
+
+        except Exception as e:
+            # Clean up client if it was created but not stored
+            if client and host_id not in self.clients:
+                try:
+                    client.close()
+                    logger.debug(f"Closed orphaned Docker client for host {host_id[:8]}")
+                except Exception as close_error:
+                    logger.debug(f"Error closing Docker client: {close_error}")
+
+            logger.error(f"Failed to update host {host_id}: {e}")
+            error_msg = self._get_user_friendly_error(str(e))
+            raise HTTPException(status_code=400, detail=error_msg)
+
+    async def get_containers(self, host_id: Optional[str] = None) -> List[Container]:
+        """Get containers from one or all hosts"""
+        containers = []
+
+        hosts_to_check = [host_id] if host_id else list(self.hosts.keys())
+
+        for hid in hosts_to_check:
+            host = self.hosts.get(hid)
+            if not host:
+                continue
+
+            # Try to reconnect if host exists but has no client (offline)
+            if hid not in self.clients:
+                # Exponential backoff: 5s, 10s, 20s, 40s, 80s, max 5 minutes
+                now = time.time()
+                attempts = self.reconnect_attempts.get(hid, 0)
+                last_attempt = self.last_reconnect_attempt.get(hid, 0)
+                backoff_seconds = min(5 * (2 ** attempts), 300)
+
+                # Skip reconnection if we're in backoff period
+                if now - last_attempt < backoff_seconds:
+                    time_remaining = backoff_seconds - (now - last_attempt)
+                    logger.debug(f"Skipping reconnection for {host.name} - backoff active (attempt {attempts}, {time_remaining:.1f}s remaining)")
+                    host.status = "offline"
+                    continue
+
+                # Record this reconnection attempt
+                self.last_reconnect_attempt[hid] = now
+                logger.info(f"Attempting to reconnect to offline host {host.name} (attempt {attempts + 1})")
+
+                # Attempt to reconnect offline hosts
+                try:
+                    # Fetch TLS certs from database for reconnection
+                    with self.db.get_session() as session:
+                        db_host = session.query(DockerHostDB).filter_by(id=hid).first()
+
+                    if host.url.startswith("unix://"):
+                        client = docker.DockerClient(base_url=host.url)
+                    elif db_host and db_host.tls_cert and db_host.tls_key and db_host.tls_ca:
+                        # Reconnect with TLS using certs from database
+                        logger.debug(f"Reconnecting to {host.name} with TLS")
+
+                        # Write certs to temporary files for TLS config
+                        cert_dir = os.path.join(CERTS_DIR, hid)
+                        os.makedirs(cert_dir, exist_ok=True)
+
+                        cert_file = os.path.join(cert_dir, 'cert.pem')
+                        key_file = os.path.join(cert_dir, 'key.pem')
+                        ca_file = os.path.join(cert_dir, 'ca.pem') if db_host.tls_ca else None
+
+                        with open(cert_file, 'w') as f:
+                            f.write(db_host.tls_cert)
+                        with open(key_file, 'w') as f:
+                            f.write(db_host.tls_key)
+                        if ca_file:
+                            with open(ca_file, 'w') as f:
+                                f.write(db_host.tls_ca)
+
+                        # Set secure permissions
+                        os.chmod(cert_file, 0o600)
+                        os.chmod(key_file, 0o600)
+                        if ca_file:
+                            os.chmod(ca_file, 0o600)
+
+                        tls_config = docker.tls.TLSConfig(
+                            client_cert=(cert_file, key_file),
+                            ca_cert=ca_file,
+                            verify=bool(db_host.tls_ca)
+                        )
+
+                        client = docker.DockerClient(
+                            base_url=host.url,
+                            tls=tls_config,
+                            timeout=self.settings.connection_timeout
+                        )
+                    else:
+                        # Reconnect without TLS
+                        client = docker.DockerClient(
+                            base_url=host.url,
+                            timeout=self.settings.connection_timeout
+                        )
+
+                    # Test the connection
+                    client.ping()
+                    # Connection successful - add to clients
+                    self.clients[hid] = client
+
+                    # Reset reconnection attempts on success
+                    self.reconnect_attempts[hid] = 0
+                    logger.info(f"Reconnected to offline host: {host.name}")
+
+                    # Re-register with stats and events service
+                    try:
+                        stats_client = get_stats_client()
+                        tls_ca = db_host.tls_ca if db_host else None
+                        tls_cert = db_host.tls_cert if db_host else None
+                        tls_key = db_host.tls_key if db_host else None
+
+                        await stats_client.add_docker_host(hid, host.url, tls_ca, tls_cert, tls_key)
+                        await stats_client.add_event_host(hid, host.url, tls_ca, tls_cert, tls_key)
+                        logger.info(f"Re-registered {host.name} ({hid[:8]}) with stats/events service after reconnection")
+                    except Exception as e:
+                        logger.warning(f"Failed to re-register {host.name} with Go services after reconnection: {e}")
+
+                except Exception as e:
+                    # Increment reconnection attempts on failure
+                    self.reconnect_attempts[hid] = attempts + 1
+
+                    # Still offline - update status and continue
+                    host.status = "offline"
+                    host.error = f"Connection failed: {str(e)}"
+                    host.last_checked = datetime.now()
+
+                    # Log with backoff info to help debugging
+                    next_attempt_in = min(5 * (2 ** (attempts + 1)), 300)
+                    logger.debug(f"Host {host.name} still offline (attempt {attempts + 1}). Next retry in {next_attempt_in}s")
+                    continue
+
+            client = self.clients[hid]
+
+            try:
+                docker_containers = client.containers.list(all=True)
+                host.status = "online"
+                host.container_count = len(docker_containers)
+                host.error = None
+
+                for dc in docker_containers:
+                    try:
+                        container_id = dc.id[:12]
+
+                        # Try to get image info, but handle missing images gracefully
+                        # Access dc.image first to trigger any errors before accessing its properties
+                        try:
+                            container_image = dc.image
+                            image_name = container_image.tags[0] if container_image.tags else container_image.short_id
+                        except Exception as img_error:
+                            # Image may have been deleted - use image ID from container attrs
+                            # This is common when containers reference deleted images
+                            image_name = dc.attrs.get('Config', {}).get('Image', 'unknown')
+                            if image_name == 'unknown':
+                                # Try to get from ImageID in attrs
+                                image_id = dc.attrs.get('Image', '')
+                                if image_id.startswith('sha256:'):
+                                    image_name = image_id[:19]  # sha256: + first 12 chars
+                                else:
+                                    image_name = image_id[:12] if image_id else 'unknown'
+
+                        container = Container(
+                            id=dc.id,
+                            short_id=container_id,
+                            name=dc.name,
+                            state=dc.status,
+                            status=dc.attrs['State']['Status'],
+                            host_id=hid,
+                            host_name=host.name,
+                            image=image_name,
+                            created=dc.attrs['Created'],
+                            auto_restart=self._get_auto_restart_status(hid, container_id),
+                            restart_attempts=self.restart_attempts.get(container_id, 0)
+                        )
+                        containers.append(container)
+                    except Exception as container_error:
+                        # Log but don't fail the whole host for one bad container
+                        logger.warning(f"Skipping container {dc.name if hasattr(dc, 'name') else 'unknown'} on {host.name} due to error: {container_error}")
+                        continue
+
+            except Exception as e:
+                logger.error(f"Error getting containers from {host.name}: {e}")
+                host.status = "offline"
+                host.error = str(e)
+
+            host.last_checked = datetime.now()
+
+        # Fetch stats from Go stats service and populate container stats
+        try:
+            from stats_client import get_stats_client
+            stats_client = get_stats_client()
+            container_stats = await stats_client.get_container_stats()
+
+            # Populate stats for each container using composite key (host_id:container_id)
+            for container in containers:
+                # Use composite key to support containers with duplicate IDs on different hosts
+                composite_key = f"{container.host_id}:{container.id}"
+                stats = container_stats.get(composite_key, {})
+                if stats:
+                    container.cpu_percent = stats.get('cpu_percent')
+                    container.memory_usage = stats.get('memory_usage')
+                    container.memory_limit = stats.get('memory_limit')
+                    container.memory_percent = stats.get('memory_percent')
+                    container.network_rx = stats.get('network_rx')
+                    container.network_tx = stats.get('network_tx')
+                    container.disk_read = stats.get('disk_read')
+                    container.disk_write = stats.get('disk_write')
+                    logger.debug(f"Populated stats for {container.name} ({container.short_id}) on {container.host_name}: CPU {container.cpu_percent}%")
+        except Exception as e:
+            logger.warning(f"Failed to fetch container stats from stats service: {e}")
+
+        return containers
+
+    def restart_container(self, host_id: str, container_id: str) -> bool:
+        """Restart a specific container"""
+        if host_id not in self.clients:
+            raise HTTPException(status_code=404, detail="Host not found")
+
+        host = self.hosts.get(host_id)
+        host_name = host.name if host else 'Unknown Host'
+
+        start_time = time.time()
+        try:
+            client = self.clients[host_id]
+            container = client.containers.get(container_id)
+            container_name = container.name
+
+            container.restart(timeout=10)
+            duration_ms = int((time.time() - start_time) * 1000)
+
+            logger.info(f"Restarted container '{container_name}' on host '{host_name}'")
+
+            # Log the successful restart
+            self.event_logger.log_container_action(
+                action="restart",
+                container_name=container_name,
+                container_id=container_id,
+                host_name=host_name,
+                host_id=host_id,
+                success=True,
+                triggered_by="user",
+                duration_ms=duration_ms
+            )
+            return True
+        except Exception as e:
+            duration_ms = int((time.time() - start_time) * 1000)
+            logger.error(f"Failed to restart container '{container_name}' on host '{host_name}': {e}")
+
+            # Log the failed restart
+            self.event_logger.log_container_action(
+                action="restart",
+                container_name=container_id,  # Use ID if name unavailable
+                container_id=container_id,
+                host_name=host_name,
+                host_id=host_id,
+                success=False,
+                triggered_by="user",
+                error_message=str(e),
+                duration_ms=duration_ms
+            )
+            raise HTTPException(status_code=500, detail=str(e))
+
+    def stop_container(self, host_id: str, container_id: str) -> bool:
+        """Stop a specific container"""
+        if host_id not in self.clients:
+            raise HTTPException(status_code=404, detail="Host not found")
+
+        host = self.hosts.get(host_id)
+        host_name = host.name if host else 'Unknown Host'
+
+        start_time = time.time()
+        try:
+            client = self.clients[host_id]
+            container = client.containers.get(container_id)
+            container_name = container.name
+
+            container.stop(timeout=10)
+            duration_ms = int((time.time() - start_time) * 1000)
+
+            logger.info(f"Stopped container '{container_name}' on host '{host_name}'")
+
+            # Track this user action to suppress critical severity on expected state change
+            container_key = f"{host_id}:{container_id}"
+            self._recent_user_actions[container_key] = time.time()
+            logger.info(f"Tracked user stop action for {container_key}")
+
+            # Log the successful stop
+            self.event_logger.log_container_action(
+                action="stop",
+                container_name=container_name,
+                container_id=container_id,
+                host_name=host_name,
+                host_id=host_id,
+                success=True,
+                triggered_by="user",
+                duration_ms=duration_ms
+            )
+            return True
+        except Exception as e:
+            duration_ms = int((time.time() - start_time) * 1000)
+            logger.error(f"Failed to stop container '{container_name}' on host '{host_name}': {e}")
+
+            # Log the failed stop
+            self.event_logger.log_container_action(
+                action="stop",
+                container_name=container_id,
+                container_id=container_id,
+                host_name=host_name,
+                host_id=host_id,
+                success=False,
+                triggered_by="user",
+                error_message=str(e),
+                duration_ms=duration_ms
+            )
+            raise HTTPException(status_code=500, detail=str(e))
+
+    def start_container(self, host_id: str, container_id: str) -> bool:
+        """Start a specific container"""
+        if host_id not in self.clients:
+            raise HTTPException(status_code=404, detail="Host not found")
+
+        host = self.hosts.get(host_id)
+        host_name = host.name if host else 'Unknown Host'
+
+        start_time = time.time()
+        try:
+            client = self.clients[host_id]
+            container = client.containers.get(container_id)
+            container_name = container.name
+
+            container.start()
+            duration_ms = int((time.time() - start_time) * 1000)
+
+            logger.info(f"Started container '{container_name}' on host '{host_name}'")
+
+            # Track this user action to suppress critical severity on expected state change
+            container_key = f"{host_id}:{container_id}"
+            self._recent_user_actions[container_key] = time.time()
+            logger.info(f"Tracked user start action for {container_key}")
+
+            # Log the successful start
+            self.event_logger.log_container_action(
+                action="start",
+                container_name=container_name,
+                container_id=container_id,
+                host_name=host_name,
+                host_id=host_id,
+                success=True,
+                triggered_by="user",
+                duration_ms=duration_ms
+            )
+            return True
+        except Exception as e:
+            duration_ms = int((time.time() - start_time) * 1000)
+            logger.error(f"Failed to start container '{container_name}' on host '{host_name}': {e}")
+
+            # Log the failed start
+            self.event_logger.log_container_action(
+                action="start",
+                container_name=container_id,
+                container_id=container_id,
+                host_name=host_name,
+                host_id=host_id,
+                success=False,
+                triggered_by="user",
+                error_message=str(e),
+                duration_ms=duration_ms
+            )
+            raise HTTPException(status_code=500, detail=str(e))
+
+    def toggle_auto_restart(self, host_id: str, container_id: str, container_name: str, enabled: bool):
+        """Toggle auto-restart for a container"""
+        # Get host name for logging
+        host = self.hosts.get(host_id)
+        host_name = host.name if host else 'Unknown Host'
+
+        # Use host_id:container_id as key to prevent collisions between hosts
+        container_key = f"{host_id}:{container_id}"
+        self.auto_restart_status[container_key] = enabled
+        if not enabled:
+            self.restart_attempts[container_key] = 0
+            self.restarting_containers[container_key] = False
+        # Save to database
+        self.db.set_auto_restart(host_id, container_id, container_name, enabled)
+        logger.info(f"Auto-restart {'enabled' if enabled else 'disabled'} for container '{container_name}' on host '{host_name}'")
+
+    async def check_orphaned_alerts(self):
+        """Check for alert rules that reference non-existent containers
+        Returns dict mapping alert_rule_id to list of orphaned container entries"""
+        orphaned = {}
+
+        try:
+            # Get all alert rules
+            with self.db.get_session() as session:
+                from database import AlertRuleDB, AlertRuleContainer
+                alert_rules = session.query(AlertRuleDB).all()
+
+                # Get all current containers (name + host_id pairs)
+                current_containers = {}
+                for container in await self.get_containers():
+                    key = f"{container.host_id}:{container.name}"
+                    current_containers[key] = True
+
+                # Check each alert rule's containers
+                for rule in alert_rules:
+                    orphaned_containers = []
+                    for alert_container in rule.containers:
+                        key = f"{alert_container.host_id}:{alert_container.container_name}"
+                        if key not in current_containers:
+                            # Container doesn't exist anymore
+                            orphaned_containers.append({
+                                'host_id': alert_container.host_id,
+                                'host_name': alert_container.host.name if alert_container.host else 'Unknown',
+                                'container_name': alert_container.container_name
+                            })
+
+                    if orphaned_containers:
+                        orphaned[rule.id] = {
+                            'rule_name': rule.name,
+                            'orphaned_containers': orphaned_containers
+                        }
+
+                if orphaned:
+                    logger.info(f"Found {len(orphaned)} alert rules with orphaned containers")
+
+                return orphaned
+
+        except Exception as e:
+            logger.error(f"Error checking orphaned alerts: {e}")
+            return {}
+
+    async def _handle_docker_event(self, event: dict):
+        """Handle Docker events from Go service"""
+        try:
+            action = event.get('action', '')
+            container_id = event.get('container_id', '')
+            container_name = event.get('container_name', '')
+            host_id = event.get('host_id', '')
+            attributes = event.get('attributes', {})
+            timestamp_str = event.get('timestamp', '')
+
+            # Filter out noisy exec_* events (health checks, etc.)
+            if action.startswith('exec_'):
+                return
+
+            # Only log important events
+            important_events = ['create', 'start', 'stop', 'die', 'kill', 'destroy', 'pause', 'unpause', 'restart', 'oom', 'health_status']
+            if action in important_events:
+                logger.info(f"Docker event: {action} - {container_name} ({container_id[:12]}) on host {host_id[:8]}")
+
+            # Process event for notifications/alerts
+            if self.notification_service and action in ['die', 'oom', 'kill', 'health_status', 'restart']:
+                # Parse timestamp
+                from datetime import datetime
+                try:
+                    timestamp = datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
+                except (ValueError, AttributeError, TypeError) as e:
+                    logger.warning(f"Failed to parse timestamp '{timestamp_str}': {e}, using current time")
+                    timestamp = datetime.now()
+
+                # Get exit code for die events
+                exit_code = None
+                if action == 'die':
+                    exit_code_str = attributes.get('exitCode', '0')
+                    try:
+                        exit_code = int(exit_code_str)
+                    except (ValueError, TypeError):
+                        exit_code = None
+
+                # Create alert event
+                from notifications import DockerEventAlert
+                alert_event = DockerEventAlert(
+                    container_id=container_id,
+                    container_name=container_name,
+                    host_id=host_id,
+                    event_type=action,
+                    timestamp=timestamp,
+                    attributes=attributes,
+                    exit_code=exit_code
+                )
+
+                # Process in background to not block event monitoring
+                task = asyncio.create_task(self.notification_service.process_docker_event(alert_event))
+                task.add_done_callback(_handle_task_exception)
+
+        except Exception as e:
+            logger.error(f"Error handling Docker event from Go service: {e}")
+
+    async def monitor_containers(self):
+        """Main monitoring loop"""
+        logger.info("Starting container monitoring...")
+
+        # Get stats client instance
+        # Note: streaming_containers is now managed by self.stats_manager
+        stats_client = get_stats_client()
+
+        # Register all hosts with the stats and event services on startup
+        for host_id, host in self.hosts.items():
+            try:
+                # Get TLS certificates from database
+                session = self.db.get_session()
+                try:
+                    db_host = session.query(DockerHostDB).filter_by(id=host_id).first()
+                    tls_ca = db_host.tls_ca if db_host else None
+                    tls_cert = db_host.tls_cert if db_host else None
+                    tls_key = db_host.tls_key if db_host else None
+                finally:
+                    session.close()
+
+                # Register with stats service
+                await stats_client.add_docker_host(host_id, host.url, tls_ca, tls_cert, tls_key)
+                logger.info(f"Registered host {host.name} ({host_id[:8]}) with stats service")
+
+                # Register with event service
+                await stats_client.add_event_host(host_id, host.url, tls_ca, tls_cert, tls_key)
+                logger.info(f"Registered host {host.name} ({host_id[:8]}) with event service")
+            except Exception as e:
+                logger.error(f"Failed to register host {host_id} with services: {e}")
+
+        # Connect to event stream WebSocket
+        try:
+            await stats_client.connect_event_stream(self._handle_docker_event)
+            logger.info("Connected to Go event stream")
+        except Exception as e:
+            logger.error(f"Failed to connect to event stream: {e}")
+
+        while True:
+            try:
+                containers = await self.get_containers()
+
+                # Centralized stats collection decision using StatsManager
+                has_viewers = self.manager.has_active_connections()
+
+                if has_viewers:
+                    # Determine which containers need stats (centralized logic)
+                    containers_needing_stats = self.stats_manager.determine_containers_needing_stats(
+                        containers,
+                        self.settings
+                    )
+
+                    # Sync streams with what's needed (start new, stop old)
+                    await self.stats_manager.sync_container_streams(
+                        containers,
+                        containers_needing_stats,
+                        stats_client,
+                        _handle_task_exception
+                    )
+                else:
+                    # No active viewers - stop all streams
+                    await self.stats_manager.stop_all_streams(stats_client, _handle_task_exception)
+
+                # Track container state changes and log them
+                for container in containers:
+                    container_key = f"{container.host_id}:{container.id}"
+                    current_state = container.status
+
+                    # Hold lock during entire read-process-write to prevent race conditions
+                    async with self._state_lock:
+                        previous_state = self._container_states.get(container_key)
+
+                        # Log state changes
+                        if previous_state is not None and previous_state != current_state:
+                            # Check if this state change was expected (recent user action)
+                            async with self._actions_lock:
+                                last_user_action = self._recent_user_actions.get(container_key, 0)
+                            time_since_action = time.time() - last_user_action
+                            is_user_initiated = time_since_action < 30  # Within 30 seconds
+
+                            logger.info(f"State change for {container_key}: {previous_state} → {current_state}, "
+                                      f"time_since_action={time_since_action:.1f}s, user_initiated={is_user_initiated}")
+
+                            # Clean up old tracking entries (5 minutes or older)
+                            if time_since_action >= 300:
+                                async with self._actions_lock:
+                                    self._recent_user_actions.pop(container_key, None)
+
+                            self.event_logger.log_container_state_change(
+                                container_name=container.name,
+                                container_id=container.short_id,
+                                host_name=container.host_name,
+                                host_id=container.host_id,
+                                old_state=previous_state,
+                                new_state=current_state,
+                                triggered_by="user" if is_user_initiated else "system"
+                            )
+
+                        # Update tracked state (still inside lock)
+                        self._container_states[container_key] = current_state
+
+                # Check for containers that need auto-restart
+                for container in containers:
+                    if (container.status == "exited" and
+                        self._get_auto_restart_status(container.host_id, container.short_id)):
+
+                        # Use host_id:container_id as key to prevent collisions between hosts
+                        container_key = f"{container.host_id}:{container.short_id}"
+                        attempts = self.restart_attempts.get(container_key, 0)
+                        is_restarting = self.restarting_containers.get(container_key, False)
+
+                        if attempts < self.settings.max_retries and not is_restarting:
+                            self.restarting_containers[container_key] = True
+                            task = asyncio.create_task(
+                                self.auto_restart_container(container)
+                            )
+                            task.add_done_callback(_handle_task_exception)
+
+                # Process alerts for container state changes
+                await self.alert_processor.process_container_update(containers, self.hosts)
+
+                # Only fetch and broadcast stats if there are active viewers
+                if has_viewers:
+                    # Prepare broadcast data
+                    broadcast_data = {
+                        "containers": [c.dict() for c in containers],
+                        "hosts": [h.dict() for h in self.hosts.values()],
+                        "timestamp": datetime.now().isoformat()
+                    }
+
+                    # Only include host metrics if host stats are enabled
+                    if self.stats_manager.should_broadcast_host_metrics(self.settings):
+                        # Get host metrics from stats service (fast HTTP call)
+                        host_metrics = await stats_client.get_host_stats()
+                        logger.debug(f"Retrieved metrics for {len(host_metrics)} hosts from stats service")
+                        broadcast_data["host_metrics"] = host_metrics
+
+                    # Broadcast update to all connected clients
+                    await self.manager.broadcast({
+                        "type": "containers_update",
+                        "data": broadcast_data
+                    })
+
+            except Exception as e:
+                logger.error(f"Error in monitoring loop: {e}")
+
+            await asyncio.sleep(self.settings.polling_interval)
+
+    async def auto_restart_container(self, container: Container):
+        """Attempt to auto-restart a container"""
+        container_id = container.short_id
+        # Use host_id:container_id as key to prevent collisions between hosts
+        container_key = f"{container.host_id}:{container_id}"
+
+        self.restart_attempts[container_key] = self.restart_attempts.get(container_key, 0) + 1
+        attempt = self.restart_attempts[container_key]
+
+        correlation_id = self.event_logger.create_correlation_id()
+
+        logger.info(
+            f"Auto-restart attempt {attempt}/{self.settings.max_retries} "
+            f"for container '{container.name}' on host '{container.host_name}'"
+        )
+
+        # Wait before attempting restart
+        await asyncio.sleep(self.settings.retry_delay)
+
+        try:
+            success = self.restart_container(container.host_id, container.id)
+            if success:
+                self.restart_attempts[container_key] = 0
+
+                # Log successful auto-restart
+                self.event_logger.log_auto_restart_attempt(
+                    container_name=container.name,
+                    container_id=container_id,
+                    host_name=container.host_name,
+                    host_id=container.host_id,
+                    attempt=attempt,
+                    max_attempts=self.settings.max_retries,
+                    success=True,
+                    correlation_id=correlation_id
+                )
+
+                await self.manager.broadcast({
+                    "type": "auto_restart_success",
+                    "data": {
+                        "container_id": container_id,
+                        "container_name": container.name,
+                        "host": container.host_name
+                    }
+                })
+        except Exception as e:
+            logger.error(f"Auto-restart failed for {container.name}: {e}")
+
+            # Log failed auto-restart
+            self.event_logger.log_auto_restart_attempt(
+                container_name=container.name,
+                container_id=container_id,
+                host_name=container.host_name,
+                host_id=container.host_id,
+                attempt=attempt,
+                max_attempts=self.settings.max_retries,
+                success=False,
+                error_message=str(e),
+                correlation_id=correlation_id
+            )
+
+            if attempt >= self.settings.max_retries:
+                self.auto_restart_status[container_key] = False
+                await self.manager.broadcast({
+                    "type": "auto_restart_failed",
+                    "data": {
+                        "container_id": container_id,
+                        "container_name": container.name,
+                        "attempts": attempt,
+                        "max_retries": self.settings.max_retries
+                    }
+                })
+        finally:
+            # Always clear the restarting flag when done (success or failure)
+            self.restarting_containers[container_key] = False
+
+    def _load_persistent_config(self):
+        """Load saved configuration from database"""
+        try:
+            # Load saved hosts
+            db_hosts = self.db.get_hosts(active_only=True)
+
+            # Detect and warn about duplicate hosts (same URL)
+            seen_urls = {}
+            for host in db_hosts:
+                if host.url in seen_urls:
+                    logger.warning(
+                        f"Duplicate host detected: '{host.name}' ({host.id}) and "
+                        f"'{seen_urls[host.url]['name']}' ({seen_urls[host.url]['id']}) "
+                        f"both use URL '{host.url}'. Consider removing duplicates."
+                    )
+                else:
+                    seen_urls[host.url] = {'name': host.name, 'id': host.id}
+
+            # Check if this is first run
+            with self.db.get_session() as session:
+                settings = session.query(GlobalSettings).first()
+                if not settings:
+                    # Create default settings
+                    settings = GlobalSettings()
+                    session.add(settings)
+                    session.commit()
+
+            # Auto-add local Docker only on first run (outside session context)
+            with self.db.get_session() as session:
+                settings = session.query(GlobalSettings).first()
+                if settings and not settings.first_run_complete and not db_hosts and os.path.exists('/var/run/docker.sock'):
+                    logger.info("First run detected - adding local Docker automatically")
+                    host_added = False
+                    try:
+                        config = DockerHostConfig(
+                            name="Local Docker",
+                            url="unix:///var/run/docker.sock",
+                            tls_cert=None,
+                            tls_key=None,
+                            tls_ca=None
+                        )
+                        self.add_host(config, suppress_event_loop_errors=True)
+                        host_added = True
+                        logger.info("Successfully added local Docker host")
+                    except Exception as e:
+                        # Check if this is the benign "no running event loop" error during startup
+                        # The host is actually added successfully despite this error
+                        error_str = str(e)
+                        if "no running event loop" in error_str:
+                            host_added = True
+                            logger.debug(f"Event loop warning during first run (host added successfully): {e}")
+                        else:
+                            logger.error(f"Failed to add local Docker: {e}")
+                            session.rollback()
+
+                    # Mark first run as complete if host was added
+                    if host_added:
+                        settings.first_run_complete = True
+                        session.commit()
+                        logger.info("First run setup complete")
+
+            for db_host in db_hosts:
+                try:
+                    config = DockerHostConfig(
+                        name=db_host.name,
+                        url=db_host.url,
+                        tls_cert=db_host.tls_cert,
+                        tls_key=db_host.tls_key,
+                        tls_ca=db_host.tls_ca
+                    )
+                    # Try to connect to the host with existing ID and preserve security status
+                    host = self.add_host(config, existing_id=db_host.id, skip_db_save=True, suppress_event_loop_errors=True)
+                    # Override with stored security status
+                    if hasattr(host, 'security_status') and db_host.security_status:
+                        host.security_status = db_host.security_status
+                except Exception as e:
+                    # Suppress event loop errors during startup
+                    error_str = str(e)
+                    if "no running event loop" not in error_str:
+                        logger.error(f"Failed to reconnect to saved host {db_host.name}: {e}")
+                    # Add host to UI even if connection failed, mark as offline
+                    # This prevents "disappearing hosts" bug after restart
+                    host = DockerHost(
+                        id=db_host.id,
+                        name=db_host.name,
+                        url=db_host.url,
+                        status="offline",
+                        client=None
+                    )
+                    host.security_status = db_host.security_status or "unknown"
+                    self.hosts[db_host.id] = host
+                    logger.info(f"Added host {db_host.name} in offline mode - connection will retry")
+
+            # Load auto-restart configurations
+            for host_id in self.hosts:
+                configs = self.db.get_session().query(AutoRestartConfig).filter(
+                    AutoRestartConfig.host_id == host_id,
+                    AutoRestartConfig.enabled == True
+                ).all()
+                for config in configs:
+                    # Use host_id:container_id as key to prevent collisions between hosts
+                    container_key = f"{config.host_id}:{config.container_id}"
+                    self.auto_restart_status[container_key] = True
+                    self.restart_attempts[container_key] = config.restart_count
+
+            logger.info(f"Loaded {len(self.hosts)} hosts from database")
+        except Exception as e:
+            logger.error(f"Error loading persistent config: {e}")
+
+    def _get_auto_restart_status(self, host_id: str, container_id: str) -> bool:
+        """Get auto-restart status for a container"""
+        # Use host_id:container_id as key to prevent collisions between hosts
+        container_key = f"{host_id}:{container_id}"
+
+        # Check in-memory cache first
+        if container_key in self.auto_restart_status:
+            return self.auto_restart_status[container_key]
+
+        # Check database
+        config = self.db.get_auto_restart_config(host_id, container_id)
+        if config:
+            self.auto_restart_status[container_key] = config.enabled
+            return config.enabled
+
+        return False
+
+    async def cleanup_old_data(self):
+        """Periodic cleanup of old data"""
+        logger.info("Starting periodic data cleanup...")
+
+        while True:
+            try:
+                settings = self.db.get_settings()
+
+                if settings.auto_cleanup_events:
+                    # Clean up old events
+                    event_deleted = self.db.cleanup_old_events(settings.event_retention_days)
+                    if event_deleted > 0:
+                        self.event_logger.log_system_event(
+                            "Automatic Event Cleanup",
+                            f"Cleaned up {event_deleted} events older than {settings.event_retention_days} days",
+                            EventSeverity.INFO,
+                            EventType.STARTUP
+                        )
+
+                # Clean up expired sessions (runs daily regardless of event cleanup setting)
+                expired_count = session_manager.cleanup_expired_sessions()
+                if expired_count > 0:
+                    logger.info(f"Cleaned up {expired_count} expired sessions")
+
+                # Sleep for 24 hours before next cleanup
+                await asyncio.sleep(24 * 60 * 60)  # 24 hours
+
+            except Exception as e:
+                logger.error(f"Error in cleanup task: {e}")
+                # Wait 1 hour before retrying
+                await asyncio.sleep(60 * 60)  # 1 hour
\ No newline at end of file
diff --git a/dockmon/backend/docker_monitor/stats_manager.py b/dockmon/backend/docker_monitor/stats_manager.py
new file mode 100644
index 0000000..bb0855f
--- /dev/null
+++ b/dockmon/backend/docker_monitor/stats_manager.py
@@ -0,0 +1,170 @@
+"""
+Stats Collection Manager for DockMon
+Centralized logic for determining which containers need stats collection
+"""
+
+import asyncio
+import logging
+from typing import Set, List
+from models.docker_models import Container
+from database import GlobalSettings
+
+logger = logging.getLogger(__name__)
+
+
+class StatsManager:
+    """Manages stats collection decisions based on settings and modal state"""
+
+    def __init__(self):
+        """Initialize stats manager"""
+        self.streaming_containers: Set[str] = set()  # Currently streaming container keys (host_id:container_id)
+        self.modal_containers: Set[str] = set()  # Composite keys (host_id:container_id) with open modals
+        self._streaming_lock = asyncio.Lock()  # Protect streaming_containers set from race conditions
+
+    def add_modal_container(self, container_id: str, host_id: str) -> None:
+        """Track that a container modal is open"""
+        composite_key = f"{host_id}:{container_id}"
+        self.modal_containers.add(composite_key)
+        logger.debug(f"Container modal opened for {container_id[:12]} on host {host_id[:8]} - stats tracking enabled")
+
+    def remove_modal_container(self, container_id: str, host_id: str) -> None:
+        """Remove container from modal tracking"""
+        composite_key = f"{host_id}:{container_id}"
+        self.modal_containers.discard(composite_key)
+        logger.debug(f"Container modal closed for {container_id[:12]} on host {host_id[:8]}")
+
+    def clear_modal_containers(self) -> None:
+        """Clear all modal containers (e.g., on WebSocket disconnect)"""
+        if self.modal_containers:
+            logger.debug(f"Clearing {len(self.modal_containers)} modal containers")
+        self.modal_containers.clear()
+
+    def determine_containers_needing_stats(
+        self,
+        containers: List[Container],
+        settings: GlobalSettings
+    ) -> Set[str]:
+        """
+        Centralized decision: determine which containers need stats collection
+
+        Rules:
+        1. If show_container_stats OR show_host_stats is ON → collect ALL running containers
+           (host stats are aggregated from container stats)
+        2. Always collect stats for containers with open modals
+
+        Args:
+            containers: List of all containers
+            settings: Global settings with show_container_stats and show_host_stats flags
+
+        Returns:
+            Set of composite keys (host_id:container_id) that need stats collection
+        """
+        containers_needing_stats = set()
+
+        # Rule 1: Container stats OR host stats enabled = ALL running containers
+        # (host stats need container data for aggregation)
+        if settings.show_container_stats or settings.show_host_stats:
+            for container in containers:
+                if container.status == 'running':
+                    containers_needing_stats.add(f"{container.host_id}:{container.id}")
+
+        # Rule 2: Always add modal containers (even if settings are off)
+        # Modal containers are already stored as composite keys
+        for modal_composite_key in self.modal_containers:
+            # Verify container is still running before adding
+            for container in containers:
+                container_key = f"{container.host_id}:{container.id}"
+                if container_key == modal_composite_key and container.status == 'running':
+                    containers_needing_stats.add(container_key)
+                    break
+
+        return containers_needing_stats
+
+    async def sync_container_streams(
+        self,
+        containers: List[Container],
+        containers_needing_stats: Set[str],
+        stats_client,
+        error_callback
+    ) -> None:
+        """
+        Synchronize container stats streams with what's needed
+
+        Starts streams for containers that need stats but aren't streaming yet
+        Stops streams for containers that no longer need stats
+
+        Args:
+            containers: List of all containers
+            containers_needing_stats: Set of composite keys (host_id:container_id) that need stats
+            stats_client: Stats client instance
+            error_callback: Callback for handling async task errors
+        """
+        async with self._streaming_lock:
+            # Start streams for containers that need stats but aren't streaming yet
+            for container in containers:
+                container_key = f"{container.host_id}:{container.id}"
+                if container_key in containers_needing_stats and container_key not in self.streaming_containers:
+                    task = asyncio.create_task(
+                        stats_client.start_container_stream(
+                            container.id,
+                            container.name,
+                            container.host_id
+                        )
+                    )
+                    task.add_done_callback(error_callback)
+                    self.streaming_containers.add(container_key)
+                    logger.debug(f"Started stats stream for {container.name} on {container.host_name}")
+
+            # Stop streams for containers that no longer need stats
+            containers_to_stop = self.streaming_containers - containers_needing_stats
+
+            for container_key in containers_to_stop:
+                # Extract host_id and container_id from the key (format: host_id:container_id)
+                try:
+                    host_id, container_id = container_key.split(':', 1)
+                except ValueError:
+                    logger.error(f"Invalid container key format: {container_key}")
+                    self.streaming_containers.discard(container_key)
+                    continue
+
+                task = asyncio.create_task(stats_client.stop_container_stream(container_id, host_id))
+                task.add_done_callback(error_callback)
+                self.streaming_containers.discard(container_key)
+                logger.debug(f"Stopped stats stream for container {container_id[:12]}")
+
+    async def stop_all_streams(self, stats_client, error_callback) -> None:
+        """
+        Stop all active stats streams
+
+        Used when there are no active viewers
+
+        Args:
+            stats_client: Stats client instance
+            error_callback: Callback for handling async task errors
+        """
+        async with self._streaming_lock:
+            if self.streaming_containers:
+                logger.info(f"Stopping {len(self.streaming_containers)} stats streams")
+                for container_key in list(self.streaming_containers):
+                    # Extract host_id and container_id from the key (format: host_id:container_id)
+                    try:
+                        host_id, container_id = container_key.split(':', 1)
+                    except ValueError:
+                        logger.error(f"Invalid container key format during cleanup: {container_key}")
+                        continue
+
+                    task = asyncio.create_task(stats_client.stop_container_stream(container_id, host_id))
+                    task.add_done_callback(error_callback)
+                self.streaming_containers.clear()
+
+    def should_broadcast_host_metrics(self, settings: GlobalSettings) -> bool:
+        """Determine if host metrics should be included in broadcast"""
+        return settings.show_host_stats
+
+    def get_stats_summary(self) -> dict:
+        """Get current stats collection summary for debugging"""
+        return {
+            "streaming_containers": len(self.streaming_containers),
+            "modal_containers": len(self.modal_containers),
+            "modal_container_ids": list(self.modal_containers)
+        }
diff --git a/dockmon/backend/event_logger.py b/dockmon/backend/event_logger.py
new file mode 100644
index 0000000..890abb3
--- /dev/null
+++ b/dockmon/backend/event_logger.py
@@ -0,0 +1,606 @@
+"""
+Comprehensive event logging service for DockMon
+Provides structured logging for all system activities
+"""
+
+import asyncio
+import logging
+import time
+import uuid
+from datetime import datetime, timezone
+from typing import Dict, List, Optional, Any, Union
+from enum import Enum
+from dataclasses import dataclass
+from database import DatabaseManager, EventLog
+
+logger = logging.getLogger(__name__)
+
+class EventCategory(str, Enum):
+    """Event categories"""
+    CONTAINER = "container"
+    HOST = "host"
+    SYSTEM = "system"
+    ALERT = "alert"
+    NOTIFICATION = "notification"
+    USER = "user"
+
+class EventType(str, Enum):
+    """Event types"""
+    # Container events
+    STATE_CHANGE = "state_change"
+    ACTION_TAKEN = "action_taken"
+    AUTO_RESTART = "auto_restart"
+
+    # Host events
+    CONNECTION = "connection"
+    DISCONNECTION = "disconnection"
+    HOST_ADDED = "host_added"
+    HOST_REMOVED = "host_removed"
+
+    # System events
+    STARTUP = "startup"
+    SHUTDOWN = "shutdown"
+    ERROR = "error"
+    PERFORMANCE = "performance"
+
+    # Alert events
+    RULE_TRIGGERED = "rule_triggered"
+    RULE_CREATED = "rule_created"
+    RULE_DELETED = "rule_deleted"
+
+    # Notification events
+    SENT = "sent"
+    FAILED = "failed"
+    CHANNEL_CREATED = "channel_created"
+    CHANNEL_TESTED = "channel_tested"
+
+    # User events
+    LOGIN = "login"
+    LOGOUT = "logout"
+    CONFIG_CHANGED = "config_changed"
+
+class EventSeverity(str, Enum):
+    """Event severity levels"""
+    DEBUG = "debug"
+    INFO = "info"
+    WARNING = "warning"
+    ERROR = "error"
+    CRITICAL = "critical"
+
+@dataclass
+class EventContext:
+    """Context information for events"""
+    correlation_id: Optional[str] = None
+    host_id: Optional[str] = None
+    host_name: Optional[str] = None
+    container_id: Optional[str] = None
+    container_name: Optional[str] = None
+    user_id: Optional[str] = None
+    user_name: Optional[str] = None
+
+class EventLogger:
+    """Comprehensive event logging service"""
+
+    def __init__(self, db: DatabaseManager, websocket_manager=None):
+        self.db = db
+        self.websocket_manager = websocket_manager
+        self._event_queue = asyncio.Queue(maxsize=10000)  # Prevent unbounded memory growth
+        self._processing_task: Optional[asyncio.Task] = None
+        self._active_correlations: Dict[str, List[str]] = {}
+        self._dropped_events_count = 0  # Track dropped events for monitoring
+
+    async def start(self):
+        """Start the event processing task"""
+        if not self._processing_task:
+            self._processing_task = asyncio.create_task(self._process_events())
+            logger.info("Event logger started")
+
+    async def stop(self):
+        """Stop the event processing task"""
+        if self._processing_task:
+            self._processing_task.cancel()
+            try:
+                await self._processing_task
+            except asyncio.CancelledError:
+                pass
+
+            # Drain the queue to prevent memory leak
+            while not self._event_queue.empty():
+                try:
+                    self._event_queue.get_nowait()
+                    self._event_queue.task_done()
+                except Exception:
+                    break
+
+            logger.info("Event logger stopped")
+
+    def log_event(self,
+                  category: EventCategory,
+                  event_type: EventType,
+                  title: str,
+                  severity: EventSeverity = EventSeverity.INFO,
+                  message: Optional[str] = None,
+                  context: Optional[EventContext] = None,
+                  old_state: Optional[str] = None,
+                  new_state: Optional[str] = None,
+                  triggered_by: Optional[str] = None,
+                  details: Optional[Dict[str, Any]] = None,
+                  duration_ms: Optional[int] = None):
+        """Log an event asynchronously"""
+
+        if context is None:
+            context = EventContext()
+
+        event_data = {
+            'correlation_id': context.correlation_id,
+            'category': category.value,
+            'event_type': event_type.value,
+            'severity': severity.value,
+            'host_id': context.host_id,
+            'host_name': context.host_name,
+            'container_id': context.container_id,
+            'container_name': context.container_name,
+            'title': title,
+            'message': message,
+            'old_state': old_state,
+            'new_state': new_state,
+            'triggered_by': triggered_by,
+            'details': details or {},
+            'duration_ms': duration_ms,
+            'timestamp': datetime.now(timezone.utc)
+        }
+
+        # Add to queue for async processing
+        try:
+            self._event_queue.put_nowait(event_data)
+        except asyncio.QueueFull:
+            self._dropped_events_count += 1
+            # Log more prominently for critical events
+            if severity in [EventSeverity.CRITICAL, EventSeverity.ERROR]:
+                logger.error(f"Event queue FULL! Dropped {severity.value} event: {title} (total dropped: {self._dropped_events_count})")
+            else:
+                # Periodic warning to avoid log spam
+                if self._dropped_events_count % 100 == 1:
+                    logger.warning(f"Event queue full, dropped {self._dropped_events_count} events total")
+
+        # Also log to Python logger for immediate visibility
+        python_logger_level = {
+            EventSeverity.DEBUG: logging.DEBUG,
+            EventSeverity.INFO: logging.INFO,
+            EventSeverity.WARNING: logging.WARNING,
+            EventSeverity.ERROR: logging.ERROR,
+            EventSeverity.CRITICAL: logging.CRITICAL
+        }[severity]
+
+        logger.log(python_logger_level, f"[{category.value.upper()}] {title}: {message or ''}")
+
+    def create_correlation_id(self) -> str:
+        """Create a new correlation ID for linking related events"""
+        correlation_id = str(uuid.uuid4())
+        self._active_correlations[correlation_id] = []
+        return correlation_id
+
+    def end_correlation(self, correlation_id: str):
+        """End a correlation session"""
+        if correlation_id in self._active_correlations:
+            del self._active_correlations[correlation_id]
+
+    async def _process_events(self):
+        """Process events from the queue"""
+        while True:
+            try:
+                event_data = await self._event_queue.get()
+                # Save to database
+                event_obj = self.db.add_event(event_data)
+
+                # Broadcast to WebSocket clients
+                if self.websocket_manager and event_obj:
+                    try:
+                        await self.websocket_manager.broadcast({
+                            'type': 'new_event',
+                            'event': {
+                                'id': event_obj.id,
+                                'correlation_id': event_obj.correlation_id,
+                                'category': event_obj.category,
+                                'event_type': event_obj.event_type,
+                                'severity': event_obj.severity,
+                                'host_id': event_obj.host_id,
+                                'host_name': event_obj.host_name,
+                                'container_id': event_obj.container_id,
+                                'container_name': event_obj.container_name,
+                                'title': event_obj.title,
+                                'message': event_obj.message,
+                                'old_state': event_obj.old_state,
+                                'new_state': event_obj.new_state,
+                                'triggered_by': event_obj.triggered_by,
+                                'details': event_obj.details,
+                                'duration_ms': event_obj.duration_ms,
+                                'timestamp': event_obj.timestamp.isoformat()
+                            }
+                        })
+                    except Exception as ws_error:
+                        logger.debug(f"WebSocket broadcast failed (non-critical): {ws_error}")
+
+                self._event_queue.task_done()
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"Error processing event: {e}")
+
+    # Convenience methods for common event types
+
+    def log_container_state_change(self,
+                                 container_name: str,
+                                 container_id: str,
+                                 host_name: str,
+                                 host_id: str,
+                                 old_state: str,
+                                 new_state: str,
+                                 triggered_by: str = "system",
+                                 correlation_id: Optional[str] = None):
+        """Log container state change"""
+        # Match severity with alert rule definitions
+        if triggered_by == "user":
+            # User-initiated changes are WARNING (intentional but noteworthy)
+            # except for starting containers which is INFO
+            if new_state in ['running', 'restarting']:
+                severity = EventSeverity.INFO
+            else:
+                severity = EventSeverity.WARNING
+        elif new_state in ['exited', 'dead']:
+            severity = EventSeverity.CRITICAL  # Unexpected crash
+        elif new_state in ['stopped', 'paused']:
+            severity = EventSeverity.WARNING  # Stopped but not crashed
+        else:
+            severity = EventSeverity.INFO
+
+        context = EventContext(
+            correlation_id=correlation_id,
+            host_id=host_id,
+            host_name=host_name,
+            container_id=container_id,
+            container_name=container_name
+        )
+
+        # Add context to message if user-initiated
+        if triggered_by == "user":
+            title = f"Container {container_name} state changed (user action)"
+            message = f"Container '{container_name}' on host '{host_name}' state changed from {old_state} to {new_state} (user action)"
+        else:
+            title = f"Container {container_name} state changed"
+            message = f"Container '{container_name}' on host '{host_name}' state changed from {old_state} to {new_state}"
+
+        self.log_event(
+            category=EventCategory.CONTAINER,
+            event_type=EventType.STATE_CHANGE,
+            title=title,
+            severity=severity,
+            message=message,
+            context=context,
+            old_state=old_state,
+            new_state=new_state,
+            triggered_by=triggered_by
+        )
+
+    def log_container_action(self,
+                           action: str,
+                           container_name: str,
+                           container_id: str,
+                           host_name: str,
+                           host_id: str,
+                           success: bool,
+                           triggered_by: str = "user",
+                           error_message: Optional[str] = None,
+                           duration_ms: Optional[int] = None,
+                           correlation_id: Optional[str] = None):
+        """Log container action (start, stop, restart, etc.)"""
+        severity = EventSeverity.ERROR if not success else EventSeverity.INFO
+        title = f"Container {action} {'succeeded' if success else 'failed'}"
+        message = f"Container '{container_name}' on host '{host_name}' {action} {'completed successfully' if success else 'failed'}"
+
+        if error_message:
+            message += f": {error_message}"
+
+        context = EventContext(
+            correlation_id=correlation_id,
+            host_id=host_id,
+            host_name=host_name,
+            container_id=container_id,
+            container_name=container_name
+        )
+
+        self.log_event(
+            category=EventCategory.CONTAINER,
+            event_type=EventType.ACTION_TAKEN,
+            title=title,
+            severity=severity,
+            message=message,
+            context=context,
+            triggered_by=triggered_by,
+            duration_ms=duration_ms,
+            details={'action': action, 'success': success, 'error': error_message}
+        )
+
+    def log_auto_restart_attempt(self,
+                                container_name: str,
+                                container_id: str,
+                                host_name: str,
+                                host_id: str,
+                                attempt: int,
+                                max_attempts: int,
+                                success: bool,
+                                error_message: Optional[str] = None,
+                                correlation_id: Optional[str] = None):
+        """Log auto-restart attempt"""
+        severity = EventSeverity.ERROR if not success else EventSeverity.INFO
+        title = f"Auto-restart attempt {attempt}/{max_attempts}"
+        message = f"Auto-restart attempt {attempt} of {max_attempts} for container '{container_name}' on host '{host_name}' {'succeeded' if success else 'failed'}"
+
+        if error_message:
+            message += f": {error_message}"
+
+        context = EventContext(
+            correlation_id=correlation_id,
+            host_id=host_id,
+            host_name=host_name,
+            container_id=container_id,
+            container_name=container_name
+        )
+
+        self.log_event(
+            category=EventCategory.CONTAINER,
+            event_type=EventType.AUTO_RESTART,
+            title=title,
+            severity=severity,
+            message=message,
+            context=context,
+            triggered_by="auto_restart",
+            details={'attempt': attempt, 'max_attempts': max_attempts, 'success': success, 'error': error_message}
+        )
+
+    def log_host_connection(self,
+                          host_name: str,
+                          host_id: str,
+                          host_url: str,
+                          connected: bool,
+                          error_message: Optional[str] = None):
+        """Log host connection/disconnection"""
+        severity = EventSeverity.WARNING if not connected else EventSeverity.INFO
+        event_type = EventType.CONNECTION if connected else EventType.DISCONNECTION
+        title = f"Host {host_name} {'connected' if connected else 'disconnected'}"
+        message = f"Docker host {host_name} ({host_url}) {'connected successfully' if connected else 'disconnected'}"
+
+        if error_message:
+            message += f": {error_message}"
+
+        context = EventContext(
+            host_id=host_id,
+            host_name=host_name
+        )
+
+        self.log_event(
+            category=EventCategory.HOST,
+            event_type=event_type,
+            title=title,
+            severity=severity,
+            message=message,
+            context=context,
+            details={'url': host_url, 'connected': connected, 'error': error_message}
+        )
+
+    def log_alert_triggered(self,
+                          rule_name: str,
+                          rule_id: str,
+                          container_name: str,
+                          container_id: str,
+                          host_name: str,
+                          host_id: str,
+                          old_state: str,
+                          new_state: str,
+                          channels_notified: int,
+                          total_channels: int,
+                          correlation_id: Optional[str] = None):
+        """Log alert rule trigger"""
+        severity = EventSeverity.WARNING if new_state in ['exited', 'dead'] else EventSeverity.INFO
+        title = f"Alert rule '{rule_name}' triggered"
+        message = f"Alert rule triggered for {container_name} state change ({old_state} → {new_state}). Notified {channels_notified}/{total_channels} channels."
+
+        context = EventContext(
+            correlation_id=correlation_id,
+            host_id=host_id,
+            host_name=host_name,
+            container_id=container_id,
+            container_name=container_name
+        )
+
+        self.log_event(
+            category=EventCategory.ALERT,
+            event_type=EventType.RULE_TRIGGERED,
+            title=title,
+            severity=severity,
+            message=message,
+            context=context,
+            old_state=old_state,
+            new_state=new_state,
+            details={'rule_id': rule_id, 'channels_notified': channels_notified, 'total_channels': total_channels}
+        )
+
+    def log_notification_sent(self,
+                            channel_name: str,
+                            channel_type: str,
+                            success: bool,
+                            container_name: str,
+                            error_message: Optional[str] = None,
+                            correlation_id: Optional[str] = None):
+        """Log notification attempt"""
+        severity = EventSeverity.ERROR if not success else EventSeverity.INFO
+        title = f"Notification {'sent' if success else 'failed'} via {channel_name}"
+        message = f"Notification via {channel_name} ({channel_type}) {'sent successfully' if success else 'failed'}"
+
+        if error_message:
+            message += f": {error_message}"
+
+        context = EventContext(
+            correlation_id=correlation_id,
+            container_name=container_name
+        )
+
+        self.log_event(
+            category=EventCategory.NOTIFICATION,
+            event_type=EventType.SENT if success else EventType.FAILED,
+            title=title,
+            severity=severity,
+            message=message,
+            context=context,
+            details={'channel_name': channel_name, 'channel_type': channel_type, 'success': success, 'error': error_message}
+        )
+
+    def log_host_added(self,
+                      host_name: str,
+                      host_id: str,
+                      host_url: str,
+                      triggered_by: str = "user"):
+        """Log host addition"""
+        context = EventContext(
+            host_id=host_id,
+            host_name=host_name
+        )
+
+        self.log_event(
+            category=EventCategory.HOST,
+            event_type=EventType.HOST_ADDED,
+            title=f"Host {host_name} added",
+            severity=EventSeverity.INFO,
+            message=f"Docker host '{host_name}' ({host_url}) was added to monitoring",
+            context=context,
+            triggered_by=triggered_by,
+            details={'url': host_url}
+        )
+
+    def log_host_removed(self,
+                        host_name: str,
+                        host_id: str,
+                        triggered_by: str = "user"):
+        """Log host removal"""
+        context = EventContext(
+            host_id=host_id,
+            host_name=host_name
+        )
+
+        self.log_event(
+            category=EventCategory.HOST,
+            event_type=EventType.HOST_REMOVED,
+            title=f"Host {host_name} removed",
+            severity=EventSeverity.INFO,
+            message=f"Docker host '{host_name}' was removed from monitoring",
+            context=context,
+            triggered_by=triggered_by
+        )
+
+    def log_alert_rule_created(self,
+                              rule_name: str,
+                              rule_id: str,
+                              container_count: int,
+                              channels: List[str],
+                              triggered_by: str = "user"):
+        """Log alert rule creation"""
+        self.log_event(
+            category=EventCategory.ALERT,
+            event_type=EventType.RULE_CREATED,
+            title=f"Alert rule '{rule_name}' created",
+            severity=EventSeverity.INFO,
+            message=f"New alert rule '{rule_name}' created with {container_count} container(s) and {len(channels)} notification channel(s)",
+            triggered_by=triggered_by,
+            details={'rule_id': rule_id, 'container_count': container_count, 'channels': channels}
+        )
+
+    def log_alert_rule_deleted(self,
+                              rule_name: str,
+                              rule_id: str,
+                              triggered_by: str = "user"):
+        """Log alert rule deletion"""
+        self.log_event(
+            category=EventCategory.ALERT,
+            event_type=EventType.RULE_DELETED,
+            title=f"Alert rule '{rule_name}' deleted",
+            severity=EventSeverity.INFO,
+            message=f"Alert rule '{rule_name}' was deleted",
+            triggered_by=triggered_by,
+            details={'rule_id': rule_id}
+        )
+
+    def log_notification_channel_created(self,
+                                        channel_name: str,
+                                        channel_type: str,
+                                        triggered_by: str = "user"):
+        """Log notification channel creation"""
+        self.log_event(
+            category=EventCategory.NOTIFICATION,
+            event_type=EventType.CHANNEL_CREATED,
+            title=f"Notification channel '{channel_name}' created",
+            severity=EventSeverity.INFO,
+            message=f"New notification channel '{channel_name}' ({channel_type}) was created",
+            triggered_by=triggered_by,
+            details={'channel_name': channel_name, 'channel_type': channel_type}
+        )
+
+    def log_system_event(self,
+                       title: str,
+                       message: str,
+                       severity: EventSeverity = EventSeverity.INFO,
+                       event_type: EventType = EventType.STARTUP,
+                       details: Optional[Dict[str, Any]] = None):
+        """Log system-level events"""
+        self.log_event(
+            category=EventCategory.SYSTEM,
+            event_type=event_type,
+            title=title,
+            severity=severity,
+            message=message,
+            details=details
+        )
+
+class PerformanceTimer:
+    """Context manager for timing operations"""
+
+    def __init__(self, event_logger: EventLogger, operation_name: str, context: Optional[EventContext] = None):
+        self.event_logger = event_logger
+        self.operation_name = operation_name
+        self.context = context or EventContext()
+        self.start_time = None
+        self.correlation_id = None
+
+    def __enter__(self):
+        self.start_time = time.time()
+        self.correlation_id = self.event_logger.create_correlation_id()
+        self.context.correlation_id = self.correlation_id
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        duration_ms = int((time.time() - self.start_time) * 1000)
+
+        if exc_type is None:
+            # Success
+            self.event_logger.log_event(
+                category=EventCategory.SYSTEM,
+                event_type=EventType.PERFORMANCE,
+                title=f"{self.operation_name} completed",
+                severity=EventSeverity.DEBUG,
+                message=f"Operation '{self.operation_name}' completed in {duration_ms}ms",
+                context=self.context,
+                duration_ms=duration_ms
+            )
+        else:
+            # Error occurred
+            self.event_logger.log_event(
+                category=EventCategory.SYSTEM,
+                event_type=EventType.ERROR,
+                title=f"{self.operation_name} failed",
+                severity=EventSeverity.ERROR,
+                message=f"Operation '{self.operation_name}' failed after {duration_ms}ms: {exc_val}",
+                context=self.context,
+                duration_ms=duration_ms,
+                details={'error_type': exc_type.__name__ if exc_type else None, 'error_message': str(exc_val)}
+            )
+
+        self.event_logger.end_correlation(self.correlation_id)
\ No newline at end of file
diff --git a/dockmon/backend/main.py b/dockmon/backend/main.py
new file mode 100644
index 0000000..1dca962
--- /dev/null
+++ b/dockmon/backend/main.py
@@ -0,0 +1,1632 @@
+#!/usr/bin/env python3
+"""
+DockMon Backend - Docker Container Monitoring System
+Supports multiple Docker hosts with auto-restart and alerts
+"""
+
+import asyncio
+import json
+import logging
+import time
+import uuid
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any
+from contextlib import asynccontextmanager
+
+import docker
+from docker import DockerClient
+from docker.errors import DockerException, APIError
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException, Request, Depends, status, Cookie, Response, Query
+from fastapi.middleware.cors import CORSMiddleware
+# Session-based auth - no longer need HTTPBearer
+from fastapi.responses import FileResponse
+from database import DatabaseManager
+from realtime import RealtimeMonitor
+from notifications import NotificationService, AlertProcessor
+from event_logger import EventLogger, EventContext, EventCategory, EventType, EventSeverity, PerformanceTimer
+
+# Import extracted modules
+from config.settings import AppConfig, get_cors_origins, setup_logging
+from models.docker_models import DockerHostConfig, DockerHost
+from models.settings_models import GlobalSettings, AlertRule
+from models.request_models import (
+    AutoRestartRequest, AlertRuleCreate, AlertRuleUpdate,
+    NotificationChannelCreate, NotificationChannelUpdate, EventLogFilter
+)
+from security.audit import security_audit
+from security.rate_limiting import rate_limiter, rate_limit_auth, rate_limit_hosts, rate_limit_containers, rate_limit_notifications, rate_limit_default
+from auth.routes import router as auth_router, verify_frontend_session
+verify_session_auth = verify_frontend_session
+from websocket.connection import ConnectionManager, DateTimeEncoder
+from websocket.rate_limiter import ws_rate_limiter
+from docker_monitor.monitor import DockerMonitor
+
+# Configure logging
+setup_logging()
+logger = logging.getLogger(__name__)
+
+
+
+
+
+
+# ==================== FastAPI Application ====================
+
+# Create monitor instance
+monitor = DockerMonitor()
+
+
+# ==================== Authentication ====================
+
+# Session-based authentication only - no API keys needed
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Manage application lifecycle"""
+    # Startup
+    logger.info("Starting DockMon backend...")
+
+    # Ensure default user exists
+    monitor.db.get_or_create_default_user()
+
+    await monitor.event_logger.start()
+    monitor.event_logger.log_system_event("DockMon Backend Starting", "DockMon backend is initializing", EventSeverity.INFO, EventType.STARTUP)
+
+    # Connect security audit logger to event logger
+    security_audit.set_event_logger(monitor.event_logger)
+    monitor.monitoring_task = asyncio.create_task(monitor.monitor_containers())
+    monitor.cleanup_task = asyncio.create_task(monitor.cleanup_old_data())
+
+    # Start blackout window monitoring with WebSocket support
+    await monitor.notification_service.blackout_manager.start_monitoring(
+        monitor.notification_service,
+        monitor,  # Pass DockerMonitor instance to avoid re-initialization
+        monitor.manager  # Pass ConnectionManager for WebSocket broadcasts
+    )
+    yield
+    # Shutdown
+    logger.info("Shutting down DockMon backend...")
+    monitor.event_logger.log_system_event("DockMon Backend Shutting Down", "DockMon backend is shutting down", EventSeverity.INFO, EventType.SHUTDOWN)
+    if monitor.monitoring_task:
+        monitor.monitoring_task.cancel()
+    if monitor.cleanup_task:
+        monitor.cleanup_task.cancel()
+    # Stop blackout monitoring
+    monitor.notification_service.blackout_manager.stop_monitoring()
+    # Close stats client (HTTP session and WebSocket)
+    from stats_client import get_stats_client
+    await get_stats_client().close()
+    # Close notification service
+    await monitor.notification_service.close()
+    # Stop event logger
+    await monitor.event_logger.stop()
+    # Dispose SQLAlchemy engine
+    monitor.db.engine.dispose()
+    logger.info("SQLAlchemy engine disposed")
+
+app = FastAPI(
+    title="DockMon API",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# Configure CORS - Production ready with environment-based configuration
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=AppConfig.CORS_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+    allow_headers=["Content-Type", "Authorization"],
+)
+
+logger.info(f"CORS configured for origins: {AppConfig.CORS_ORIGINS}")
+
+# ==================== API Routes ====================
+
+# Register authentication router
+app.include_router(auth_router)
+
+@app.get("/")
+async def root(authenticated: bool = Depends(verify_session_auth)):
+    """Backend API root - frontend is served separately"""
+    return {"message": "DockMon Backend API", "version": "1.0.0", "docs": "/docs"}
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint for Docker health checks - no authentication required"""
+    return {"status": "healthy", "service": "dockmon-backend"}
+
+def _is_localhost_or_internal(ip: str) -> bool:
+    """Check if IP is localhost or internal network (Docker networks, private networks)"""
+    import ipaddress
+    try:
+        addr = ipaddress.ip_address(ip)
+
+        # Allow localhost
+        if addr.is_loopback:
+            return True
+
+        # Allow private networks (RFC 1918) - for Docker networks and internal deployments
+        if addr.is_private:
+            return True
+
+        return False
+    except ValueError:
+        # Invalid IP format
+        return False
+
+
+# ==================== Frontend Authentication ====================
+
+async def verify_session_auth(request: Request):
+    """Verify authentication via session cookie only"""
+    from auth.routes import _get_session_from_cookie
+    from auth.session_manager import session_manager
+
+    # Since backend only listens on 127.0.0.1, all requests must come through nginx
+    # No need to check client IP - the backend binding ensures security
+
+    # Check session authentication
+    session_id = _get_session_from_cookie(request)
+    if session_id and session_manager.validate_session(session_id, request):
+        return True
+
+    # No valid session found
+    raise HTTPException(
+        status_code=401,
+        detail="Authentication required - please login"
+    )
+
+
+
+@app.get("/api/hosts")
+async def get_hosts(authenticated: bool = Depends(verify_session_auth)):
+    """Get all configured Docker hosts"""
+    return list(monitor.hosts.values())
+
+@app.post("/api/hosts")
+async def add_host(config: DockerHostConfig, authenticated: bool = Depends(verify_session_auth), rate_limit_check: bool = rate_limit_hosts, request: Request = None):
+    """Add a new Docker host"""
+    try:
+        host = monitor.add_host(config)
+
+        # Security audit log - successful privileged action
+        if request:
+            security_audit.log_privileged_action(
+                client_ip=request.client.host if hasattr(request, 'client') else "unknown",
+                action="ADD_DOCKER_HOST",
+                target=f"{config.name} ({config.url})",
+                success=True,
+                user_agent=request.headers.get('user-agent', 'unknown')
+            )
+
+        # Broadcast host addition to WebSocket clients so they refresh
+        await monitor.manager.broadcast({
+            "type": "host_added",
+            "data": {"host_id": host.id, "host_name": host.name}
+        })
+
+        return host
+    except Exception as e:
+        # Security audit log - failed privileged action
+        if request:
+            security_audit.log_privileged_action(
+                client_ip=request.client.host if hasattr(request, 'client') else "unknown",
+                action="ADD_DOCKER_HOST",
+                target=f"{config.name} ({config.url})",
+                success=False,
+                user_agent=request.headers.get('user-agent', 'unknown')
+            )
+        raise
+
+@app.put("/api/hosts/{host_id}")
+async def update_host(host_id: str, config: DockerHostConfig, authenticated: bool = Depends(verify_session_auth), rate_limit_check: bool = rate_limit_hosts):
+    """Update an existing Docker host"""
+    host = monitor.update_host(host_id, config)
+    return host
+
+@app.delete("/api/hosts/{host_id}")
+async def remove_host(host_id: str, authenticated: bool = Depends(verify_session_auth), rate_limit_check: bool = rate_limit_hosts):
+    """Remove a Docker host"""
+    await monitor.remove_host(host_id)
+
+    # Broadcast host removal to WebSocket clients so they refresh
+    await monitor.manager.broadcast({
+        "type": "host_removed",
+        "data": {"host_id": host_id}
+    })
+
+    return {"status": "success", "message": f"Host {host_id} removed"}
+
+@app.get("/api/hosts/{host_id}/metrics")
+async def get_host_metrics(host_id: str, authenticated: bool = Depends(verify_session_auth)):
+    """Get aggregated metrics for a Docker host (CPU, RAM, Network)"""
+    try:
+        host = monitor.hosts.get(host_id)
+        if not host:
+            raise HTTPException(status_code=404, detail="Host not found")
+
+        client = monitor.clients.get(host_id)
+        if not client:
+            raise HTTPException(status_code=503, detail="Host client not available")
+
+        # Get all running containers on this host
+        containers = client.containers.list(filters={'status': 'running'})
+
+        total_cpu = 0.0
+        total_memory_used = 0
+        total_memory_limit = 0
+        total_net_rx = 0
+        total_net_tx = 0
+        container_count = 0
+
+        for container in containers:
+            try:
+                stats = container.stats(stream=False)
+
+                # Calculate CPU percentage
+                cpu_delta = stats['cpu_stats']['cpu_usage']['total_usage'] - \
+                           stats['precpu_stats']['cpu_usage']['total_usage']
+                system_delta = stats['cpu_stats']['system_cpu_usage'] - \
+                              stats['precpu_stats']['system_cpu_usage']
+
+                if system_delta > 0:
+                    num_cpus = len(stats['cpu_stats']['cpu_usage'].get('percpu_usage', [1]))
+                    cpu_percent = (cpu_delta / system_delta) * num_cpus * 100.0
+                    total_cpu += cpu_percent
+
+                # Memory
+                mem_usage = stats['memory_stats'].get('usage', 0)
+                mem_limit = stats['memory_stats'].get('limit', 1)
+                total_memory_used += mem_usage
+                total_memory_limit += mem_limit
+
+                # Network I/O
+                networks = stats.get('networks', {})
+                for net_stats in networks.values():
+                    total_net_rx += net_stats.get('rx_bytes', 0)
+                    total_net_tx += net_stats.get('tx_bytes', 0)
+
+                container_count += 1
+
+            except Exception as e:
+                logger.warning(f"Failed to get stats for container {container.id}: {e}")
+                continue
+
+        # Calculate percentages
+        avg_cpu = round(total_cpu / container_count, 1) if container_count > 0 else 0.0
+        memory_percent = round((total_memory_used / total_memory_limit) * 100, 1) if total_memory_limit > 0 else 0.0
+
+        return {
+            "cpu_percent": avg_cpu,
+            "memory_percent": memory_percent,
+            "memory_used_bytes": total_memory_used,
+            "memory_limit_bytes": total_memory_limit,
+            "network_rx_bytes": total_net_rx,
+            "network_tx_bytes": total_net_tx,
+            "container_count": container_count,
+            "timestamp": int(time.time())
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error fetching metrics for host {host_id}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/containers")
+async def get_containers(host_id: Optional[str] = None, authenticated: bool = Depends(verify_session_auth)):
+    """Get all containers"""
+    return await monitor.get_containers(host_id)
+
+@app.post("/api/hosts/{host_id}/containers/{container_id}/restart")
+async def restart_container(host_id: str, container_id: str, authenticated: bool = Depends(verify_session_auth), rate_limit_check: bool = rate_limit_containers):
+    """Restart a container"""
+    success = monitor.restart_container(host_id, container_id)
+    return {"status": "success" if success else "failed"}
+
+@app.post("/api/hosts/{host_id}/containers/{container_id}/stop")
+async def stop_container(host_id: str, container_id: str, authenticated: bool = Depends(verify_session_auth), rate_limit_check: bool = rate_limit_containers):
+    """Stop a container"""
+    success = monitor.stop_container(host_id, container_id)
+    return {"status": "success" if success else "failed"}
+
+@app.post("/api/hosts/{host_id}/containers/{container_id}/start")
+async def start_container(host_id: str, container_id: str, authenticated: bool = Depends(verify_session_auth), rate_limit_check: bool = rate_limit_containers):
+    """Start a container"""
+    success = monitor.start_container(host_id, container_id)
+    return {"status": "success" if success else "failed"}
+
+@app.get("/api/hosts/{host_id}/containers/{container_id}/logs")
+async def get_container_logs(
+    host_id: str,
+    container_id: str,
+    tail: int = 100,
+    since: Optional[str] = None,  # ISO timestamp for getting logs since a specific time
+    authenticated: bool = Depends(verify_session_auth)
+    # No rate limiting - authenticated users can poll logs freely
+):
+    """Get container logs - Portainer-style polling approach"""
+    if host_id not in monitor.clients:
+        raise HTTPException(status_code=404, detail="Host not found")
+
+    try:
+        client = monitor.clients[host_id]
+
+        # Run blocking Docker calls in executor with timeout
+        loop = asyncio.get_event_loop()
+
+        # Get container with timeout
+        try:
+            container = await asyncio.wait_for(
+                loop.run_in_executor(None, client.containers.get, container_id),
+                timeout=5.0
+            )
+        except asyncio.TimeoutError:
+            raise HTTPException(status_code=504, detail="Timeout getting container")
+
+        # Prepare log options
+        log_kwargs = {
+            'timestamps': True,
+            'tail': tail
+        }
+
+        # Add since parameter if provided (for getting only new logs)
+        if since:
+            try:
+                # Parse ISO timestamp and convert to Unix timestamp for Docker
+                import dateutil.parser
+                dt = dateutil.parser.parse(since)
+                # Docker's 'since' expects Unix timestamp as float
+                import time
+                unix_ts = time.mktime(dt.timetuple())
+                log_kwargs['since'] = unix_ts
+                log_kwargs['tail'] = 'all'  # Get all logs since timestamp
+            except Exception as e:
+                logger.debug(f"Could not parse 'since' parameter: {e}")
+                pass  # Invalid timestamp, ignore
+
+        # Fetch logs with timeout
+        try:
+            logs = await asyncio.wait_for(
+                loop.run_in_executor(
+                    None,
+                    lambda: container.logs(**log_kwargs).decode('utf-8', errors='ignore')
+                ),
+                timeout=5.0
+            )
+        except asyncio.TimeoutError:
+            raise HTTPException(status_code=504, detail="Timeout fetching logs")
+
+        # Parse logs and extract timestamps
+        # Docker log format with timestamps: "2025-09-30T19:30:45.123456789Z actual log message"
+        parsed_logs = []
+        for line in logs.split('\n'):
+            if not line.strip():
+                continue
+
+            # Try to extract timestamp (Docker format: ISO8601 with nanoseconds)
+            try:
+                # Find the space after timestamp
+                space_idx = line.find(' ')
+                if space_idx > 0:
+                    timestamp_str = line[:space_idx]
+                    log_text = line[space_idx + 1:]
+
+                    # Parse timestamp (remove nanoseconds for Python datetime)
+                    # Format: 2025-09-30T19:30:45.123456789Z -> 2025-09-30T19:30:45.123456Z
+                    if 'T' in timestamp_str and timestamp_str.endswith('Z'):
+                        # Truncate to microseconds (6 digits) if nanoseconds present
+                        parts = timestamp_str[:-1].split('.')
+                        if len(parts) == 2 and len(parts[1]) > 6:
+                            timestamp_str = f"{parts[0]}.{parts[1][:6]}Z"
+
+                        parsed_logs.append({
+                            "timestamp": timestamp_str,
+                            "log": log_text
+                        })
+                    else:
+                        # No valid timestamp, use current time
+                        parsed_logs.append({
+                            "timestamp": datetime.utcnow().isoformat() + 'Z',
+                            "log": line
+                        })
+                else:
+                    # No space found, treat whole line as log
+                    parsed_logs.append({
+                        "timestamp": datetime.utcnow().isoformat() + 'Z',
+                        "log": line
+                    })
+            except Exception:
+                # If parsing fails, use current time
+                parsed_logs.append({
+                    "timestamp": datetime.utcnow().isoformat() + 'Z',
+                    "log": line
+                })
+
+        return {
+            "container_id": container_id,
+            "logs": parsed_logs,
+            "last_timestamp": datetime.utcnow().isoformat() + 'Z'  # For next 'since' parameter
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to get logs for {container_id}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Container exec endpoint removed for security reasons
+# Users should use direct SSH, Docker CLI, or other appropriate tools for container access
+
+
+# WebSocket log streaming removed in favor of HTTP polling (Portainer-style)
+# This is more reliable for remote Docker hosts
+
+
+@app.post("/api/containers/{container_id}/auto-restart")
+async def toggle_auto_restart(container_id: str, request: AutoRestartRequest, authenticated: bool = Depends(verify_session_auth)):
+    """Toggle auto-restart for a container"""
+    monitor.toggle_auto_restart(request.host_id, container_id, request.container_name, request.enabled)
+    return {"container_id": container_id, "auto_restart": request.enabled}
+
+@app.get("/api/rate-limit/stats")
+async def get_rate_limit_stats(authenticated: bool = Depends(verify_session_auth)):
+    """Get rate limiter statistics - admin only"""
+    return rate_limiter.get_stats()
+
+@app.get("/api/security/audit")
+async def get_security_audit_stats(authenticated: bool = Depends(verify_session_auth), request: Request = None):
+    """Get security audit statistics - admin only"""
+    if request:
+        security_audit.log_privileged_action(
+            client_ip=request.client.host if hasattr(request, 'client') else "unknown",
+            action="VIEW_SECURITY_AUDIT",
+            target="security_audit_logs",
+            success=True,
+            user_agent=request.headers.get('user-agent', 'unknown')
+        )
+    return security_audit.get_security_stats()
+
+@app.get("/api/settings")
+async def get_settings(authenticated: bool = Depends(verify_session_auth)):
+    """Get global settings"""
+    settings = monitor.db.get_settings()
+    return {
+        "max_retries": settings.max_retries,
+        "retry_delay": settings.retry_delay,
+        "default_auto_restart": settings.default_auto_restart,
+        "polling_interval": settings.polling_interval,
+        "connection_timeout": settings.connection_timeout,
+        "log_retention_days": settings.log_retention_days,
+        "enable_notifications": settings.enable_notifications,
+        "alert_template": getattr(settings, 'alert_template', None),
+        "blackout_windows": getattr(settings, 'blackout_windows', None),
+        "timezone_offset": getattr(settings, 'timezone_offset', 0),
+        "show_host_stats": getattr(settings, 'show_host_stats', True),
+        "show_container_stats": getattr(settings, 'show_container_stats', True)
+    }
+
+@app.post("/api/settings")
+async def update_settings(settings: GlobalSettings, authenticated: bool = Depends(verify_session_auth), rate_limit_check: bool = rate_limit_default):
+    """Update global settings"""
+    # Check if stats settings changed
+    old_show_host_stats = monitor.settings.show_host_stats
+    old_show_container_stats = monitor.settings.show_container_stats
+
+    updated = monitor.db.update_settings(settings.dict())
+    monitor.settings = updated  # Update in-memory settings
+
+    # Log stats collection changes
+    if old_show_host_stats != updated.show_host_stats:
+        logger.info(f"Host stats collection {'enabled' if updated.show_host_stats else 'disabled'}")
+    if old_show_container_stats != updated.show_container_stats:
+        logger.info(f"Container stats collection {'enabled' if updated.show_container_stats else 'disabled'}")
+
+    # Broadcast blackout status change to all clients
+    is_blackout, window_name = monitor.notification_service.blackout_manager.is_in_blackout_window()
+    await monitor.manager.broadcast({
+        'type': 'blackout_status_changed',
+        'data': {
+            'is_blackout': is_blackout,
+            'window_name': window_name
+        }
+    })
+
+    return settings
+
+@app.get("/api/alerts")
+async def get_alert_rules(authenticated: bool = Depends(verify_session_auth)):
+    """Get all alert rules"""
+    rules = monitor.db.get_alert_rules(enabled_only=False)
+    logger.info(f"Retrieved {len(rules)} alert rules from database")
+
+    # Check for orphaned alerts
+    orphaned = await monitor.check_orphaned_alerts()
+
+    return [{
+        "id": rule.id,
+        "name": rule.name,
+        "containers": [{"host_id": c.host_id, "container_name": c.container_name}
+                      for c in rule.containers] if rule.containers else [],
+        "trigger_events": rule.trigger_events,
+        "trigger_states": rule.trigger_states,
+        "notification_channels": rule.notification_channels,
+        "cooldown_minutes": rule.cooldown_minutes,
+        "enabled": rule.enabled,
+        "last_triggered": rule.last_triggered.isoformat() if rule.last_triggered else None,
+        "created_at": rule.created_at.isoformat(),
+        "updated_at": rule.updated_at.isoformat(),
+        "is_orphaned": rule.id in orphaned,
+        "orphaned_containers": orphaned.get(rule.id, {}).get('orphaned_containers', []) if rule.id in orphaned else []
+    } for rule in rules]
+
+
+@app.post("/api/alerts")
+async def create_alert_rule(rule: AlertRuleCreate, authenticated: bool = Depends(verify_session_auth), rate_limit_check: bool = rate_limit_default):
+    """Create a new alert rule"""
+    try:
+        # Validate cooldown_minutes
+        if rule.cooldown_minutes < 0 or rule.cooldown_minutes > 10080:  # Max 1 week
+            raise HTTPException(status_code=400, detail="Cooldown must be between 0 and 10080 minutes (1 week)")
+
+        rule_id = str(uuid.uuid4())
+
+        # Convert ContainerHostPair objects to dicts for database
+        containers_data = None
+        if rule.containers:
+            containers_data = [{"host_id": c.host_id, "container_name": c.container_name}
+                             for c in rule.containers]
+
+        logger.info(f"Creating alert rule: {rule.name} with {len(containers_data) if containers_data else 0} container+host pairs")
+
+        db_rule = monitor.db.add_alert_rule({
+            "id": rule_id,
+            "name": rule.name,
+            "containers": containers_data,
+            "trigger_events": rule.trigger_events,
+            "trigger_states": rule.trigger_states,
+            "notification_channels": rule.notification_channels,
+            "cooldown_minutes": rule.cooldown_minutes,
+            "enabled": rule.enabled
+        })
+        logger.info(f"Successfully created alert rule with ID: {db_rule.id}")
+
+        # Log alert rule creation
+        monitor.event_logger.log_alert_rule_created(
+            rule_name=db_rule.name,
+            rule_id=db_rule.id,
+            container_count=len(db_rule.containers) if db_rule.containers else 0,
+            channels=db_rule.notification_channels or [],
+            triggered_by="user"
+        )
+
+        return {
+            "id": db_rule.id,
+            "name": db_rule.name,
+            "containers": [{"host_id": c.host_id, "container_name": c.container_name}
+                          for c in db_rule.containers] if db_rule.containers else [],
+            "trigger_events": db_rule.trigger_events,
+            "trigger_states": db_rule.trigger_states,
+            "notification_channels": db_rule.notification_channels,
+            "cooldown_minutes": db_rule.cooldown_minutes,
+            "enabled": db_rule.enabled,
+            "last_triggered": None,
+            "created_at": db_rule.created_at.isoformat(),
+            "updated_at": db_rule.updated_at.isoformat()
+        }
+    except Exception as e:
+        logger.error(f"Failed to create alert rule: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.put("/api/alerts/{rule_id}")
+async def update_alert_rule(rule_id: str, updates: AlertRuleUpdate, authenticated: bool = Depends(verify_session_auth)):
+    """Update an alert rule"""
+    try:
+        # Validate cooldown_minutes if provided
+        if updates.cooldown_minutes is not None:
+            if updates.cooldown_minutes < 0 or updates.cooldown_minutes > 10080:  # Max 1 week
+                raise HTTPException(status_code=400, detail="Cooldown must be between 0 and 10080 minutes (1 week)")
+
+        # Include all fields that are explicitly set, even if empty
+        # This allows clearing trigger_events or trigger_states
+        update_data = {}
+        for k, v in updates.dict().items():
+            if v is not None:
+                # Convert empty lists to None for trigger fields
+                if k in ['trigger_events', 'trigger_states'] and isinstance(v, list) and not v:
+                    update_data[k] = None
+                # Handle containers field separately
+                elif k == 'containers':
+                    # v is already a list of dicts after .dict() call
+                    # Include it even if None to clear the containers (set to "all containers")
+                    update_data[k] = v
+                else:
+                    update_data[k] = v
+            elif k == 'containers':
+                # Explicitly handle containers=None to clear specific container selection
+                update_data[k] = None
+
+        # Validate that at least one trigger type remains after update
+        if 'trigger_events' in update_data or 'trigger_states' in update_data:
+            # Get current rule to check what will remain
+            current_rule = monitor.db.get_alert_rule(rule_id)
+            if current_rule:
+                final_events = update_data.get('trigger_events', current_rule.trigger_events)
+                final_states = update_data.get('trigger_states', current_rule.trigger_states)
+
+                if not final_events and not final_states:
+                    raise HTTPException(status_code=400,
+                        detail="Alert rule must have at least one trigger event or state")
+
+        db_rule = monitor.db.update_alert_rule(rule_id, update_data)
+
+        if not db_rule:
+            raise HTTPException(status_code=404, detail="Alert rule not found")
+
+        # Refresh in-memory alert rules
+        return {
+            "id": db_rule.id,
+            "name": db_rule.name,
+            "containers": [{"host_id": c.host_id, "container_name": c.container_name}
+                          for c in db_rule.containers] if db_rule.containers else [],
+            "trigger_events": db_rule.trigger_events,
+            "trigger_states": db_rule.trigger_states,
+            "notification_channels": db_rule.notification_channels,
+            "cooldown_minutes": db_rule.cooldown_minutes,
+            "enabled": db_rule.enabled,
+            "last_triggered": db_rule.last_triggered.isoformat() if db_rule.last_triggered else None,
+            "created_at": db_rule.created_at.isoformat(),
+            "updated_at": db_rule.updated_at.isoformat()
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to update alert rule: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.delete("/api/alerts/{rule_id}")
+async def delete_alert_rule(rule_id: str, authenticated: bool = Depends(verify_session_auth), rate_limit_check: bool = rate_limit_default):
+    """Delete an alert rule"""
+    try:
+        # Get rule info before deleting for logging
+        rule = monitor.db.get_alert_rule(rule_id)
+        if not rule:
+            raise HTTPException(status_code=404, detail="Alert rule not found")
+
+        rule_name = rule.name
+        success = monitor.db.delete_alert_rule(rule_id)
+        if not success:
+            raise HTTPException(status_code=404, detail="Alert rule not found")
+
+        # Refresh in-memory alert rules
+        # Log alert rule deletion
+        monitor.event_logger.log_alert_rule_deleted(
+            rule_name=rule_name,
+            rule_id=rule_id,
+            triggered_by="user"
+        )
+
+        return {"status": "success", "message": f"Alert rule {rule_id} deleted"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to delete alert rule: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.get("/api/alerts/orphaned")
+async def get_orphaned_alerts(authenticated: bool = Depends(verify_session_auth)):
+    """Get alert rules that reference non-existent containers"""
+    try:
+        orphaned = await monitor.check_orphaned_alerts()
+        return {
+            "count": len(orphaned),
+            "orphaned_rules": orphaned
+        }
+    except Exception as e:
+        logger.error(f"Failed to check orphaned alerts: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# ==================== Blackout Window Routes ====================
+
+@app.get("/api/blackout/status")
+async def get_blackout_status(authenticated: bool = Depends(verify_session_auth)):
+    """Get current blackout window status"""
+    try:
+        is_blackout, window_name = monitor.notification_service.blackout_manager.is_in_blackout_window()
+        return {
+            "is_blackout": is_blackout,
+            "current_window": window_name
+        }
+    except Exception as e:
+        logger.error(f"Error getting blackout status: {e}")
+        return {"is_blackout": False, "current_window": None}
+
+# ==================== Notification Channel Routes ====================
+
+
+@app.get("/api/notifications/template-variables")
+async def get_template_variables(authenticated: bool = Depends(verify_session_auth)):
+    """Get available template variables for notification messages"""
+    return {
+        "variables": [
+            {"name": "{CONTAINER_NAME}", "description": "Name of the container"},
+            {"name": "{CONTAINER_ID}", "description": "Short container ID (12 characters)"},
+            {"name": "{HOST_NAME}", "description": "Name of the Docker host"},
+            {"name": "{HOST_ID}", "description": "ID of the Docker host"},
+            {"name": "{OLD_STATE}", "description": "Previous state of the container"},
+            {"name": "{NEW_STATE}", "description": "New state of the container"},
+            {"name": "{IMAGE}", "description": "Docker image name"},
+            {"name": "{TIMESTAMP}", "description": "Full timestamp (YYYY-MM-DD HH:MM:SS)"},
+            {"name": "{TIME}", "description": "Time only (HH:MM:SS)"},
+            {"name": "{DATE}", "description": "Date only (YYYY-MM-DD)"},
+            {"name": "{RULE_NAME}", "description": "Name of the alert rule"},
+            {"name": "{RULE_ID}", "description": "ID of the alert rule"},
+            {"name": "{TRIGGERED_BY}", "description": "What triggered the alert"},
+            {"name": "{EVENT_TYPE}", "description": "Docker event type (if applicable)"},
+            {"name": "{EXIT_CODE}", "description": "Container exit code (if applicable)"}
+        ],
+        "default_template": """🚨 **DockMon Alert**
+
+**Container:** `{CONTAINER_NAME}`
+**Host:** {HOST_NAME}
+**State Change:** `{OLD_STATE}` → `{NEW_STATE}`
+**Image:** {IMAGE}
+**Time:** {TIMESTAMP}
+**Rule:** {RULE_NAME}
+───────────────────────""",
+        "examples": {
+            "simple": "Alert: {CONTAINER_NAME} on {HOST_NAME} changed from {OLD_STATE} to {NEW_STATE}",
+            "detailed": """🔴 Container Alert
+Container: {CONTAINER_NAME} ({CONTAINER_ID})
+Host: {HOST_NAME}
+Status: {OLD_STATE} → {NEW_STATE}
+Image: {IMAGE}
+Time: {TIMESTAMP}
+Triggered by: {RULE_NAME}""",
+            "minimal": "{CONTAINER_NAME}: {NEW_STATE} at {TIME}"
+        }
+    }
+
+@app.get("/api/notifications/channels")
+async def get_notification_channels(authenticated: bool = Depends(verify_session_auth)):
+    """Get all notification channels"""
+    channels = monitor.db.get_notification_channels(enabled_only=False)
+    return [{
+        "id": ch.id,
+        "name": ch.name,
+        "type": ch.type,
+        "config": ch.config,
+        "enabled": ch.enabled,
+        "created_at": ch.created_at.isoformat(),
+        "updated_at": ch.updated_at.isoformat()
+    } for ch in channels]
+
+@app.post("/api/notifications/channels")
+async def create_notification_channel(channel: NotificationChannelCreate, authenticated: bool = Depends(verify_session_auth), rate_limit_check: bool = rate_limit_notifications):
+    """Create a new notification channel"""
+    try:
+        db_channel = monitor.db.add_notification_channel({
+            "name": channel.name,
+            "type": channel.type,
+            "config": channel.config,
+            "enabled": channel.enabled
+        })
+
+        # Log notification channel creation
+        monitor.event_logger.log_notification_channel_created(
+            channel_name=db_channel.name,
+            channel_type=db_channel.type,
+            triggered_by="user"
+        )
+
+        return {
+            "id": db_channel.id,
+            "name": db_channel.name,
+            "type": db_channel.type,
+            "config": db_channel.config,
+            "enabled": db_channel.enabled,
+            "created_at": db_channel.created_at.isoformat(),
+            "updated_at": db_channel.updated_at.isoformat()
+        }
+    except Exception as e:
+        logger.error(f"Failed to create notification channel: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.put("/api/notifications/channels/{channel_id}")
+async def update_notification_channel(channel_id: int, updates: NotificationChannelUpdate, authenticated: bool = Depends(verify_session_auth), rate_limit_check: bool = rate_limit_notifications):
+    """Update a notification channel"""
+    try:
+        update_data = {k: v for k, v in updates.dict().items() if v is not None}
+        db_channel = monitor.db.update_notification_channel(channel_id, update_data)
+
+        if not db_channel:
+            raise HTTPException(status_code=404, detail="Channel not found")
+
+        return {
+            "id": db_channel.id,
+            "name": db_channel.name,
+            "type": db_channel.type,
+            "config": db_channel.config,
+            "enabled": db_channel.enabled,
+            "created_at": db_channel.created_at.isoformat(),
+            "updated_at": db_channel.updated_at.isoformat()
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to update notification channel: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.get("/api/notifications/channels/{channel_id}/dependent-alerts")
+async def get_dependent_alerts(channel_id: int, authenticated: bool = Depends(verify_session_auth), rate_limit_check: bool = rate_limit_notifications):
+    """Get alerts that would be orphaned if this channel is deleted"""
+    try:
+        dependent_alerts = monitor.db.get_alerts_dependent_on_channel(channel_id)
+        return {"alerts": dependent_alerts}
+    except Exception as e:
+        logger.error(f"Failed to get dependent alerts: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.delete("/api/notifications/channels/{channel_id}")
+async def delete_notification_channel(channel_id: int, authenticated: bool = Depends(verify_session_auth), rate_limit_check: bool = rate_limit_notifications):
+    """Delete a notification channel and cascade delete alerts that would become orphaned"""
+    try:
+        # Find alerts that would be orphaned (only have this channel)
+        affected_alerts = monitor.db.get_alerts_dependent_on_channel(channel_id)
+
+        # Find all alerts that use this channel (for removal from multi-channel alerts)
+        all_alerts = monitor.db.get_alert_rules()
+
+        # Delete the channel
+        success = monitor.db.delete_notification_channel(channel_id)
+        if not success:
+            raise HTTPException(status_code=404, detail="Channel not found")
+
+        # Delete orphaned alerts
+        deleted_alerts = []
+        for alert in affected_alerts:
+            if monitor.db.delete_alert_rule(alert['id']):
+                deleted_alerts.append(alert['name'])
+
+        # Remove channel from multi-channel alerts
+        updated_alerts = []
+        for alert in all_alerts:
+            # Skip if already deleted
+            if alert.id in [a['id'] for a in affected_alerts]:
+                continue
+
+            # Check if this alert uses the deleted channel
+            channels = alert.notification_channels if isinstance(alert.notification_channels, list) else []
+            if channel_id in channels:
+                # Remove the channel
+                new_channels = [ch for ch in channels if ch != channel_id]
+                monitor.db.update_alert_rule(alert.id, {'notification_channels': new_channels})
+                updated_alerts.append(alert.name)
+
+        result = {
+            "status": "success",
+            "message": f"Channel {channel_id} deleted"
+        }
+
+        if deleted_alerts:
+            result["deleted_alerts"] = deleted_alerts
+            result["message"] += f" and {len(deleted_alerts)} orphaned alert(s) removed"
+
+        if updated_alerts:
+            result["updated_alerts"] = updated_alerts
+            if "deleted_alerts" in result:
+                result["message"] += f", {len(updated_alerts)} alert(s) updated"
+            else:
+                result["message"] += f" and {len(updated_alerts)} alert(s) updated"
+
+        return result
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to delete notification channel: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.post("/api/notifications/channels/{channel_id}/test")
+async def test_notification_channel(channel_id: int, authenticated: bool = Depends(verify_session_auth), rate_limit_check: bool = rate_limit_notifications):
+    """Test a notification channel"""
+    try:
+        if not hasattr(monitor, 'notification_service'):
+            raise HTTPException(status_code=503, detail="Notification service not available")
+
+        result = await monitor.notification_service.test_channel(channel_id)
+        return result
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to test notification channel: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# ==================== Event Log Routes ====================
+
+@app.get("/api/events")
+async def get_events(
+    category: Optional[List[str]] = Query(None),
+    event_type: Optional[str] = None,
+    severity: Optional[List[str]] = Query(None),
+    host_id: Optional[List[str]] = Query(None),
+    container_id: Optional[str] = None,
+    container_name: Optional[str] = None,
+    start_date: Optional[str] = None,
+    end_date: Optional[str] = None,
+    correlation_id: Optional[str] = None,
+    search: Optional[str] = None,
+    limit: int = 100,
+    offset: int = 0,
+    hours: Optional[int] = None,
+    authenticated: bool = Depends(verify_session_auth),
+    rate_limit_check: bool = rate_limit_default
+):
+    """
+    Get events with filtering and pagination
+
+    Query parameters:
+    - category: Filter by category (container, host, system, alert, notification)
+    - event_type: Filter by event type (state_change, action_taken, etc.)
+    - severity: Filter by severity (debug, info, warning, error, critical)
+    - host_id: Filter by specific host
+    - container_id: Filter by specific container
+    - container_name: Filter by container name (partial match)
+    - start_date: Filter events after this date (ISO 8601 format)
+    - end_date: Filter events before this date (ISO 8601 format)
+    - hours: Shortcut to get events from last X hours (overrides start_date)
+    - correlation_id: Get related events
+    - search: Search in title, message, and container name
+    - limit: Number of results per page (default 100, max 500)
+    - offset: Pagination offset
+    """
+    try:
+        # Validate and parse dates
+        start_datetime = None
+        end_datetime = None
+
+        # If hours parameter is provided, calculate start_date
+        if hours is not None:
+            start_datetime = datetime.now() - timedelta(hours=hours)
+        elif start_date:
+            try:
+                start_datetime = datetime.fromisoformat(start_date.replace('Z', '+00:00'))
+            except ValueError:
+                raise HTTPException(status_code=400, detail="Invalid start_date format. Use ISO 8601 format.")
+
+        if end_date:
+            try:
+                end_datetime = datetime.fromisoformat(end_date.replace('Z', '+00:00'))
+            except ValueError:
+                raise HTTPException(status_code=400, detail="Invalid end_date format. Use ISO 8601 format.")
+
+        # Limit maximum results per page
+        if limit > 500:
+            limit = 500
+
+        # Query events from database
+        events, total_count = monitor.db.get_events(
+            category=category,
+            event_type=event_type,
+            severity=severity,
+            host_id=host_id,
+            container_id=container_id,
+            container_name=container_name,
+            start_date=start_datetime,
+            end_date=end_datetime,
+            correlation_id=correlation_id,
+            search=search,
+            limit=limit,
+            offset=offset
+        )
+
+        # Convert to JSON-serializable format
+        events_json = []
+        for event in events:
+            events_json.append({
+                "id": event.id,
+                "correlation_id": event.correlation_id,
+                "category": event.category,
+                "event_type": event.event_type,
+                "severity": event.severity,
+                "host_id": event.host_id,
+                "host_name": event.host_name,
+                "container_id": event.container_id,
+                "container_name": event.container_name,
+                "title": event.title,
+                "message": event.message,
+                "old_state": event.old_state,
+                "new_state": event.new_state,
+                "triggered_by": event.triggered_by,
+                "details": event.details,
+                "duration_ms": event.duration_ms,
+                "timestamp": event.timestamp.isoformat()
+            })
+
+        return {
+            "events": events_json,
+            "total_count": total_count,
+            "limit": limit,
+            "offset": offset,
+            "has_more": (offset + limit) < total_count
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to get events: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/events/{event_id}")
+async def get_event_by_id(
+    event_id: int,
+    authenticated: bool = Depends(verify_session_auth),
+    rate_limit_check: bool = rate_limit_default
+):
+    """Get a specific event by ID"""
+    try:
+        event = monitor.db.get_event_by_id(event_id)
+        if not event:
+            raise HTTPException(status_code=404, detail="Event not found")
+
+        return {
+            "id": event.id,
+            "correlation_id": event.correlation_id,
+            "category": event.category,
+            "event_type": event.event_type,
+            "severity": event.severity,
+            "host_id": event.host_id,
+            "host_name": event.host_name,
+            "container_id": event.container_id,
+            "container_name": event.container_name,
+            "title": event.title,
+            "message": event.message,
+            "old_state": event.old_state,
+            "new_state": event.new_state,
+            "triggered_by": event.triggered_by,
+            "details": event.details,
+            "duration_ms": event.duration_ms,
+            "timestamp": event.timestamp.isoformat()
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to get event: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/events/correlation/{correlation_id}")
+async def get_events_by_correlation(
+    correlation_id: str,
+    authenticated: bool = Depends(verify_session_auth),
+    rate_limit_check: bool = rate_limit_default
+):
+    """Get all events with the same correlation ID (related events)"""
+    try:
+        events = monitor.db.get_events_by_correlation(correlation_id)
+
+        events_json = []
+        for event in events:
+            events_json.append({
+                "id": event.id,
+                "correlation_id": event.correlation_id,
+                "category": event.category,
+                "event_type": event.event_type,
+                "severity": event.severity,
+                "host_id": event.host_id,
+                "host_name": event.host_name,
+                "container_id": event.container_id,
+                "container_name": event.container_name,
+                "title": event.title,
+                "message": event.message,
+                "old_state": event.old_state,
+                "new_state": event.new_state,
+                "triggered_by": event.triggered_by,
+                "details": event.details,
+                "duration_ms": event.duration_ms,
+                "timestamp": event.timestamp.isoformat()
+            })
+
+        return {"events": events_json, "count": len(events_json)}
+    except Exception as e:
+        logger.error(f"Failed to get events by correlation: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# ==================== User Dashboard Routes ====================
+
+@app.get("/api/user/dashboard-layout")
+async def get_dashboard_layout(request: Request, authenticated: bool = Depends(verify_session_auth)):
+    """Get dashboard layout for current user"""
+    from auth.routes import _get_session_from_cookie
+    from auth.session_manager import session_manager
+
+    session_id = _get_session_from_cookie(request)
+    username = session_manager.get_session_username(session_id)
+
+    layout = monitor.db.get_dashboard_layout(username)
+    return {"layout": layout}
+
+@app.post("/api/user/dashboard-layout")
+async def save_dashboard_layout(request: Request, authenticated: bool = Depends(verify_session_auth)):
+    """Save dashboard layout for current user"""
+    from auth.routes import _get_session_from_cookie
+    from auth.session_manager import session_manager
+
+    session_id = _get_session_from_cookie(request)
+    username = session_manager.get_session_username(session_id)
+
+    try:
+        body = await request.json()
+        layout_json = body.get('layout')
+
+        if layout_json is None:
+            raise HTTPException(status_code=400, detail="Layout is required")
+
+        # Validate JSON structure
+        if layout_json:
+            try:
+                parsed_layout = json.loads(layout_json) if isinstance(layout_json, str) else layout_json
+
+                # Validate it's a list
+                if not isinstance(parsed_layout, list):
+                    raise HTTPException(status_code=400, detail="Layout must be an array of widget positions")
+
+                # Validate each widget has required fields
+                required_fields = ['x', 'y', 'w', 'h']
+                for widget in parsed_layout:
+                    if not isinstance(widget, dict):
+                        raise HTTPException(status_code=400, detail="Each widget must be an object")
+                    for field in required_fields:
+                        if field not in widget:
+                            raise HTTPException(status_code=400, detail=f"Widget missing required field: {field}")
+                        if not isinstance(widget[field], (int, float)):
+                            raise HTTPException(status_code=400, detail=f"Widget field '{field}' must be a number")
+
+                # Convert back to string for storage
+                layout_json = json.dumps(parsed_layout)
+            except json.JSONDecodeError:
+                raise HTTPException(status_code=400, detail="Invalid JSON format for layout")
+
+        success = monitor.db.save_dashboard_layout(username, layout_json)
+        if not success:
+            raise HTTPException(status_code=500, detail="Failed to save layout")
+
+        return {"success": True}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to save dashboard layout: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/user/event-sort-order")
+async def get_event_sort_order(request: Request, authenticated: bool = Depends(verify_session_auth)):
+    """Get event sort order preference for current user"""
+    from auth.routes import _get_session_from_cookie
+    from auth.session_manager import session_manager
+
+    session_id = _get_session_from_cookie(request)
+    username = session_manager.get_session_username(session_id)
+
+    sort_order = monitor.db.get_event_sort_order(username)
+    return {"sort_order": sort_order}
+
+@app.post("/api/user/event-sort-order")
+async def save_event_sort_order(request: Request, authenticated: bool = Depends(verify_session_auth)):
+    """Save event sort order preference for current user"""
+    from auth.routes import _get_session_from_cookie
+    from auth.session_manager import session_manager
+
+    session_id = _get_session_from_cookie(request)
+    username = session_manager.get_session_username(session_id)
+
+    try:
+        body = await request.json()
+        sort_order = body.get('sort_order')
+
+        if sort_order not in ['asc', 'desc']:
+            raise HTTPException(status_code=400, detail="sort_order must be 'asc' or 'desc'")
+
+        success = monitor.db.save_event_sort_order(username, sort_order)
+        if not success:
+            raise HTTPException(status_code=500, detail="Failed to save sort order")
+
+        return {"success": True}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to save event sort order: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/user/container-sort-order")
+async def get_container_sort_order(request: Request, authenticated: bool = Depends(verify_session_auth)):
+    """Get container sort order preference for current user"""
+    from auth.routes import _get_session_from_cookie
+    from auth.session_manager import session_manager
+
+    session_id = _get_session_from_cookie(request)
+    username = session_manager.get_session_username(session_id)
+
+    sort_order = monitor.db.get_container_sort_order(username)
+    return {"sort_order": sort_order}
+
+@app.post("/api/user/container-sort-order")
+async def save_container_sort_order(request: Request, authenticated: bool = Depends(verify_session_auth)):
+    """Save container sort order preference for current user"""
+    from auth.routes import _get_session_from_cookie
+    from auth.session_manager import session_manager
+
+    session_id = _get_session_from_cookie(request)
+    username = session_manager.get_session_username(session_id)
+
+    try:
+        body = await request.json()
+        sort_order = body.get('sort_order')
+
+        valid_sorts = ['name-asc', 'name-desc', 'status', 'memory-desc', 'memory-asc', 'cpu-desc', 'cpu-asc']
+        if sort_order not in valid_sorts:
+            raise HTTPException(status_code=400, detail=f"sort_order must be one of: {', '.join(valid_sorts)}")
+
+        success = monitor.db.save_container_sort_order(username, sort_order)
+        if not success:
+            raise HTTPException(status_code=500, detail="Failed to save sort order")
+
+        return {"success": True}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to save container sort order: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/user/modal-preferences")
+async def get_modal_preferences(request: Request, authenticated: bool = Depends(verify_session_auth)):
+    """Get modal preferences for current user"""
+    from auth.routes import _get_session_from_cookie
+    from auth.session_manager import session_manager
+
+    session_id = _get_session_from_cookie(request)
+    username = session_manager.get_session_username(session_id)
+
+    preferences = monitor.db.get_modal_preferences(username)
+    return {"preferences": preferences}
+
+@app.post("/api/user/modal-preferences")
+async def save_modal_preferences(request: Request, authenticated: bool = Depends(verify_session_auth)):
+    """Save modal preferences for current user"""
+    from auth.routes import _get_session_from_cookie
+    from auth.session_manager import session_manager
+
+    session_id = _get_session_from_cookie(request)
+    username = session_manager.get_session_username(session_id)
+
+    try:
+        body = await request.json()
+        preferences = body.get('preferences')
+
+        if preferences is None:
+            raise HTTPException(status_code=400, detail="Preferences are required")
+
+        success = monitor.db.save_modal_preferences(username, preferences)
+        if not success:
+            raise HTTPException(status_code=500, detail="Failed to save preferences")
+
+        return {"success": True}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to save modal preferences: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# ==================== Event Log Routes ====================
+# Note: Main /api/events endpoint is defined earlier with full feature set
+
+@app.get("/api/events/{event_id}")
+async def get_event(event_id: int, authenticated: bool = Depends(verify_session_auth)):
+    """Get a specific event by ID"""
+    try:
+        event = monitor.db.get_event_by_id(event_id)
+        if not event:
+            raise HTTPException(status_code=404, detail="Event not found")
+
+        return {
+            "id": event.id,
+            "correlation_id": event.correlation_id,
+            "category": event.category,
+            "event_type": event.event_type,
+            "severity": event.severity,
+            "host_id": event.host_id,
+            "host_name": event.host_name,
+            "container_id": event.container_id,
+            "container_name": event.container_name,
+            "title": event.title,
+            "message": event.message,
+            "old_state": event.old_state,
+            "new_state": event.new_state,
+            "triggered_by": event.triggered_by,
+            "details": event.details,
+            "duration_ms": event.duration_ms,
+            "timestamp": event.timestamp.isoformat()
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to get event {event_id}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/events/correlation/{correlation_id}")
+async def get_events_by_correlation(correlation_id: str, authenticated: bool = Depends(verify_session_auth)):
+    """Get all events with the same correlation ID"""
+    try:
+        events = monitor.db.get_events_by_correlation(correlation_id)
+
+        return {
+            "correlation_id": correlation_id,
+            "events": [{
+                "id": event.id,
+                "correlation_id": event.correlation_id,
+                "category": event.category,
+                "event_type": event.event_type,
+                "severity": event.severity,
+                "host_id": event.host_id,
+                "host_name": event.host_name,
+                "container_id": event.container_id,
+                "container_name": event.container_name,
+                "title": event.title,
+                "message": event.message,
+                "old_state": event.old_state,
+                "new_state": event.new_state,
+                "triggered_by": event.triggered_by,
+                "details": event.details,
+                "duration_ms": event.duration_ms,
+                "timestamp": event.timestamp.isoformat()
+            } for event in events]
+        }
+    except Exception as e:
+        logger.error(f"Failed to get events by correlation {correlation_id}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/events/statistics")
+async def get_event_statistics(start_date: Optional[str] = None,
+                             end_date: Optional[str] = None,
+                             authenticated: bool = Depends(verify_session_auth)):
+    """Get event statistics for dashboard"""
+    try:
+        # Parse dates
+        parsed_start_date = None
+        parsed_end_date = None
+
+        if start_date:
+            try:
+                parsed_start_date = datetime.fromisoformat(start_date.replace('Z', '+00:00'))
+            except ValueError:
+                raise HTTPException(status_code=400, detail="Invalid start_date format")
+
+        if end_date:
+            try:
+                parsed_end_date = datetime.fromisoformat(end_date.replace('Z', '+00:00'))
+            except ValueError:
+                raise HTTPException(status_code=400, detail="Invalid end_date format")
+
+        stats = monitor.db.get_event_statistics(
+            start_date=parsed_start_date,
+            end_date=parsed_end_date
+        )
+
+        return stats
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to get event statistics: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/events/container/{container_id}")
+async def get_container_events(container_id: str, limit: int = 50, authenticated: bool = Depends(verify_session_auth)):
+    """Get events for a specific container"""
+    try:
+        events, total_count = monitor.db.get_events(
+            container_id=container_id,
+            limit=limit,
+            offset=0
+        )
+
+        return {
+            "container_id": container_id,
+            "events": [{
+                "id": event.id,
+                "correlation_id": event.correlation_id,
+                "category": event.category,
+                "event_type": event.event_type,
+                "severity": event.severity,
+                "host_id": event.host_id,
+                "host_name": event.host_name,
+                "container_id": event.container_id,
+                "container_name": event.container_name,
+                "title": event.title,
+                "message": event.message,
+                "old_state": event.old_state,
+                "new_state": event.new_state,
+                "triggered_by": event.triggered_by,
+                "details": event.details,
+                "duration_ms": event.duration_ms,
+                "timestamp": event.timestamp.isoformat()
+            } for event in events],
+            "total_count": total_count
+        }
+    except Exception as e:
+        logger.error(f"Failed to get events for container {container_id}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/api/events/host/{host_id}")
+async def get_host_events(host_id: str, limit: int = 50, authenticated: bool = Depends(verify_session_auth)):
+    """Get events for a specific host"""
+    try:
+        events, total_count = monitor.db.get_events(
+            host_id=host_id,
+            limit=limit,
+            offset=0
+        )
+
+        return {
+            "host_id": host_id,
+            "events": [{
+                "id": event.id,
+                "correlation_id": event.correlation_id,
+                "category": event.category,
+                "event_type": event.event_type,
+                "severity": event.severity,
+                "host_id": event.host_id,
+                "host_name": event.host_name,
+                "container_id": event.container_id,
+                "container_name": event.container_name,
+                "title": event.title,
+                "message": event.message,
+                "old_state": event.old_state,
+                "new_state": event.new_state,
+                "triggered_by": event.triggered_by,
+                "details": event.details,
+                "duration_ms": event.duration_ms,
+                "timestamp": event.timestamp.isoformat()
+            } for event in events],
+            "total_count": total_count
+        }
+    except Exception as e:
+        logger.error(f"Failed to get events for host {host_id}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.delete("/api/events/cleanup")
+async def cleanup_old_events(days: int = 30, authenticated: bool = Depends(verify_session_auth)):
+    """Clean up old events - DANGEROUS: Can delete audit logs"""
+    try:
+        if days < 1:
+            raise HTTPException(status_code=400, detail="Days must be at least 1")
+
+        deleted_count = monitor.db.cleanup_old_events(days)
+
+        monitor.event_logger.log_system_event(
+            "Event Cleanup Completed",
+            f"Cleaned up {deleted_count} events older than {days} days",
+            EventSeverity.INFO,
+            EventType.STARTUP
+        )
+
+        return {
+            "status": "success",
+            "message": f"Cleaned up {deleted_count} events older than {days} days",
+            "deleted_count": deleted_count
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Failed to cleanup events: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    """WebSocket endpoint for real-time updates"""
+    # Generate a unique connection ID for rate limiting
+    connection_id = f"ws_{id(websocket)}_{time.time()}"
+
+    await monitor.manager.connect(websocket)
+    await monitor.realtime.subscribe_to_events(websocket)
+
+    # Send initial state
+    settings_dict = {
+        "max_retries": monitor.settings.max_retries,
+        "retry_delay": monitor.settings.retry_delay,
+        "default_auto_restart": monitor.settings.default_auto_restart,
+        "polling_interval": monitor.settings.polling_interval,
+        "connection_timeout": monitor.settings.connection_timeout,
+        "log_retention_days": monitor.settings.log_retention_days,
+        "enable_notifications": monitor.settings.enable_notifications,
+        "alert_template": getattr(monitor.settings, 'alert_template', None),
+        "blackout_windows": getattr(monitor.settings, 'blackout_windows', None),
+        "timezone_offset": getattr(monitor.settings, 'timezone_offset', 0),
+        "show_host_stats": getattr(monitor.settings, 'show_host_stats', True),
+        "show_container_stats": getattr(monitor.settings, 'show_container_stats', True)
+    }
+
+    initial_state = {
+        "type": "initial_state",
+        "data": {
+            "hosts": [h.dict() for h in monitor.hosts.values()],
+            "containers": [c.dict() for c in await monitor.get_containers()],
+            "settings": settings_dict
+        }
+    }
+    await websocket.send_text(json.dumps(initial_state, cls=DateTimeEncoder))
+
+    try:
+        while True:
+            # Keep connection alive and handle incoming messages
+            message = await websocket.receive_json()
+
+            # Check rate limit for incoming messages
+            allowed, reason = ws_rate_limiter.check_rate_limit(connection_id)
+            if not allowed:
+                # Send rate limit error to client
+                await websocket.send_text(json.dumps({
+                    "type": "error",
+                    "error": "rate_limit",
+                    "message": reason
+                }))
+                # Don't process the message
+                continue
+
+            # Handle different message types
+            if message.get("type") == "subscribe_stats":
+                container_id = message.get("container_id")
+                if container_id:
+                    await monitor.realtime.subscribe_to_stats(websocket, container_id)
+                    # Find the host and start monitoring
+                    for host_id, client in monitor.clients.items():
+                        try:
+                            client.containers.get(container_id)
+                            await monitor.realtime.start_container_stats_stream(
+                                client, container_id, interval=2
+                            )
+                            break
+                        except Exception as e:
+                            logger.debug(f"Container {container_id} not found on host {host_id[:8]}: {e}")
+                            continue
+
+            elif message.get("type") == "unsubscribe_stats":
+                container_id = message.get("container_id")
+                if container_id:
+                    await monitor.realtime.unsubscribe_from_stats(websocket, container_id)
+
+            elif message.get("type") == "modal_opened":
+                # Track that a container modal is open - keep stats running for this container
+                container_id = message.get("container_id")
+                host_id = message.get("host_id")
+                if container_id and host_id:
+                    # Verify container exists and user has access to it
+                    try:
+                        containers = await monitor.get_containers()  # Must await async function
+                        container_exists = any(
+                            c.id == container_id and c.host_id == host_id
+                            for c in containers
+                        )
+                        if container_exists:
+                            monitor.stats_manager.add_modal_container(container_id, host_id)
+                        else:
+                            logger.warning(f"User attempted to access stats for non-existent container: {container_id[:12]} on host {host_id[:8]}")
+                    except Exception as e:
+                        logger.error(f"Error validating container access: {e}")
+
+            elif message.get("type") == "modal_closed":
+                # Remove container from modal tracking
+                container_id = message.get("container_id")
+                host_id = message.get("host_id")
+                if container_id and host_id:
+                    monitor.stats_manager.remove_modal_container(container_id, host_id)
+
+            elif message.get("type") == "ping":
+                await websocket.send_text(json.dumps({"type": "pong"}, cls=DateTimeEncoder))
+
+    except WebSocketDisconnect:
+        await monitor.manager.disconnect(websocket)
+        await monitor.realtime.unsubscribe_from_events(websocket)
+        # Unsubscribe from all stats
+        for container_id in list(monitor.realtime.stats_subscribers):
+            await monitor.realtime.unsubscribe_from_stats(websocket, container_id)
+        # Clear modal containers (user disconnected, modals are closed)
+        monitor.stats_manager.clear_modal_containers()
+        # Clean up rate limiter tracking
+        ws_rate_limiter.cleanup_connection(connection_id)
\ No newline at end of file
diff --git a/dockmon/backend/models/__init__.py b/dockmon/backend/models/__init__.py
new file mode 100644
index 0000000..6bfcba3
--- /dev/null
+++ b/dockmon/backend/models/__init__.py
@@ -0,0 +1 @@
+# Data models module for DockMon
\ No newline at end of file
diff --git a/dockmon/backend/models/auth_models.py b/dockmon/backend/models/auth_models.py
new file mode 100644
index 0000000..21deba2
--- /dev/null
+++ b/dockmon/backend/models/auth_models.py
@@ -0,0 +1,18 @@
+"""
+Authentication Models for DockMon
+Pydantic models for authentication requests and responses
+"""
+
+from pydantic import BaseModel, Field
+
+
+class LoginRequest(BaseModel):
+    """Login request model with validation"""
+    username: str = Field(..., min_length=1, max_length=50)
+    password: str = Field(..., min_length=1, max_length=100)
+
+
+class ChangePasswordRequest(BaseModel):
+    """Change password request model"""
+    current_password: str = Field(..., min_length=1, max_length=100)
+    new_password: str = Field(..., min_length=8, max_length=100)  # Minimum 8 characters for security
\ No newline at end of file
diff --git a/dockmon/backend/models/docker_models.py b/dockmon/backend/models/docker_models.py
new file mode 100644
index 0000000..4ee5aab
--- /dev/null
+++ b/dockmon/backend/models/docker_models.py
@@ -0,0 +1,175 @@
+"""
+Docker Models for DockMon
+Pydantic models for Docker hosts, containers, and configurations
+"""
+
+import re
+import uuid
+import logging
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, Field, validator, model_validator
+
+
+logger = logging.getLogger(__name__)
+
+
+class DockerHostConfig(BaseModel):
+    """Configuration for a Docker host"""
+    name: str = Field(..., min_length=1, max_length=100, pattern=r'^[a-zA-Z0-9][a-zA-Z0-9 ._-]*$')
+    url: str = Field(..., min_length=1, max_length=500)
+    tls_cert: Optional[str] = Field(None, max_length=10000)
+    tls_key: Optional[str] = Field(None, max_length=10000)
+    tls_ca: Optional[str] = Field(None, max_length=10000)
+
+    @validator('name')
+    def validate_name(cls, v):
+        """Validate host name for security"""
+        if not v or not v.strip():
+            raise ValueError('Host name cannot be empty')
+        # Prevent XSS and injection
+        sanitized = re.sub(r'[<>"\']', '', v.strip())
+        if len(sanitized) != len(v.strip()):
+            raise ValueError('Host name contains invalid characters')
+        return sanitized
+
+    @validator('url')
+    def validate_url(cls, v):
+        """Validate Docker URL for security - prevent SSRF attacks"""
+        if not v or not v.strip():
+            raise ValueError('URL cannot be empty')
+
+        v = v.strip()
+
+        # Only allow specific protocols
+        allowed_protocols = ['tcp://', 'unix://', 'http://', 'https://']
+        if not any(v.startswith(proto) for proto in allowed_protocols):
+            raise ValueError('URL must use tcp://, unix://, http:// or https:// protocol')
+
+        # Block ONLY the most dangerous SSRF targets (cloud metadata & loopback)
+        # Allow private networks (10.*, 172.16-31.*, 192.168.*) for legitimate Docker hosts
+        extremely_dangerous_patterns = [
+            r'169\.254\.169\.254',                     # AWS/GCP metadata (specific)
+            r'169\.254\.',                             # Link-local range (broader)
+            r'metadata\.google\.internal',             # GCP metadata
+            r'metadata\.goog',                         # GCP metadata alternative
+            r'100\.100\.100\.200',                     # Alibaba Cloud metadata
+            r'fd00:ec2::254',                          # AWS IPv6 metadata
+            r'0\.0\.0\.0',                             # All interfaces binding
+            r'::1',                                    # IPv6 localhost
+            r'localhost(?!\:|$)',                      # Localhost variations but allow localhost:port
+            r'127\.0\.0\.(?!1$)',                      # 127.x.x.x but allow 127.0.0.1
+        ]
+
+        # Check for extremely dangerous metadata service targets
+        for pattern in extremely_dangerous_patterns:
+            if re.search(pattern, v, re.IGNORECASE):
+                # Special handling for localhost - allow localhost:port but block bare localhost
+                if 'localhost' in pattern.lower() and ':' in v:
+                    continue  # Allow localhost:2376 etc
+                raise ValueError('URL targets cloud metadata service or dangerous internal endpoint')
+
+        # Additional validation: warn about but allow private networks
+        private_network_patterns = [
+            r'10\.',                                   # 10.0.0.0/8
+            r'172\.(1[6-9]|2[0-9]|3[01])\.',          # 172.16.0.0/12
+            r'192\.168\.',                            # 192.168.0.0/16
+        ]
+
+        # Log private network usage for monitoring (but don't block)
+        for pattern in private_network_patterns:
+            if re.search(pattern, v, re.IGNORECASE):
+                logger.info(f"Docker host configured on private network: {v[:50]}...")
+                break
+
+        return v
+
+    @validator('tls_cert', 'tls_key', 'tls_ca')
+    def validate_certificate(cls, v):
+        """Validate TLS certificate data"""
+        if v is None:
+            return v
+
+        v = v.strip()
+        if not v:
+            return None
+
+        # Basic PEM format validation with helpful error messages
+        if '-----BEGIN' not in v and '-----END' not in v:
+            raise ValueError('Certificate is incomplete. PEM certificates must start with "-----BEGIN" and end with "-----END". Please copy the entire certificate including both lines.')
+        elif '-----BEGIN' not in v:
+            raise ValueError('Certificate is missing the "-----BEGIN" header line. Make sure you copied the complete certificate starting from the "-----BEGIN" line.')
+        elif '-----END' not in v:
+            raise ValueError('Certificate is missing the "-----END" footer line. Make sure you copied the complete certificate including the "-----END" line.')
+
+        # Block potential code injection
+        dangerous_patterns = ['<script', 'javascript:', 'data:', 'vbscript:', '<?php', '<%', '{{', '{%']
+        v_lower = v.lower()
+        if any(pattern in v_lower for pattern in dangerous_patterns):
+            raise ValueError('Certificate contains potentially dangerous content')
+
+        return v
+
+    @model_validator(mode='after')
+    def validate_tls_complete(self):
+        """Ensure TLS configuration is complete when using TCP with certificates"""
+        # Only validate for TCP connections
+        if not self.url or not self.url.startswith('tcp://'):
+            return self
+
+        # If any TLS field is provided, all three must be provided
+        tls_fields_provided = [
+            ('Client Certificate', self.tls_cert),
+            ('Client Private Key', self.tls_key),
+            ('CA Certificate', self.tls_ca)
+        ]
+
+        provided_fields = [(name, val) for name, val in tls_fields_provided if val and val.strip()]
+
+        if provided_fields and len(provided_fields) < 3:
+            # Some but not all fields provided
+            missing = [name for name, val in tls_fields_provided if not val or not val.strip()]
+            missing_str = ', '.join(missing)
+            raise ValueError(
+                f'Incomplete TLS configuration. For secure TCP connections, you must provide all three certificates. '
+                f'Missing: {missing_str}. Either provide all three certificates or remove all of them.'
+            )
+
+        return self
+
+
+class DockerHost(BaseModel):
+    """Docker host with connection status"""
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    name: str
+    url: str
+    status: str = "offline"
+    security_status: Optional[str] = None  # "secure", "insecure", "unknown"
+    last_checked: datetime = Field(default_factory=datetime.now)
+    container_count: int = 0
+    error: Optional[str] = None
+
+
+class Container(BaseModel):
+    """Container information"""
+    id: str
+    short_id: str
+    name: str
+    state: str
+    status: str
+    host_id: str
+    host_name: str
+    image: str
+    created: str
+    auto_restart: bool = False
+    restart_attempts: int = 0
+    # Stats from Go stats service
+    cpu_percent: Optional[float] = None
+    memory_usage: Optional[int] = None
+    memory_limit: Optional[int] = None
+    memory_percent: Optional[float] = None
+    network_rx: Optional[int] = None
+    network_tx: Optional[int] = None
+    disk_read: Optional[int] = None
+    disk_write: Optional[int] = None
\ No newline at end of file
diff --git a/dockmon/backend/models/request_models.py b/dockmon/backend/models/request_models.py
new file mode 100644
index 0000000..e4fe55f
--- /dev/null
+++ b/dockmon/backend/models/request_models.py
@@ -0,0 +1,275 @@
+"""
+Request Models for DockMon API Endpoints
+Pydantic models for API request validation
+"""
+
+import re
+import time
+from datetime import datetime
+from typing import Optional, List, Dict, Any
+
+from pydantic import BaseModel, Field, validator
+
+
+class ContainerHostPair(BaseModel):
+    """Container and host pair for alert rules"""
+    host_id: str = Field(..., max_length=50)
+    container_name: str = Field(..., min_length=1, max_length=200)
+
+
+class AutoRestartRequest(BaseModel):
+    """Request model for toggling auto-restart"""
+    host_id: str
+    container_name: str
+    enabled: bool
+
+
+class AlertRuleCreate(BaseModel):
+    """Request model for creating alert rules"""
+    name: str = Field(..., min_length=1, max_length=100)
+    containers: Optional[List[ContainerHostPair]] = Field(None, max_items=100)
+    trigger_events: Optional[List[str]] = Field(None, max_items=20)  # Docker events
+    trigger_states: Optional[List[str]] = Field(None, max_items=10)  # Docker states
+    notification_channels: List[int] = Field(..., min_items=1, max_items=20)
+    cooldown_minutes: int = Field(15, ge=1, le=1440)  # 1 min to 24 hours
+    enabled: bool = True
+
+    @validator('name')
+    def validate_name(cls, v):
+        """Validate rule name for security"""
+        if not v or not v.strip():
+            raise ValueError('Rule name cannot be empty')
+        # Sanitize and prevent XSS
+        sanitized = re.sub(r'[<>"\']', '', v.strip())
+        if len(sanitized) != len(v.strip()):
+            raise ValueError('Rule name contains invalid characters')
+        return sanitized
+
+    @validator('trigger_events')
+    def validate_trigger_events(cls, v):
+        """Validate Docker events"""
+        if not v:
+            return v  # Events are optional
+
+        valid_events = {
+            # Critical events
+            'oom', 'die-nonzero', 'health_status:unhealthy',
+            # Warning events
+            'kill', 'die-zero', 'restart-loop', 'stuck-removing',
+            # Info events
+            'start', 'stop', 'create', 'destroy', 'pause', 'unpause',
+            'health_status:healthy'
+        }
+
+        invalid_events = [event for event in v if event not in valid_events]
+        if invalid_events:
+            raise ValueError(f'Invalid trigger events: {invalid_events}')
+
+        return v
+
+    @validator('trigger_states')
+    def validate_trigger_states(cls, v):
+        """Validate container states"""
+        if not v:
+            return v  # States are optional now
+
+        valid_states = {'created', 'restarting', 'running', 'removing', 'paused', 'exited', 'dead'}
+        invalid_states = [state for state in v if state not in valid_states]
+        if invalid_states:
+            raise ValueError(f'Invalid trigger states: {invalid_states}')
+
+        return v
+
+    def __init__(self, **data):
+        """Custom validation to ensure at least one trigger is specified"""
+        super().__init__(**data)
+        events = self.trigger_events or []
+        states = self.trigger_states or []
+        if not events and not states:
+            raise ValueError('At least one trigger event or state is required')
+
+    @validator('notification_channels')
+    def validate_notification_channels(cls, v):
+        """Validate notification channel IDs"""
+        if not v:
+            raise ValueError('At least one notification channel is required')
+
+        # Validate all are positive integers
+        invalid_ids = [id for id in v if id <= 0]
+        if invalid_ids:
+            raise ValueError(f'Invalid notification channel IDs: {invalid_ids}')
+
+        return v
+
+
+class AlertRuleUpdate(BaseModel):
+    """Request model for updating alert rules"""
+    name: Optional[str] = None
+    containers: Optional[List[ContainerHostPair]] = None
+    trigger_events: Optional[List[str]] = None  # Docker events
+    trigger_states: Optional[List[str]] = None  # Docker states
+    notification_channels: Optional[List[int]] = None
+    cooldown_minutes: Optional[int] = None
+    enabled: Optional[bool] = None
+
+
+class NotificationChannelCreate(BaseModel):
+    """Request model for creating notification channels"""
+    name: str = Field(..., min_length=1, max_length=100)
+    type: str = Field(..., min_length=1, max_length=20)
+    config: Dict[str, Any] = Field(..., min_items=1, max_items=10)
+    enabled: bool = True
+
+    @validator('name')
+    def validate_name(cls, v):
+        """Validate channel name for security"""
+        if not v or not v.strip():
+            raise ValueError('Channel name cannot be empty')
+        # Sanitize and prevent XSS
+        sanitized = re.sub(r'[<>"\']', '', v.strip())
+        if len(sanitized) != len(v.strip()):
+            raise ValueError('Channel name contains invalid characters')
+        return sanitized
+
+    @validator('type')
+    def validate_type(cls, v):
+        """Validate notification type"""
+        if not v or not v.strip():
+            raise ValueError('Channel type cannot be empty')
+
+        valid_types = {'telegram', 'discord', 'pushover', 'slack', 'gotify', 'smtp'}
+        v = v.strip().lower()
+
+        if v not in valid_types:
+            raise ValueError(f'Invalid channel type. Must be one of: {valid_types}')
+
+        return v
+
+    @validator('config')
+    def validate_config(cls, v, values):
+        """Validate channel configuration based on type"""
+        if not v:
+            raise ValueError('Configuration cannot be empty')
+
+        channel_type = values.get('type', '').lower()
+
+        # Validate configuration based on channel type
+        if channel_type == 'telegram':
+            required_keys = {'bot_token', 'chat_id'}
+            if not all(key in v for key in required_keys):
+                raise ValueError(f'Telegram config must contain: {required_keys}')
+
+            # Validate bot token format
+            bot_token = v.get('bot_token', '')
+            if not re.match(r'^\d+:[A-Za-z0-9_-]+$', bot_token):
+                raise ValueError('Invalid Telegram bot token format')
+
+        elif channel_type == 'discord':
+            required_keys = {'webhook_url'}
+            if not all(key in v for key in required_keys):
+                raise ValueError(f'Discord config must contain: {required_keys}')
+
+            # Validate Discord webhook URL
+            webhook_url = v.get('webhook_url', '')
+            if not webhook_url.startswith('https://discord.com/api/webhooks/'):
+                raise ValueError('Invalid Discord webhook URL')
+
+        elif channel_type == 'slack':
+            required_keys = {'webhook_url'}
+            if not all(key in v for key in required_keys):
+                raise ValueError(f'Slack config must contain: {required_keys}')
+
+            # Validate Slack webhook URL
+            webhook_url = v.get('webhook_url', '')
+            if not (webhook_url.startswith('https://hooks.slack.com/services/') or
+                    webhook_url.startswith('https://hooks.slack.com/workflows/')):
+                raise ValueError('Invalid Slack webhook URL')
+
+        elif channel_type == 'pushover':
+            required_keys = {'app_token', 'user_key'}
+            if not all(key in v for key in required_keys):
+                raise ValueError(f'Pushover config must contain: {required_keys}')
+
+            # Validate token formats
+            app_token = v.get('app_token', '')
+            user_key = v.get('user_key', '')
+            if not re.match(r'^[a-z0-9]{30}$', app_token, re.IGNORECASE):
+                raise ValueError('Invalid Pushover app token format')
+            if not re.match(r'^[a-z0-9]{30}$', user_key, re.IGNORECASE):
+                raise ValueError('Invalid Pushover user key format')
+
+        elif channel_type == 'gotify':
+            required_keys = {'server_url', 'app_token'}
+            if not all(key in v for key in required_keys):
+                raise ValueError(f'Gotify config must contain: {required_keys}')
+
+            # Validate server URL
+            server_url = v.get('server_url', '')
+            if not (server_url.startswith('http://') or server_url.startswith('https://')):
+                raise ValueError('Gotify server URL must start with http:// or https://')
+
+        elif channel_type == 'smtp':
+            required_keys = {'smtp_host', 'from_email', 'to_email'}
+            if not all(key in v for key in required_keys):
+                raise ValueError(f'SMTP config must contain: {required_keys}')
+
+            # Default port to 587 if not provided or empty
+            if 'smtp_port' not in v or v['smtp_port'] == '' or v['smtp_port'] is None:
+                v['smtp_port'] = 587
+
+            # Validate email format
+            import re
+            email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+            from_email = v.get('from_email', '')
+            to_email = v.get('to_email', '')
+            if not re.match(email_pattern, from_email):
+                raise ValueError('Invalid from_email format')
+            if not re.match(email_pattern, to_email):
+                raise ValueError('Invalid to_email format')
+
+            # Validate port
+            try:
+                port = int(v.get('smtp_port', 587))
+                if port < 1 or port > 65535:
+                    raise ValueError('SMTP port must be between 1 and 65535')
+                v['smtp_port'] = port  # Ensure it's stored as int
+            except (ValueError, TypeError):
+                raise ValueError('SMTP port must be a valid number')
+
+        # Validate all string values in config for security
+        for key, value in v.items():
+            if isinstance(value, str):
+                # Prevent code injection in configuration values
+                dangerous_patterns = ['<script', 'javascript:', 'data:', 'vbscript:', '<?php', '<%']
+                value_lower = value.lower()
+                if any(pattern in value_lower for pattern in dangerous_patterns):
+                    raise ValueError(f'Configuration value for {key} contains potentially dangerous content')
+
+                # Limit string length to prevent DoS
+                if len(value) > 1000:
+                    raise ValueError(f'Configuration value for {key} is too long (max 1000 characters)')
+
+        return v
+
+
+class NotificationChannelUpdate(BaseModel):
+    """Request model for updating notification channels"""
+    name: Optional[str] = None
+    config: Optional[Dict[str, Any]] = None
+    enabled: Optional[bool] = None
+
+
+class EventLogFilter(BaseModel):
+    """Request model for filtering events"""
+    category: Optional[str] = None
+    event_type: Optional[str] = None
+    severity: Optional[str] = None
+    host_id: Optional[str] = None
+    container_id: Optional[str] = None
+    container_name: Optional[str] = None
+    start_date: Optional[datetime] = None
+    end_date: Optional[datetime] = None
+    correlation_id: Optional[str] = None
+    search: Optional[str] = None
+    limit: int = 100
+    offset: int = 0
\ No newline at end of file
diff --git a/dockmon/backend/models/settings_models.py b/dockmon/backend/models/settings_models.py
new file mode 100644
index 0000000..f552bfd
--- /dev/null
+++ b/dockmon/backend/models/settings_models.py
@@ -0,0 +1,85 @@
+"""
+Settings and Configuration Models for DockMon
+Pydantic models for global settings, alerts, and notifications
+"""
+
+import uuid
+from datetime import datetime
+from typing import Optional, List
+
+from pydantic import BaseModel, Field, validator
+
+
+from typing import Optional, List
+
+class GlobalSettings(BaseModel):
+    """Global monitoring settings"""
+    max_retries: int = Field(3, ge=0, le=10)  # 0-10 retries
+    retry_delay: int = Field(30, ge=5, le=300)  # 5 seconds to 5 minutes
+    default_auto_restart: bool = False
+    polling_interval: int = Field(2, ge=1, le=300)  # 1 second to 5 minutes
+    connection_timeout: int = Field(10, ge=1, le=60)  # 1-60 seconds
+    alert_template: Optional[str] = Field(None, max_length=2000)  # Global notification template
+    blackout_windows: Optional[List[dict]] = None  # Blackout windows configuration
+    timezone_offset: int = Field(0, ge=-720, le=720)  # Timezone offset in minutes from UTC (-12h to +12h)
+    show_host_stats: bool = Field(True)  # Show host statistics graphs on dashboard
+    show_container_stats: bool = Field(True)  # Show container statistics on dashboard
+
+    @validator('max_retries')
+    def validate_max_retries(cls, v):
+        """Validate retry count to prevent resource exhaustion"""
+        if v < 0:
+            raise ValueError('Max retries cannot be negative')
+        if v > 10:
+            raise ValueError('Max retries cannot exceed 10 to prevent resource exhaustion')
+        return v
+
+    @validator('retry_delay')
+    def validate_retry_delay(cls, v):
+        """Validate retry delay to prevent system overload"""
+        if v < 5:
+            raise ValueError('Retry delay must be at least 5 seconds')
+        if v > 300:
+            raise ValueError('Retry delay cannot exceed 300 seconds')
+        return v
+
+    @validator('polling_interval')
+    def validate_polling_interval(cls, v):
+        """Validate polling interval to prevent system overload"""
+        if v < 1:
+            raise ValueError('Polling interval must be at least 1 second')
+        if v > 300:
+            raise ValueError('Polling interval cannot exceed 300 seconds')
+        return v
+
+    @validator('connection_timeout')
+    def validate_connection_timeout(cls, v):
+        """Validate connection timeout"""
+        if v < 1:
+            raise ValueError('Connection timeout must be at least 1 second')
+        if v > 60:
+            raise ValueError('Connection timeout cannot exceed 60 seconds')
+        return v
+
+
+class AlertRule(BaseModel):
+    """Alert rule configuration"""
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    name: str
+    trigger_events: Optional[List[str]] = None
+    trigger_states: Optional[List[str]] = None
+    notification_channels: List[int]
+    cooldown_minutes: int = 15
+    enabled: bool = True
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+    last_triggered: Optional[datetime] = None
+
+
+class NotificationSettings(BaseModel):
+    """Notification channel settings"""
+    telegram_token: Optional[str] = None
+    telegram_chat_id: Optional[str] = None
+    discord_webhook: Optional[str] = None
+    pushover_app_token: Optional[str] = None
+    pushover_user_key: Optional[str] = None
\ No newline at end of file
diff --git a/dockmon/backend/notifications.py b/dockmon/backend/notifications.py
new file mode 100644
index 0000000..e0f9baf
--- /dev/null
+++ b/dockmon/backend/notifications.py
@@ -0,0 +1,1141 @@
+"""
+Notification service for DockMon
+Handles sending alerts via Discord, Telegram, and Pushover
+"""
+
+import asyncio
+import json
+import logging
+import re
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass
+import requests
+import httpx
+from database import DatabaseManager, NotificationChannel, AlertRuleDB
+from event_logger import EventSeverity, EventCategory, EventType
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class AlertEvent:
+    """Container alert event"""
+    container_id: str
+    container_name: str
+    host_id: str
+    host_name: str
+    old_state: str
+    new_state: str
+    timestamp: datetime
+    image: str
+    triggered_by: str = "monitor"
+
+@dataclass
+class DockerEventAlert:
+    """Docker event that might trigger an alert"""
+    container_id: str
+    container_name: str
+    host_id: str
+    event_type: str  # e.g., "die", "oom", "kill", "health_status:unhealthy"
+    timestamp: datetime
+    attributes: Dict[str, Any] = None  # Additional event attributes
+    exit_code: Optional[int] = None
+
+class NotificationService:
+    """Handles all notification channels and alert processing"""
+
+    def __init__(self, db: DatabaseManager, event_logger=None):
+        self.db = db
+        self.event_logger = event_logger
+        self.http_client = httpx.AsyncClient(timeout=30.0)
+        self._last_alerts: Dict[str, datetime] = {}  # For cooldown tracking
+        self._last_container_state: Dict[str, str] = {}  # Track last known state per container
+        self._suppressed_alerts: List[AlertEvent] = []  # Track alerts suppressed during blackout windows
+        self.MAX_SUPPRESSED_ALERTS = 1000  # Prevent unbounded memory growth
+        self.MAX_COOLDOWN_ENTRIES = 10000  # Prevent unbounded cooldown dictionary
+        self.COOLDOWN_MAX_AGE_DAYS = 7  # Remove cooldown entries older than 7 days
+
+        # Initialize blackout manager
+        from blackout_manager import BlackoutManager
+        self.blackout_manager = BlackoutManager(db)
+
+    def _cleanup_old_cooldowns(self) -> None:
+        """Clean up old cooldown entries to prevent memory leak"""
+        now = datetime.now()
+        max_age = timedelta(days=self.COOLDOWN_MAX_AGE_DAYS)
+
+        # Remove entries older than max age
+        keys_to_remove = [
+            key for key, timestamp in self._last_alerts.items()
+            if now - timestamp > max_age
+        ]
+
+        for key in keys_to_remove:
+            del self._last_alerts[key]
+
+        if keys_to_remove:
+            logger.info(f"Cleaned up {len(keys_to_remove)} old cooldown entries")
+
+        # If still over limit, remove oldest entries
+        if len(self._last_alerts) > self.MAX_COOLDOWN_ENTRIES:
+            # Sort by timestamp and keep only the newest MAX_COOLDOWN_ENTRIES
+            sorted_alerts = sorted(self._last_alerts.items(), key=lambda x: x[1], reverse=True)
+            self._last_alerts = dict(sorted_alerts[:self.MAX_COOLDOWN_ENTRIES])
+            logger.warning(f"Cooldown dictionary exceeded limit, truncated to {self.MAX_COOLDOWN_ENTRIES} entries")
+
+    def _get_host_name(self, event) -> str:
+        """Get host name from event, handling both AlertEvent and DockerEventAlert types"""
+        if hasattr(event, 'host_name'):
+            return event.host_name
+        elif hasattr(event, 'host_id'):
+            # Look up host name from host_id in database
+            try:
+                host = self.db.get_host(event.host_id)
+                return host.name if host else 'Unknown Host'
+            except Exception:
+                return 'Unknown Host'
+        else:
+            return 'Unknown Host'
+
+    async def process_docker_event(self, event: DockerEventAlert) -> bool:
+        """Process a Docker event and send alerts if rules match"""
+        try:
+            # Get matching alert rules for this event
+            rules = self.db.get_alert_rules(enabled_only=True)
+            matching_rules = []
+
+            host_name = self._get_host_name(event)
+            logger.info(f"Processing Docker event: {event.event_type} for container '{event.container_name}' on host '{host_name}'")
+
+            for rule in rules:
+                # Check if rule has event triggers
+                if not rule.trigger_events:
+                    continue
+
+                # Check if this event type matches any triggers
+                event_matches = False
+                for trigger in rule.trigger_events:
+                    # Handle special event mappings
+                    if trigger == "die-nonzero" and event.event_type == "die" and event.exit_code and event.exit_code != 0:
+                        event_matches = True
+                        break
+                    elif trigger == "die-zero" and event.event_type == "die" and event.exit_code == 0:
+                        event_matches = True
+                        break
+                    elif trigger == event.event_type:
+                        event_matches = True
+                        break
+                    # Handle health status events
+                    elif trigger.startswith("health_status:") and event.event_type == "health_status":
+                        health_status = event.attributes.get("health_status") if event.attributes else None
+                        if health_status and trigger == f"health_status:{health_status}":
+                            event_matches = True
+                            break
+
+                if not event_matches:
+                    continue
+
+                # Check if this container+host matches the rule
+                # First check if rule has specific container+host pairs
+                if hasattr(rule, 'containers') and rule.containers:
+                    # Use specific container+host pairs
+                    matches = False
+                    for container in rule.containers:
+                        if (container.host_id == event.host_id and
+                            container.container_name == event.container_name):
+                            matches = True
+                            break
+
+                    if not matches:
+                        continue
+                else:
+                    continue
+
+                logger.info(f"Docker event matches rule {rule.id}: {rule.name}")
+                matching_rules.append(rule)
+
+            if not matching_rules:
+                logger.debug(f"No rules match Docker event {event.event_type} for container '{event.container_name}' on host '{host_name}'")
+                return False
+
+            # Send notifications for matching rules
+            success_count = 0
+            for rule in matching_rules:
+                logger.info(f"Processing Docker event rule '{rule.name}' for container '{event.container_name}' on host '{host_name}'")
+
+                # Check cooldown
+                container_key = f"{event.host_id}:{event.container_id}"
+                cooldown_key = f"event:{rule.id}:{container_key}:{event.event_type}"
+
+                # Periodic cleanup of old cooldown entries (every ~100 alerts)
+                if len(self._last_alerts) % 100 == 0:
+                    self._cleanup_old_cooldowns()
+
+                # Check cooldown
+                if cooldown_key in self._last_alerts:
+                    time_since = datetime.now() - self._last_alerts[cooldown_key]
+                    if time_since.total_seconds() < rule.cooldown_minutes * 60:
+                        logger.info(f"Skipping Docker event alert for container '{event.container_name}' on host '{host_name}' (rule: {rule.name}) due to cooldown")
+                        continue
+
+                # Check if we're in a blackout window
+                is_blackout, window_name = self.blackout_manager.is_in_blackout_window()
+                logger.info(f"Blackout check for Docker event (rule: {rule.name}): is_blackout={is_blackout}, window_name={window_name}")
+                if is_blackout:
+                    logger.info(f"Docker event alert suppressed during blackout window '{window_name}' for container '{event.container_name}' on host '{host_name}' (rule: {rule.name})")
+                    continue
+
+                # Send notification
+                logger.info(f"Sending Docker event notification for rule '{rule.name}'")
+                if await self._send_event_notification(rule, event):
+                    success_count += 1
+                    self._last_alerts[cooldown_key] = datetime.now()
+
+                    # Update rule's last triggered time
+                    self.db.update_alert_rule(rule.id, {
+                        'last_triggered': datetime.now()
+                    })
+
+            return success_count > 0
+
+        except Exception as e:
+            host_name = self._get_host_name(event)
+            logger.error(f"Error processing Docker event for container '{event.container_name}' on host '{host_name}': {e}")
+            return False
+
+    async def _send_event_notification(self, rule: AlertRuleDB, event: DockerEventAlert) -> bool:
+        """Send notifications for a Docker event"""
+        try:
+            # Get host name
+            host_name = event.host_id
+            try:
+                with self.db.get_session() as session:
+                    from database import DockerHostDB
+                    host = session.query(DockerHostDB).filter_by(id=event.host_id).first()
+                    if host:
+                        host_name = host.name
+            except Exception as e:
+                logger.warning(f"Could not get host name: {e}")
+
+            # Get container image
+            image = event.attributes.get('image', 'Unknown') if event.attributes else 'Unknown'
+
+            # Format event type description
+            if event.event_type == "die":
+                if event.exit_code == 0:
+                    event_desc = "Container stopped normally (exit code 0)"
+                    emoji = "🟢"
+                else:
+                    event_desc = f"Container died with exit code {event.exit_code}"
+                    emoji = "🔴"
+            elif event.event_type == "oom":
+                event_desc = "Container killed due to Out Of Memory (OOM)"
+                emoji = "💀"
+            elif event.event_type == "kill":
+                event_desc = "Container was killed"
+                emoji = "⚠️"
+            elif event.event_type.startswith("health_status"):
+                status = event.attributes.get("health_status", "unknown") if event.attributes else "unknown"
+                if status == "unhealthy":
+                    event_desc = "Container is UNHEALTHY"
+                    emoji = "🏥"
+                elif status == "healthy":
+                    event_desc = "Container is healthy again"
+                    emoji = "✅"
+                else:
+                    event_desc = f"Health status: {status}"
+                    emoji = "🏥"
+            elif event.event_type == "restart-loop":
+                event_desc = "Container is in a restart loop"
+                emoji = "🔄"
+            else:
+                event_desc = f"Docker event: {event.event_type}"
+                emoji = "📢"
+
+            # Format structured message like state alerts
+            message = f"""{emoji} **DockMon Alert**
+
+**Container:** `{event.container_name}`
+**Host:** {host_name}
+**Event:** {event_desc}
+**Image:** {image}
+**Time:** {event.timestamp.strftime('%Y-%m-%d %H:%M:%S')}
+**Rule:** {rule.name}"""
+
+            # Get notification channels
+            channels = self.db.get_notification_channels_by_ids(rule.notification_channels)
+
+            success_count = 0
+            total_channels = len(channels)
+
+            for channel in channels:
+                if channel.enabled:
+                    try:
+                        if channel.type == 'telegram':
+                            await self._send_telegram(channel.config, message)
+                            success_count += 1
+                        elif channel.type == 'discord':
+                            await self._send_discord(channel.config, message)
+                            success_count += 1
+                        elif channel.type == 'pushover':
+                            await self._send_pushover(channel.config, message, event)
+                            success_count += 1
+                        elif channel.type == 'slack':
+                            await self._send_slack(channel.config, message, event)
+                            success_count += 1
+                        elif channel.type == 'gotify':
+                            await self._send_gotify(channel.config, message, event)
+                            success_count += 1
+                        elif channel.type == 'smtp':
+                            await self._send_smtp(channel.config, message, event)
+                            success_count += 1
+                        host_name = self._get_host_name(event)
+                        logger.info(f"Event notification sent via {channel.type} for container '{event.container_name}' on host '{host_name}'")
+                    except Exception as e:
+                        logger.error(f"Failed to send {channel.type} notification: {e}")
+
+            host_name = self._get_host_name(event)
+            logger.info(f"Event alert sent to {success_count}/{total_channels} channels for container '{event.container_name}' on host '{host_name}'")
+            return success_count > 0
+
+        except Exception as e:
+            logger.error(f"Error sending event notification: {e}")
+            return False
+
+    async def send_alert(self, event: AlertEvent) -> bool:
+        """Process an alert event and send notifications"""
+        try:
+            # Get matching alert rules
+            alert_rules = await self._get_matching_rules(event)
+
+            host_name = self._get_host_name(event)
+            logger.info(f"Found {len(alert_rules) if alert_rules else 0} matching alert rules for container '{event.container_name}' on host '{host_name}'")
+
+            if not alert_rules:
+                logger.warning(f"No alert rules match container '{event.container_name}' on host '{host_name}' (state: {event.old_state} → {event.new_state})")
+                return False
+
+            success_count = 0
+            total_rules = len(alert_rules)
+
+            # Check if we're in a blackout window
+            is_blackout, window_name = self.blackout_manager.is_in_blackout_window()
+            if is_blackout:
+                logger.info(f"Suppressed {len(alert_rules)} alerts during blackout window '{window_name}' for container '{event.container_name}' on host '{host_name}'")
+                # Track this alert for later (with cap to prevent memory leak)
+                if len(self._suppressed_alerts) < self.MAX_SUPPRESSED_ALERTS:
+                    self._suppressed_alerts.append(event)
+                else:
+                    logger.warning(f"Suppressed alerts queue full ({self.MAX_SUPPRESSED_ALERTS}), dropping oldest")
+                    self._suppressed_alerts.pop(0)
+                    self._suppressed_alerts.append(event)
+
+                # Log suppression event
+                if self.event_logger:
+                    rule_names = ", ".join([rule.name for rule in alert_rules[:3]])  # First 3 rules
+                    if len(alert_rules) > 3:
+                        rule_names += f" (+{len(alert_rules) - 3} more)"
+
+                    from event_logger import EventContext
+                    context = EventContext(
+                        host_id=event.host_id,
+                        host_name=host_name,
+                        container_id=event.container_id,
+                        container_name=event.container_name
+                    )
+
+                    self.event_logger.log_event(
+                        title=f"Alert Suppressed: {event.container_name}",
+                        message=f"Alert suppressed during blackout window '{window_name}'. State change: {event.old_state} → {event.new_state}. Matching rules: {rule_names}",
+                        category=EventCategory.ALERT,
+                        event_type=EventType.RULE_TRIGGERED,
+                        severity=EventSeverity.WARNING,
+                        context=context,
+                        old_state=event.old_state,
+                        new_state=event.new_state,
+                        details={"blackout_window": window_name, "rules_count": len(alert_rules), "suppressed": True}
+                    )
+
+                return False
+
+            # Process each matching rule
+            triggered_rules = []
+            for rule in alert_rules:
+                if await self._should_send_alert(rule, event):
+                    if await self._send_rule_notifications(rule, event):
+                        success_count += 1
+                        triggered_rules.append(rule.name)
+                        # Update last triggered time for this container + rule combination
+                        container_key = f"{event.host_id}:{event.container_id}"
+                        cooldown_key = f"{rule.id}:{container_key}"
+                        self._last_alerts[cooldown_key] = datetime.now()
+
+                        # Also update the rule's global last_triggered for backward compatibility
+                        self.db.update_alert_rule(rule.id, {
+                            'last_triggered': datetime.now()
+                        })
+
+            # Log the event to new event system
+            if success_count > 0 and self.event_logger:
+                rule_names = ", ".join(triggered_rules[:3])  # First 3 rules
+                if len(triggered_rules) > 3:
+                    rule_names += f" (+{len(triggered_rules) - 3} more)"
+
+                # Determine severity based on state
+                severity = EventSeverity.CRITICAL if event.new_state in ['exited', 'dead'] else EventSeverity.ERROR
+
+                from event_logger import EventContext
+                context = EventContext(
+                    host_id=event.host_id,
+                    host_name=host_name,
+                    container_id=event.container_id,
+                    container_name=event.container_name
+                )
+
+                self.event_logger.log_event(
+                    category=EventCategory.ALERT,
+                    event_type=EventType.RULE_TRIGGERED,
+                    title=f"Alert Triggered: {event.container_name}",
+                    message=f"{success_count} alert rule(s) triggered for container state change: {event.old_state} → {event.new_state}. Rules: {rule_names}",
+                    severity=severity,
+                    context=context,
+                    old_state=event.old_state,
+                    new_state=event.new_state,
+                    details={"rules_triggered": triggered_rules, "rules_count": success_count, "total_rules": total_rules}
+                )
+
+            return success_count > 0
+
+        except Exception as e:
+            host_name = self._get_host_name(event)
+            logger.error(f"Error processing alert for container '{event.container_name}' on host '{host_name}': {e}")
+            return False
+
+    async def _get_matching_rules(self, event: AlertEvent) -> List[AlertRuleDB]:
+        """Get alert rules that match the container and state change"""
+        rules = self.db.get_alert_rules(enabled_only=True)
+        matching_rules = []
+
+        host_name = self._get_host_name(event)
+        logger.info(f"Checking {len(rules)} alert rules for container '{event.container_name}' on host '{host_name}' (state: {event.old_state} → {event.new_state})")
+
+        for rule in rules:
+            container_info = f"{len(rule.containers)} container+host pairs" if hasattr(rule, 'containers') and rule.containers else "no containers"
+            logger.debug(f"Rule {rule.id}: name='{rule.name}', containers={container_info}, states={rule.trigger_states}, events={rule.trigger_events}")
+
+            # Check if this container+host matches the rule
+            # First check if rule has specific container+host pairs
+            if hasattr(rule, 'containers') and rule.containers:
+                # Use specific container+host pairs
+                matches = False
+                for container in rule.containers:
+                    if (container.host_id == event.host_id and
+                        container.container_name == event.container_name):
+                        matches = True
+                        break
+
+                if not matches:
+                    logger.debug(f"Rule {rule.id} skipped: no matching container+host pair")
+                    continue
+            else:
+                # No containers specified = monitor all containers
+                logger.debug(f"Rule {rule.id} matches: monitoring all containers")
+
+            # Check if new state triggers alert (only if trigger_states is defined)
+            if rule.trigger_states and event.new_state not in rule.trigger_states:
+                logger.debug(f"Rule {rule.id} skipped: state '{event.new_state}' not in triggers {rule.trigger_states}")
+                continue
+            elif not rule.trigger_states:
+                # This rule only has event triggers, not state triggers, skip for state changes
+                logger.debug(f"Rule {rule.id} skipped: no state triggers defined (events only)")
+                continue
+
+            logger.debug(f"Rule {rule.id} MATCHES!")
+            matching_rules.append(rule)
+
+        return matching_rules
+
+    async def _should_send_alert(self, rule: AlertRuleDB, event: AlertEvent) -> bool:
+        """Check if alert should be sent based on cooldown per container"""
+        container_key = f"{event.host_id}:{event.container_id}"
+        cooldown_key = f"{rule.id}:{container_key}"
+
+        # Check if container recovered (went to a non-alert state) since last alert
+        # Use old_state from the event, not our tracked state!
+        host_name = self._get_host_name(event)
+        logger.debug(f"Alert check for container '{event.container_name}' on host '{host_name}': {event.old_state} → {event.new_state}")
+
+        # If container was in a "good" state (running) and now in "bad" state (exited),
+        # this is a new incident - reset cooldown
+        good_states = ['running', 'created']
+        if rule.trigger_states and event.old_state in good_states and event.new_state in rule.trigger_states:
+            logger.info(f"Alert allowed for container '{event.container_name}' on host '{host_name}': Container recovered ({event.old_state}) then failed ({event.new_state}) - new incident detected")
+            # Remove the cooldown for this container
+            if cooldown_key in self._last_alerts:
+                del self._last_alerts[cooldown_key]
+            return True
+
+        if cooldown_key not in self._last_alerts:
+            logger.debug(f"Alert allowed: No previous alert for this container")
+            return True
+
+        # Check cooldown period
+        time_since_last = datetime.now() - self._last_alerts[cooldown_key]
+        cooldown_minutes = rule.cooldown_minutes or 15
+        cooldown_seconds = cooldown_minutes * 60
+
+        if time_since_last.total_seconds() >= cooldown_seconds:
+            logger.debug(f"Alert allowed: Cooldown period exceeded ({time_since_last.total_seconds():.1f}s > {cooldown_seconds}s)")
+            return True
+        else:
+            host_name = self._get_host_name(event)
+            logger.info(f"Alert blocked for container '{event.container_name}' on host '{host_name}': Still in cooldown ({cooldown_seconds - time_since_last.total_seconds():.1f}s remaining)")
+            return False
+
+    async def _send_rule_notifications(self, rule: AlertRuleDB, event: AlertEvent) -> bool:
+        """Send notifications for a specific rule"""
+        if not rule.notification_channels:
+            return False
+
+        channels = self.db.get_notification_channels(enabled_only=True)
+        channel_map = {str(ch.id): ch for ch in channels}
+
+        success_count = 0
+        total_channels = len(rule.notification_channels)
+
+        # Send to each configured channel
+        for channel_id in rule.notification_channels:
+            if str(channel_id) in channel_map:
+                channel = channel_map[str(channel_id)]
+                try:
+                    if await self._send_to_channel(channel, event, rule):
+                        success_count += 1
+                except Exception as e:
+                    logger.error(f"Failed to send to channel {channel.name}: {e}")
+
+        host_name = self._get_host_name(event)
+        logger.info(f"Alert sent to {success_count}/{total_channels} channels for container '{event.container_name}' on host '{host_name}'")
+        return success_count > 0
+
+    async def _send_to_channel(self, channel: NotificationChannel,
+                             event: AlertEvent, rule: AlertRuleDB) -> bool:
+        """Send notification to a specific channel"""
+        # Get global template from settings
+        settings = self.db.get_settings()
+        template = getattr(settings, 'alert_template', None) if settings else None
+
+        # Use global template or default
+        if not template:
+            template = self._get_default_template(channel.type)
+
+        message = self._format_message(event, rule, template)
+
+        if channel.type == "telegram":
+            return await self._send_telegram(channel.config, message)
+        elif channel.type == "discord":
+            return await self._send_discord(channel.config, message)
+        elif channel.type == "pushover":
+            return await self._send_pushover(channel.config, message, event)
+        elif channel.type == "slack":
+            return await self._send_slack(channel.config, message, event)
+        elif channel.type == "gotify":
+            return await self._send_gotify(channel.config, message, event)
+        elif channel.type == "smtp":
+            return await self._send_smtp(channel.config, message, event)
+        else:
+            logger.warning(f"Unknown notification channel type: {channel.type}")
+            return False
+
+    def _get_default_template(self, channel_type: str = None) -> str:
+        """Get default template for channel type"""
+        # Default template with variables - ends with separator for visual distinction
+        default = """🚨 **DockMon Alert**
+
+**Container:** `{CONTAINER_NAME}`
+**Host:** {HOST_NAME}
+**State Change:** `{OLD_STATE}` → `{NEW_STATE}`
+**Image:** {IMAGE}
+**Time:** {TIMESTAMP}
+**Rule:** {RULE_NAME}
+───────────────────────"""
+
+        # Channel-specific defaults (can be customized per platform)
+        templates = {
+            'slack': default,
+            'discord': default,
+            'telegram': default,
+            'pushover': """DockMon Alert
+Container: {CONTAINER_NAME}
+Host: {HOST_NAME}
+State: {OLD_STATE} → {NEW_STATE}
+Image: {IMAGE}
+Time: {TIMESTAMP}
+Rule: {RULE_NAME}
+---"""
+        }
+
+        return templates.get(channel_type, default)
+
+    def _format_message(self, event: AlertEvent, rule: AlertRuleDB, template: str = None) -> str:
+        """Format alert message using template with variable substitution"""
+        # Use provided template or default
+        if not template:
+            template = self._get_default_template()
+
+        # Get timezone offset from settings
+        settings = self.db.get_settings()
+        timezone_offset = getattr(settings, 'timezone_offset', 0) if settings else 0
+
+        # Convert timestamp to local timezone
+        local_timestamp = event.timestamp + timedelta(minutes=timezone_offset)
+
+        # Prepare variables for substitution
+        host_name = self._get_host_name(event)
+        variables = {
+            '{CONTAINER_NAME}': event.container_name,
+            '{CONTAINER_ID}': event.container_id[:12],  # Short ID
+            '{HOST_NAME}': host_name,
+            '{HOST_ID}': event.host_id,
+            '{OLD_STATE}': event.old_state,
+            '{NEW_STATE}': event.new_state,
+            '{IMAGE}': event.image,
+            '{TIMESTAMP}': local_timestamp.strftime('%Y-%m-%d %H:%M:%S'),
+            '{TIME}': local_timestamp.strftime('%H:%M:%S'),
+            '{DATE}': local_timestamp.strftime('%Y-%m-%d'),
+            '{RULE_NAME}': rule.name,
+            '{RULE_ID}': str(rule.id),
+            '{TRIGGERED_BY}': event.triggered_by,
+        }
+
+        # Handle optional Docker event attributes
+        if hasattr(event, 'event_type'):
+            variables['{EVENT_TYPE}'] = event.event_type
+            if hasattr(event, 'exit_code') and event.exit_code is not None:
+                variables['{EXIT_CODE}'] = str(event.exit_code)
+
+        # Replace all variables in template
+        message = template
+        for var, value in variables.items():
+            message = message.replace(var, value)
+
+        # Clean up any unused variables (remove them)
+        import re
+        message = re.sub(r'\{[A-Z_]+\}', '', message)
+
+        return message
+
+    async def _send_telegram(self, config: Dict[str, Any], message: str) -> bool:
+        """Send notification via Telegram"""
+        try:
+            # Support both 'token' and 'bot_token' for backward compatibility
+            token = config.get('token') or config.get('bot_token')
+            chat_id = config.get('chat_id')
+
+            if not token or not chat_id:
+                logger.error(f"Telegram config missing token or chat_id")
+                return False
+
+            url = f"https://api.telegram.org/bot{token}/sendMessage"
+            payload = {
+                'chat_id': chat_id,
+                'text': message,
+                'parse_mode': 'Markdown'
+            }
+
+            response = await self.http_client.post(url, json=payload)
+            response.raise_for_status()
+
+            logger.info("Telegram notification sent successfully")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to send Telegram notification: {e}")
+            return False
+
+    async def _send_discord(self, config: Dict[str, Any], message: str) -> bool:
+        """Send notification via Discord webhook"""
+        try:
+            webhook_url = config.get('webhook_url')
+
+            if not webhook_url:
+                logger.error("Discord config missing webhook_url")
+                return False
+
+            # Convert markdown to Discord format
+            discord_message = message.replace('`', '`').replace('**', '**')
+
+            payload = {
+                'content': discord_message,
+                'username': 'DockMon',
+                'avatar_url': 'https://cdn-icons-png.flaticon.com/512/919/919853.png'
+            }
+
+            response = await self.http_client.post(webhook_url, json=payload)
+            response.raise_for_status()
+
+            logger.info("Discord notification sent successfully")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to send Discord notification: {e}")
+            return False
+
+    async def _send_pushover(self, config: Dict[str, Any], message: str,
+                           event) -> bool:
+        """Send notification via Pushover"""
+        try:
+            app_token = config.get('app_token')
+            user_key = config.get('user_key')
+
+            if not app_token or not user_key:
+                logger.error("Pushover config missing app_token or user_key")
+                return False
+
+            # Strip markdown for Pushover
+            plain_message = re.sub(r'\*\*(.*?)\*\*', r'\1', message)  # Bold
+            plain_message = re.sub(r'`(.*?)`', r'\1', plain_message)   # Code
+            plain_message = re.sub(r'🚨', '', plain_message)  # Remove alert emoji
+
+            # Determine priority based on event type
+            priority = 0  # Normal
+            # Handle both AlertEvent and DockerEventAlert
+            if hasattr(event, 'new_state') and event.new_state in ['exited', 'dead']:
+                priority = 1  # High priority for state failures
+            elif hasattr(event, 'event_type') and event.event_type in ['die', 'oom', 'kill']:
+                priority = 1  # High priority for critical Docker events
+
+            payload = {
+                'token': app_token,
+                'user': user_key,
+                'message': plain_message,
+                'title': f"DockMon: {event.container_name}",
+                'priority': priority,
+                'url': config.get('url', ''),
+                'url_title': 'Open DockMon'
+            }
+
+            response = await self.http_client.post(
+                'https://api.pushover.net/1/messages.json',
+                data=payload
+            )
+            response.raise_for_status()
+
+            logger.info("Pushover notification sent successfully")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to send Pushover notification: {e}")
+            return False
+
+    async def _send_slack(self, config: Dict[str, Any], message: str, event: AlertEvent) -> bool:
+        """Send notification via Slack webhook"""
+        try:
+            webhook_url = config.get('webhook_url')
+
+            if not webhook_url:
+                logger.error("Slack config missing webhook_url")
+                return False
+
+            # Convert markdown to Slack format
+            # Slack uses mrkdwn format which is similar to markdown but with some differences
+            slack_message = message.replace('**', '*')  # Bold in Slack is single asterisk
+            slack_message = slack_message.replace('`', '`')  # Code blocks remain the same
+
+            # Determine color based on event type
+            color = "#ff0000"  # Default red for critical
+            if hasattr(event, 'new_state'):
+                if event.new_state == 'running':
+                    color = "#00ff00"  # Green for running
+                elif event.new_state in ['stopped', 'paused']:
+                    color = "#ffaa00"  # Orange for stopped/paused
+            elif hasattr(event, 'event_type'):
+                if event.event_type in ['start', 'unpause']:
+                    color = "#00ff00"  # Green for recovery events
+                elif event.event_type in ['stop', 'pause']:
+                    color = "#ffaa00"  # Orange for controlled stops
+
+            # Create rich Slack message with attachments
+            payload = {
+                'attachments': [{
+                    'color': color,
+                    'fallback': slack_message,
+                    'title': '🚨 DockMon Alert',
+                    'text': slack_message,
+                    'mrkdwn_in': ['text'],
+                    'footer': 'DockMon',
+                    'footer_icon': 'https://raw.githubusercontent.com/docker/compose/v2/logo.png',
+                    'ts': int(event.timestamp.timestamp())
+                }]
+            }
+
+            response = await self.http_client.post(webhook_url, json=payload)
+            response.raise_for_status()
+
+            logger.info("Slack notification sent successfully")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to send Slack notification: {e}")
+            return False
+
+    async def _send_gotify(self, config: Dict[str, Any], message: str, event) -> bool:
+        """Send notification via Gotify"""
+        try:
+            # Validate required config fields
+            server_url = config.get('server_url', '').strip()
+            app_token = config.get('app_token', '').strip()
+
+            if not server_url:
+                logger.error("Gotify config missing server_url")
+                return False
+
+            if not app_token:
+                logger.error("Gotify config missing app_token")
+                return False
+
+            # Validate server URL format
+            if not server_url.startswith(('http://', 'https://')):
+                logger.error(f"Gotify server_url must start with http:// or https://: {server_url}")
+                return False
+
+            # Strip markdown formatting for plain text
+            plain_message = re.sub(r'\*\*(.*?)\*\*', r'\1', message)
+            plain_message = re.sub(r'`(.*?)`', r'\1', plain_message)
+            plain_message = re.sub(r'[🚨🔴🟢💀⚠️🏥✅🔄📢]', '', plain_message)  # Remove emojis
+
+            # Determine priority (0-10, default 5)
+            priority = 5
+            if hasattr(event, 'new_state') and event.new_state in ['exited', 'dead']:
+                priority = 8  # High priority for critical states
+            elif hasattr(event, 'event_type') and event.event_type in ['die', 'oom', 'kill']:
+                priority = 8  # High priority for critical events
+
+            # Build URL with proper path handling
+            base_url = server_url.rstrip('/')
+            url = f"{base_url}/message?token={app_token}"
+
+            # Create payload
+            payload = {
+                'title': f"DockMon: {event.container_name}",
+                'message': plain_message,
+                'priority': priority
+            }
+
+            # Send request with timeout
+            response = await self.http_client.post(url, json=payload)
+            response.raise_for_status()
+
+            logger.info("Gotify notification sent successfully")
+            return True
+
+        except httpx.HTTPStatusError as e:
+            logger.error(f"Gotify HTTP error {e.response.status_code}: {e}")
+            return False
+        except httpx.RequestError as e:
+            logger.error(f"Gotify connection error: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"Failed to send Gotify notification: {e}")
+            return False
+
+    async def _send_smtp(self, config: Dict[str, Any], message: str, event) -> bool:
+        """Send notification via SMTP (Email)"""
+        try:
+            # Import SMTP libraries (only when needed to avoid dependency issues)
+            try:
+                import aiosmtplib
+                from email.mime.text import MIMEText
+                from email.mime.multipart import MIMEMultipart
+            except ImportError:
+                logger.error("SMTP support requires 'aiosmtplib' package. Install with: pip install aiosmtplib")
+                return False
+
+            # Validate required config fields
+            smtp_host = config.get('smtp_host', '').strip()
+            smtp_port = config.get('smtp_port', 587)
+            smtp_user = config.get('smtp_user', '').strip()
+            smtp_password = config.get('smtp_password', '').strip()
+            from_email = config.get('from_email', '').strip()
+            to_email = config.get('to_email', '').strip()
+            use_tls = config.get('use_tls', True)
+
+            # Validate all required fields
+            if not smtp_host:
+                logger.error("SMTP config missing smtp_host")
+                return False
+            if not smtp_user:
+                logger.error("SMTP config missing smtp_user")
+                return False
+            if not smtp_password:
+                logger.error("SMTP config missing smtp_password")
+                return False
+            if not from_email:
+                logger.error("SMTP config missing from_email")
+                return False
+            if not to_email:
+                logger.error("SMTP config missing to_email")
+                return False
+
+            # Validate port range
+            try:
+                smtp_port = int(smtp_port)
+                if smtp_port < 1 or smtp_port > 65535:
+                    logger.error(f"SMTP port must be between 1-65535: {smtp_port}")
+                    return False
+            except (ValueError, TypeError):
+                logger.error(f"Invalid SMTP port: {smtp_port}")
+                return False
+
+            # Validate email format (basic check)
+            email_pattern = re.compile(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$')
+            if not email_pattern.match(from_email):
+                logger.error(f"Invalid from_email format: {from_email}")
+                return False
+            if not email_pattern.match(to_email):
+                logger.error(f"Invalid to_email format: {to_email}")
+                return False
+
+            # Create multipart email
+            msg = MIMEMultipart('alternative')
+            msg['Subject'] = f"DockMon Alert: {event.container_name}"
+            msg['From'] = from_email
+            msg['To'] = to_email
+
+            # Plain text version (strip markdown and emojis)
+            plain_text = re.sub(r'\*\*(.*?)\*\*', r'\1', message)
+            plain_text = re.sub(r'`(.*?)`', r'\1', plain_text)
+            plain_text = re.sub(r'[🚨🔴🟢💀⚠️🏥✅🔄📢]', '', plain_text)
+
+            # HTML version with basic styling (light theme for better email compatibility)
+            html_text = message.replace('\n', '<br>')
+            html_text = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', html_text)
+            html_text = re.sub(r'`(.*?)`', r'<code style="background:#f5f5f5;color:#333;padding:2px 6px;border-radius:3px;font-family:monospace;">\1</code>', html_text)
+
+            html_body = f"""<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+</head>
+<body style="margin:0;padding:0;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,'Helvetica Neue',Arial,sans-serif;background:#f9f9f9;color:#333;">
+    <div style="max-width:600px;margin:20px auto;background:#ffffff;padding:24px;border-radius:8px;border:1px solid #e0e0e0;box-shadow:0 1px 3px rgba(0,0,0,0.1);">
+        <div style="line-height:1.6;font-size:14px;">
+            {html_text}
+        </div>
+        <div style="margin-top:20px;padding-top:20px;border-top:1px solid #e0e0e0;font-size:12px;color:#666;">
+            Sent by DockMon Container Monitoring
+        </div>
+    </div>
+</body>
+</html>"""
+
+            # Attach both versions
+            part1 = MIMEText(plain_text, 'plain', 'utf-8')
+            part2 = MIMEText(html_body, 'html', 'utf-8')
+            msg.attach(part1)
+            msg.attach(part2)
+
+            # Send email with proper connection handling
+            # Port 587 uses STARTTLS, port 465 uses direct TLS/SSL
+            if smtp_port == 587:
+                smtp_kwargs = {
+                    'hostname': smtp_host,
+                    'port': smtp_port,
+                    'start_tls': use_tls,  # Use STARTTLS for port 587
+                    'timeout': 30
+                }
+            elif smtp_port == 465:
+                smtp_kwargs = {
+                    'hostname': smtp_host,
+                    'port': smtp_port,
+                    'use_tls': use_tls,  # Use direct TLS for port 465
+                    'timeout': 30
+                }
+            else:
+                # Other ports (like 25) - no encryption by default unless use_tls is True
+                smtp_kwargs = {
+                    'hostname': smtp_host,
+                    'port': smtp_port,
+                    'start_tls': use_tls if use_tls else False,
+                    'timeout': 30
+                }
+
+            async with aiosmtplib.SMTP(**smtp_kwargs) as smtp:
+                await smtp.login(smtp_user, smtp_password)
+                await smtp.send_message(msg)
+
+            logger.info(f"SMTP notification sent successfully to {to_email}")
+            return True
+
+        except aiosmtplib.SMTPAuthenticationError as e:
+            logger.error(f"SMTP authentication failed: {e}")
+            return False
+        except aiosmtplib.SMTPException as e:
+            logger.error(f"SMTP error: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"Failed to send SMTP notification: {e}")
+            return False
+
+    async def test_channel(self, channel_id: int) -> Dict[str, Any]:
+        """Test a notification channel"""
+        try:
+            channel = self.db.get_notification_channels(enabled_only=False)
+            channel = next((ch for ch in channel if ch.id == channel_id), None)
+
+            if not channel:
+                return {'success': False, 'error': 'Channel not found'}
+
+            # Create test event
+            test_event = AlertEvent(
+                container_id='test_container',
+                container_name='test-container',
+                host_id='test_host',
+                host_name='Test Host',
+                old_state='running',
+                new_state='stopped',
+                timestamp=datetime.now(),
+                image='nginx:latest',
+                triggered_by='test'
+            )
+
+            # Create test rule
+            test_rule = type('TestRule', (), {
+                'id': 'test_rule',
+                'name': 'Test Notification',
+                'notification_channels': [channel_id]
+            })()
+
+            success = await self._send_to_channel(channel, test_event, test_rule)
+
+            return {
+                'success': success,
+                'channel_name': channel.name,
+                'channel_type': channel.type
+            }
+
+        except Exception as e:
+            logger.error(f"Error testing channel {channel_id}: {e}")
+            return {'success': False, 'error': str(e)}
+
+    async def process_suppressed_alerts(self, monitor):
+        """Process alerts that were suppressed during blackout windows
+
+        Args:
+            monitor: The DockerMonitor instance (reused, not created)
+        """
+        if not self._suppressed_alerts:
+            logger.info("No suppressed alerts to process")
+            return
+
+        logger.info(f"Processing {len(self._suppressed_alerts)} suppressed alerts from blackout windows")
+
+        alerts_to_send = []
+
+        # For each suppressed alert, check if the container is still in that problematic state
+        for alert in self._suppressed_alerts:
+            container_key = f"{alert.host_id}:{alert.container_id}"
+
+            # Get current state of this container
+            try:
+                client = monitor.clients.get(alert.host_id)
+                if not client:
+                    logger.debug(f"No client found for host {alert.host_id}")
+                    continue
+
+                try:
+                    container = client.containers.get(alert.container_id)
+                    current_state = container.status
+
+                    # If container is still in the problematic state from the alert, send it
+                    if current_state == alert.new_state:
+                        logger.info(f"Container {alert.container_name} still in '{current_state}' state - sending suppressed alert")
+                        alerts_to_send.append(alert)
+                    else:
+                        logger.info(f"Container {alert.container_name} recovered from '{alert.new_state}' to '{current_state}' during blackout window - skipping alert")
+
+                except Exception as e:
+                    # Container might have been removed
+                    logger.debug(f"Could not check container {alert.container_id}: {e}")
+
+            except Exception as e:
+                logger.error(f"Error checking suppressed alert for {alert.container_name}: {e}")
+
+        # Clear the suppressed alerts list
+        self._suppressed_alerts.clear()
+
+        # Send alerts for containers still in problematic states
+        for alert in alerts_to_send:
+            try:
+                await self.send_alert(alert)
+            except Exception as e:
+                logger.error(f"Failed to send suppressed alert for {alert.container_name}: {e}")
+
+        logger.info(f"Sent {len(alerts_to_send)} of {len(self._suppressed_alerts) + len(alerts_to_send)} suppressed alerts")
+
+    async def close(self):
+        """Clean up resources"""
+        await self.http_client.aclose()
+
+    async def __aenter__(self):
+        """Context manager entry"""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit - ensure cleanup"""
+        await self.close()
+        return False
+
+class AlertProcessor:
+    """Processes container state changes and triggers alerts"""
+
+    def __init__(self, notification_service: NotificationService):
+        self.notification_service = notification_service
+        self._container_states: Dict[str, str] = {}  # Track previous states
+
+    async def process_container_update(self, containers: List[Any], hosts: Dict[str, Any]):
+        """Process container updates and trigger alerts for state changes"""
+        for container in containers:
+            container_key = f"{container.host_id}:{container.id}"
+            current_state = container.status
+            previous_state = self._container_states.get(container_key)
+
+            # Skip if no state change
+            if previous_state == current_state:
+                continue
+
+            # Update tracked state
+            self._container_states[container_key] = current_state
+
+            # IMPORTANT: Update the notification service's state tracking too
+            # This ensures recovery states are tracked even when they don't trigger alerts
+            self.notification_service._last_container_state[container_key] = current_state
+            logger.debug(f"State transition for {container.name}: {previous_state} → {current_state}")
+
+            # Skip if this is the first time we see this container
+            if previous_state is None:
+                continue
+
+            # Create alert event
+            host = hosts.get(container.host_id)
+            host_name = host.name if host else 'Unknown Host'
+
+            alert_event = AlertEvent(
+                container_id=container.id,
+                container_name=container.name,
+                host_id=container.host_id,
+                host_name=host_name,
+                old_state=previous_state,
+                new_state=current_state,
+                timestamp=datetime.now(),
+                image=container.image,
+                triggered_by='monitor'
+            )
+
+            # Send alert
+            logger.debug(f"Processing state change for {container.name}: {previous_state} → {current_state}")
+            await self.notification_service.send_alert(alert_event)
+
+    def get_container_states(self) -> Dict[str, str]:
+        """Get current container states for debugging"""
+        return self._container_states.copy()
\ No newline at end of file
diff --git a/dockmon/backend/realtime.py b/dockmon/backend/realtime.py
new file mode 100644
index 0000000..bbbd5b9
--- /dev/null
+++ b/dockmon/backend/realtime.py
@@ -0,0 +1,206 @@
+"""
+Real-time monitoring and WebSocket management for DockMon
+Provides live container updates and stats streaming
+Note: Docker event monitoring is now handled by the Go service
+"""
+
+import asyncio
+import json
+import logging
+from datetime import datetime
+from typing import Dict, List, Set, Optional, Any
+from dataclasses import dataclass, asdict
+import docker
+from docker.models.containers import Container as DockerContainer
+
+logger = logging.getLogger(__name__)
+
+# Custom JSON encoder for datetime objects
+class DateTimeEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        return super().default(obj)
+
+@dataclass
+class ContainerStats:
+    """Real-time container statistics (used for WebSocket stats streaming)"""
+    container_id: str
+    cpu_percent: float
+    memory_mb: float
+    memory_percent: float
+    memory_limit_mb: float
+    network_rx_mb: float
+    network_tx_mb: float
+    block_read_mb: float
+    block_write_mb: float
+    pids: int
+    timestamp: str
+
+class RealtimeMonitor:
+    """Manages real-time container monitoring and events"""
+
+    def __init__(self):
+        self.stats_subscribers: Dict[str, Set[Any]] = {}  # container_id -> set of websockets
+        self.event_subscribers: Set[Any] = set()  # websockets listening to all events
+        self.monitoring_tasks: Dict[str, asyncio.Task] = {}
+
+    async def subscribe_to_stats(self, websocket: Any, container_id: str):
+        """Subscribe a websocket to container stats"""
+        if container_id not in self.stats_subscribers:
+            self.stats_subscribers[container_id] = set()
+
+        self.stats_subscribers[container_id].add(websocket)
+        logger.info(f"WebSocket subscribed to stats for container {container_id}")
+
+    async def unsubscribe_from_stats(self, websocket: Any, container_id: str):
+        """Unsubscribe a websocket from container stats"""
+        if container_id in self.stats_subscribers:
+            self.stats_subscribers[container_id].discard(websocket)
+            if not self.stats_subscribers[container_id]:
+                del self.stats_subscribers[container_id]
+                # Stop monitoring if no subscribers
+                if container_id in self.monitoring_tasks:
+                    self.monitoring_tasks[container_id].cancel()
+                    del self.monitoring_tasks[container_id]
+
+    async def subscribe_to_events(self, websocket: Any):
+        """Subscribe a websocket to all Docker events"""
+        self.event_subscribers.add(websocket)
+        logger.info("WebSocket subscribed to Docker events")
+
+    async def unsubscribe_from_events(self, websocket: Any):
+        """Unsubscribe a websocket from Docker events"""
+        self.event_subscribers.discard(websocket)
+
+    async def start_container_stats_stream(self, client: docker.DockerClient,
+                                          container_id: str, interval: int = 2):
+        """Start streaming stats for a specific container"""
+        if container_id in self.monitoring_tasks:
+            return  # Already monitoring
+
+        task = asyncio.create_task(
+            self._monitor_container_stats(client, container_id, interval)
+        )
+        self.monitoring_tasks[container_id] = task
+
+    async def _monitor_container_stats(self, client: docker.DockerClient,
+                                      container_id: str, interval: int):
+        """Monitor and broadcast container stats"""
+        logger.info(f"Starting stats monitoring for container {container_id}")
+
+        while container_id in self.stats_subscribers and self.stats_subscribers[container_id]:
+            try:
+                container = client.containers.get(container_id)
+
+                if container.status != 'running':
+                    await asyncio.sleep(interval)
+                    continue
+
+                stats = self._calculate_container_stats(container)
+
+                # Broadcast to all subscribers
+                dead_sockets = []
+                for websocket in self.stats_subscribers.get(container_id, []):
+                    try:
+                        await websocket.send_text(json.dumps({
+                            "type": "container_stats",
+                            "data": asdict(stats)
+                        }, cls=DateTimeEncoder))
+                    except Exception as e:
+                        logger.error(f"Error sending stats to websocket: {e}")
+                        dead_sockets.append(websocket)
+
+                # Clean up dead sockets
+                for ws in dead_sockets:
+                    await self.unsubscribe_from_stats(ws, container_id)
+
+            except docker.errors.NotFound:
+                logger.warning(f"Container {container_id} not found")
+                break
+            except Exception as e:
+                logger.error(f"Error monitoring container {container_id}: {e}")
+
+            await asyncio.sleep(interval)
+
+        logger.info(f"Stopped stats monitoring for container {container_id}")
+
+    def _calculate_container_stats(self, container: DockerContainer) -> ContainerStats:
+        """Calculate container statistics from Docker stats API"""
+        try:
+            stats = container.stats(stream=False)
+
+            # CPU calculation
+            cpu_delta = stats["cpu_stats"]["cpu_usage"]["total_usage"] - \
+                       stats["precpu_stats"]["cpu_usage"]["total_usage"]
+            system_cpu_delta = stats["cpu_stats"]["system_cpu_usage"] - \
+                              stats["precpu_stats"]["system_cpu_usage"]
+            number_cpus = len(stats["cpu_stats"]["cpu_usage"].get("percpu_usage", [1]))
+
+            cpu_percent = 0.0
+            if system_cpu_delta > 0.0 and cpu_delta > 0.0:
+                cpu_percent = (cpu_delta / system_cpu_delta) * number_cpus * 100.0
+
+            # Memory calculation
+            mem_stats = stats.get("memory_stats", {})
+            mem_usage = mem_stats.get("usage", 0)
+            mem_limit = mem_stats.get("limit", 1)
+            mem_percent = (mem_usage / mem_limit) * 100 if mem_limit > 0 else 0
+
+            # Network I/O
+            networks = stats.get("networks", {})
+            net_rx = sum(net.get("rx_bytes", 0) for net in networks.values())
+            net_tx = sum(net.get("tx_bytes", 0) for net in networks.values())
+
+            # Block I/O
+            blkio = stats.get("blkio_stats", {})
+            io_read = 0
+            io_write = 0
+
+            if "io_service_bytes_recursive" in blkio:
+                for item in blkio["io_service_bytes_recursive"]:
+                    if item["op"] == "Read":
+                        io_read += item["value"]
+                    elif item["op"] == "Write":
+                        io_write += item["value"]
+
+            # Process count
+            pids = stats.get("pids_stats", {}).get("current", 0)
+
+            return ContainerStats(
+                container_id=container.id[:12],
+                cpu_percent=round(cpu_percent, 2),
+                memory_mb=round(mem_usage / (1024 * 1024), 2),
+                memory_percent=round(mem_percent, 2),
+                memory_limit_mb=round(mem_limit / (1024 * 1024), 2),
+                network_rx_mb=round(net_rx / (1024 * 1024), 2),
+                network_tx_mb=round(net_tx / (1024 * 1024), 2),
+                block_read_mb=round(io_read / (1024 * 1024), 2),
+                block_write_mb=round(io_write / (1024 * 1024), 2),
+                pids=pids,
+                timestamp=datetime.now().isoformat()
+            )
+        except Exception as e:
+            logger.error(f"Error calculating stats: {e}")
+            return ContainerStats(
+                container_id=container.id[:12],
+                cpu_percent=0,
+                memory_mb=0,
+                memory_percent=0,
+                memory_limit_mb=0,
+                network_rx_mb=0,
+                network_tx_mb=0,
+                block_read_mb=0,
+                block_write_mb=0,
+                pids=0,
+                timestamp=datetime.now().isoformat()
+            )
+
+    def stop_all_monitoring(self):
+        """Stop all monitoring tasks"""
+        logger.info("Stopping all monitoring tasks")
+
+        # Cancel stats monitoring
+        for task in self.monitoring_tasks.values():
+            task.cancel()
+        self.monitoring_tasks.clear()
\ No newline at end of file
diff --git a/dockmon/backend/requirements.txt b/dockmon/backend/requirements.txt
new file mode 100644
index 0000000..41fdab2
--- /dev/null
+++ b/dockmon/backend/requirements.txt
@@ -0,0 +1,14 @@
+fastapi==0.115.6
+uvicorn[standard]==0.34.0
+docker==7.1.0
+pydantic==2.10.6
+python-multipart==0.0.20
+websockets==14.1
+aiofiles==24.1.0
+aiohttp==3.11.11
+httpx==0.28.1
+python-dotenv==1.0.1
+sqlalchemy==2.0.36
+requests==2.32.3
+bcrypt==4.2.1
+aiosmtplib==3.0.2
diff --git a/dockmon/backend/reset_password.py b/dockmon/backend/reset_password.py
new file mode 100755
index 0000000..2ce00f2
--- /dev/null
+++ b/dockmon/backend/reset_password.py
@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+DockMon Password Reset Tool
+Command-line utility to reset user passwords
+"""
+
+import sys
+import argparse
+import getpass
+from config.paths import DATABASE_PATH
+from database import DatabaseManager
+
+
+def main():
+    parser = argparse.ArgumentParser(description="DockMon Password Reset Tool")
+    parser.add_argument("username", nargs="?", help="Username to reset password for")
+    parser.add_argument("--password", "-p", help="New password (if not provided, will be generated)")
+    parser.add_argument("--interactive", "-i", action="store_true", help="Interactive mode - prompts for password")
+    parser.add_argument("--list", "-l", action="store_true", help="List all usernames")
+
+    args = parser.parse_args()
+
+    # Initialize database with centralized path
+    db = DatabaseManager(DATABASE_PATH)
+
+    # List users if requested
+    if args.list:
+        users = db.list_users()
+        if users:
+            print("Available users:")
+            for user in users:
+                print(f"  - {user}")
+        else:
+            print("No users found in database.")
+        sys.exit(0)
+
+    # Get username - if not provided, check if there's only one user or default to 'admin'
+    username = args.username
+    if not username:
+        users = db.list_users()
+        if not users:
+            print("Error: No users found in database.")
+            sys.exit(1)
+        elif len(users) == 1:
+            username = users[0]
+            print(f"Using username: {username}")
+        elif 'admin' in users:
+            username = 'admin'
+            print(f"Using default username: admin")
+        else:
+            print("Error: Multiple users exist. Please specify a username.")
+            print("Available users:")
+            for user in users:
+                print(f"  - {user}")
+            print("\nUsage: python reset_password.py <username>")
+            sys.exit(1)
+
+    new_password = args.password
+
+    # Interactive mode - prompt for password
+    if args.interactive:
+        while True:
+            password1 = getpass.getpass("Enter new password (min 8 characters): ")
+            if len(password1) < 8:
+                print("Password must be at least 8 characters long.")
+                continue
+
+            password2 = getpass.getpass("Confirm new password: ")
+            if password1 != password2:
+                print("Passwords do not match. Please try again.")
+                continue
+
+            new_password = password1
+            break
+
+    # Reset the password
+    result = db.reset_user_password(username, new_password)
+
+    if result is None:
+        print(f"Error: User '{username}' not found.")
+        sys.exit(1)
+
+    print(f"✓ Password reset successfully for user: {username}")
+
+    if not args.password and not args.interactive:
+        # Password was auto-generated
+        print(f"New password: {result}")
+        print("\n⚠️  Please save this password securely. You will be prompted to change it on next login.")
+    else:
+        print("\n✓ You can now login with your new password.")
+        print("   The user will be prompted to change the password on next login.")
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\nOperation cancelled.")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
\ No newline at end of file
diff --git a/dockmon/backend/security/__init__.py b/dockmon/backend/security/__init__.py
new file mode 100644
index 0000000..802d72f
--- /dev/null
+++ b/dockmon/backend/security/__init__.py
@@ -0,0 +1 @@
+# Security module for DockMon
\ No newline at end of file
diff --git a/dockmon/backend/security/audit.py b/dockmon/backend/security/audit.py
new file mode 100644
index 0000000..cab0ef3
--- /dev/null
+++ b/dockmon/backend/security/audit.py
@@ -0,0 +1,312 @@
+"""
+Security Audit Logging System for DockMon
+Tracks all security-relevant events for incident response
+"""
+
+import json
+import logging
+import os
+from logging.handlers import RotatingFileHandler
+from typing import Dict, List, Optional
+
+
+class SecurityAuditLogger:
+    """
+    Comprehensive security audit logging system
+    Tracks all security-relevant events for incident response
+    """
+    def __init__(self, event_logger=None):
+        self.security_logger = logging.getLogger('security_audit')
+        self.event_logger = event_logger
+
+        # Create separate log file for security events in persistent volume
+        from config.paths import DATA_DIR
+        log_dir = os.path.join(DATA_DIR, 'logs')
+        os.makedirs(log_dir, mode=0o700, exist_ok=True)
+
+        # Rotating file handler for security audit logs
+        # Max 10MB per file, keep 14 backups (total max 150MB with current + 14 backups)
+        security_handler = RotatingFileHandler(
+            os.path.join(log_dir, 'security_audit.log'),
+            maxBytes=10*1024*1024,  # 10MB
+            backupCount=14,  # Keep 14 old files
+            encoding='utf-8'
+        )
+        security_handler.setLevel(logging.INFO)
+
+        # Structured logging format for security events
+        security_formatter = logging.Formatter(
+            '%(asctime)s - SECURITY - %(levelname)s - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S UTC'
+        )
+        security_handler.setFormatter(security_formatter)
+        self.security_logger.addHandler(security_handler)
+        self.security_logger.setLevel(logging.INFO)
+        self.security_logger.propagate = False  # Don't propagate to root logger
+
+    def set_event_logger(self, event_logger):
+        """Set the event logger instance for logging to Event Viewer"""
+        self.event_logger = event_logger
+
+    def _log_security_event(self, level: str, event_type: str, client_ip: str,
+                           endpoint: str = None, user_agent: str = None,
+                           details: dict = None, risk_level: str = "LOW"):
+        """Internal method to log structured security events"""
+        log_data = {
+            "event_type": event_type,
+            "client_ip": client_ip,
+            "endpoint": endpoint,
+            "user_agent": user_agent or "unknown",
+            "risk_level": risk_level,
+            "details": details or {}
+        }
+
+        # Convert to JSON for structured logging
+        message = json.dumps(log_data, default=str)
+
+        if level.upper() == "ERROR":
+            self.security_logger.error(message)
+        elif level.upper() == "WARNING":
+            self.security_logger.warning(message)
+        else:
+            self.security_logger.info(message)
+
+    def log_authentication_attempt(self, client_ip: str, success: bool, endpoint: str, user_agent: str = None):
+        """Log authentication attempts (both success and failure)"""
+        event_type = "AUTH_SUCCESS" if success else "AUTH_FAILURE"
+        risk_level = "LOW" if success else "MEDIUM"
+        level = "INFO" if success else "WARNING"
+
+        self._log_security_event(
+            level=level,
+            event_type=event_type,
+            client_ip=client_ip,
+            endpoint=endpoint,
+            user_agent=user_agent,
+            risk_level=risk_level
+        )
+
+    def log_rate_limit_violation(self, client_ip: str, endpoint: str, violations: int, banned: bool = False):
+        """Log rate limiting violations and bans"""
+        event_type = "RATE_LIMIT_BAN" if banned else "RATE_LIMIT_VIOLATION"
+        risk_level = "HIGH" if banned else "MEDIUM"
+
+        self._log_security_event(
+            level="ERROR" if banned else "WARNING",
+            event_type=event_type,
+            client_ip=client_ip,
+            endpoint=endpoint,
+            details={"violation_count": violations, "banned": banned},
+            risk_level=risk_level
+        )
+
+    def log_input_validation_failure(self, client_ip: str, endpoint: str, field: str,
+                                   attempted_value: str, user_agent: str = None):
+        """Log input validation failures (potential attacks)"""
+        self._log_security_event(
+            level="WARNING",
+            event_type="INPUT_VALIDATION_FAILURE",
+            client_ip=client_ip,
+            endpoint=endpoint,
+            user_agent=user_agent,
+            details={
+                "field": field,
+                "attempted_value": attempted_value[:100] if attempted_value else None,  # Limit log size
+                "attack_indicators": self._detect_attack_patterns(attempted_value)
+            },
+            risk_level="HIGH"
+        )
+
+    def log_cors_violation(self, client_ip: str, origin: str, endpoint: str):
+        """Log CORS policy violations"""
+        self._log_security_event(
+            level="WARNING",
+            event_type="CORS_VIOLATION",
+            client_ip=client_ip,
+            endpoint=endpoint,
+            details={"blocked_origin": origin},
+            risk_level="MEDIUM"
+        )
+
+    def log_privileged_action(self, client_ip: str, action: str, target: str, success: bool, user_agent: str = None):
+        """Log privileged actions (host management, container control, etc.)"""
+        event_type = f"PRIVILEGED_ACTION_{action.upper()}"
+        risk_level = "MEDIUM" if success else "HIGH"
+
+        self._log_security_event(
+            level="INFO" if success else "ERROR",
+            event_type=event_type,
+            client_ip=client_ip,
+            user_agent=user_agent,
+            details={
+                "action": action,
+                "target": target,
+                "success": success
+            },
+            risk_level=risk_level
+        )
+
+    def log_suspicious_activity(self, client_ip: str, activity_type: str, details: dict, endpoint: str = None):
+        """Log suspicious activities that don't fit other categories"""
+        self._log_security_event(
+            level="ERROR",
+            event_type="SUSPICIOUS_ACTIVITY",
+            client_ip=client_ip,
+            endpoint=endpoint,
+            details={
+                "activity_type": activity_type,
+                **details
+            },
+            risk_level="HIGH"
+        )
+
+    def _detect_attack_patterns(self, value: str) -> list:
+        """Detect common attack patterns in input"""
+        if not value:
+            return []
+
+        patterns = []
+        value_lower = value.lower()
+
+        # XSS patterns
+        if any(pattern in value_lower for pattern in ['<script', 'javascript:', 'onerror=', 'onload=']):
+            patterns.append("XSS")
+
+        # SQL injection patterns
+        if any(pattern in value_lower for pattern in [' or ', ' union ', ' select ', "'; drop", '1=1']):
+            patterns.append("SQL_INJECTION")
+
+        # Command injection patterns
+        if any(pattern in value_lower for pattern in ['; rm ', '| cat ', '&& curl', 'wget ', '`whoami`']):
+            patterns.append("COMMAND_INJECTION")
+
+        # Path traversal patterns
+        if any(pattern in value for pattern in ['../../../', '..\\..\\', '/etc/passwd', 'c:\\windows']):
+            patterns.append("PATH_TRAVERSAL")
+
+        # SSRF patterns
+        if any(pattern in value_lower for pattern in ['localhost', '127.0.0.1', '169.254.169.254']):
+            patterns.append("SSRF")
+
+        return patterns
+
+    def get_security_stats(self, hours: int = 24) -> dict:
+        """Get security statistics for the last N hours"""
+        # This is a simplified version - in production you'd query actual log files
+        return {
+            "timeframe_hours": hours,
+            "total_security_events": "N/A - check logs/security_audit.log",
+            "log_location": "logs/security_audit.log",
+            "note": "Parse JSON logs for detailed statistics"
+        }
+
+    def log_login_success(self, client_ip: str, user_agent: str, session_id: str):
+        """Log successful login attempt"""
+        self._log_security_event(
+            level="INFO",
+            event_type="LOGIN_SUCCESS",
+            client_ip=client_ip,
+            user_agent=user_agent,
+            details={"session_id": session_id[:8] + "..."},  # Don't log full session ID
+            risk_level="LOW"
+        )
+
+    def log_login_failure(self, client_ip: str, user_agent: str, reason: str):
+        """Log failed login attempt"""
+        self._log_security_event(
+            level="WARNING",
+            event_type="LOGIN_FAILURE",
+            client_ip=client_ip,
+            user_agent=user_agent,
+            details={"reason": reason},
+            risk_level="MEDIUM"
+        )
+
+    def log_session_expired(self, client_ip: str, session_id: str):
+        """Log session expiration"""
+        self._log_security_event(
+            level="INFO",
+            event_type="SESSION_EXPIRED",
+            client_ip=client_ip,
+            details={"session_id": session_id[:8] + "..."},
+            risk_level="LOW"
+        )
+
+    def log_session_hijack_attempt(self, original_ip: str, attempted_ip: str, session_id: str):
+        """Log potential session hijacking attempt"""
+        self._log_security_event(
+            level="ERROR",
+            event_type="SESSION_HIJACK_ATTEMPT",
+            client_ip=attempted_ip,
+            details={
+                "original_ip": original_ip,
+                "attempted_ip": attempted_ip,
+                "session_id": session_id[:8] + "..."
+            },
+            risk_level="HIGH"
+        )
+
+    def log_authentication_failure(self, client_ip: str, user_agent: str, reason: str):
+        """Log authentication failure"""
+        self._log_security_event(
+            level="WARNING",
+            event_type="AUTH_FAILURE",
+            client_ip=client_ip,
+            user_agent=user_agent,
+            details={"reason": reason},
+            risk_level="MEDIUM"
+        )
+
+    def log_password_change(self, client_ip: str, user_agent: str, username: str):
+        """Log password change event"""
+        self._log_security_event(
+            level="INFO",
+            event_type="PASSWORD_CHANGE",
+            client_ip=client_ip,
+            user_agent=user_agent,
+            details={"username": username, "message": f"Password changed for user: {username}"},
+            risk_level="LOW"
+        )
+
+        # Also log to event logger for Event Viewer
+        if self.event_logger:
+            from event_logger import EventCategory, EventType, EventSeverity
+            self.event_logger.log_event(
+                category=EventCategory.USER,
+                event_type=EventType.CONFIG_CHANGED,
+                title="Password Changed",
+                message=f"User '{username}' changed their password from IP: {client_ip}",
+                severity=EventSeverity.INFO,
+                details={"username": username, "client_ip": client_ip, "user_agent": user_agent}
+            )
+
+    def log_username_change(self, client_ip: str, user_agent: str, old_username: str, new_username: str):
+        """Log username change event"""
+        self._log_security_event(
+            level="INFO",
+            event_type="USERNAME_CHANGE",
+            client_ip=client_ip,
+            user_agent=user_agent,
+            details={
+                "old_username": old_username,
+                "new_username": new_username,
+                "message": f"Username changed from {old_username} to {new_username}"
+            },
+            risk_level="LOW"
+        )
+
+        # Also log to event logger for Event Viewer
+        if self.event_logger:
+            from event_logger import EventCategory, EventType, EventSeverity
+            self.event_logger.log_event(
+                category=EventCategory.USER,
+                event_type=EventType.CONFIG_CHANGED,
+                title="Username Changed",
+                message=f"Username changed from '{old_username}' to '{new_username}' from IP: {client_ip}",
+                severity=EventSeverity.INFO,
+                details={"old_username": old_username, "new_username": new_username, "client_ip": client_ip, "user_agent": user_agent}
+            )
+
+
+# Global security audit logger instance
+security_audit = SecurityAuditLogger()
\ No newline at end of file
diff --git a/dockmon/backend/security/rate_limiting.py b/dockmon/backend/security/rate_limiting.py
new file mode 100644
index 0000000..84039fb
--- /dev/null
+++ b/dockmon/backend/security/rate_limiting.py
@@ -0,0 +1,185 @@
+"""
+Rate Limiting System for DockMon
+Provides protection against abuse and DoS attacks using token bucket algorithm
+"""
+
+import logging
+import os
+import time
+from collections import defaultdict
+from datetime import datetime
+from typing import Dict, Tuple
+
+from fastapi import Request, HTTPException, status, Depends
+
+from .audit import security_audit
+
+logger = logging.getLogger(__name__)
+
+
+class RateLimiter:
+    """
+    In-memory rate limiter using token bucket algorithm
+    Provides protection against abuse and DoS attacks
+    """
+    def __init__(self):
+        # Start with generous initial tokens to allow immediate bursts
+        # This prevents legitimate users from getting rate limited on first use
+        self.clients = defaultdict(lambda: {"tokens": 100, "last_update": time.time(), "violations": 0})
+
+        # Get rate limits from environment or use production-friendly defaults
+        self.limits = {
+            # endpoint_pattern: (requests_per_minute, burst_limit, violation_threshold)
+            "default": (
+                int(os.getenv('DOCKMON_RATE_LIMIT_DEFAULT', 120)),
+                int(os.getenv('DOCKMON_RATE_BURST_DEFAULT', 20)),
+                int(os.getenv('DOCKMON_RATE_VIOLATIONS_DEFAULT', 8))
+            ),
+            "auth": (
+                int(os.getenv('DOCKMON_RATE_LIMIT_AUTH', 10)),  # 10 per minute for auth
+                int(os.getenv('DOCKMON_RATE_BURST_AUTH', 5)),   # Lower burst
+                int(os.getenv('DOCKMON_RATE_VIOLATIONS_AUTH', 10))  # More lenient violations
+            ),
+            "hosts": (
+                int(os.getenv('DOCKMON_RATE_LIMIT_HOSTS', 60)),
+                int(os.getenv('DOCKMON_RATE_BURST_HOSTS', 15)),
+                int(os.getenv('DOCKMON_RATE_VIOLATIONS_HOSTS', 8))
+            ),
+            "containers": (
+                int(os.getenv('DOCKMON_RATE_LIMIT_CONTAINERS', 900)),  # Increased for logs polling with multiple containers
+                int(os.getenv('DOCKMON_RATE_BURST_CONTAINERS', 180)),
+                int(os.getenv('DOCKMON_RATE_VIOLATIONS_CONTAINERS', 25))
+            ),
+            "notifications": (
+                int(os.getenv('DOCKMON_RATE_LIMIT_NOTIFICATIONS', 30)),
+                int(os.getenv('DOCKMON_RATE_BURST_NOTIFICATIONS', 10)),
+                int(os.getenv('DOCKMON_RATE_VIOLATIONS_NOTIFICATIONS', 5))
+            ),
+        }
+
+        logger.info(f"Rate limiting configured: Default={self.limits['default'][0]}/min, "
+                   f"Auth={self.limits['auth'][0]}/min, Containers={self.limits['containers'][0]}/min")
+        self.banned_clients = {}  # IP -> ban_until_timestamp
+
+    def _get_limit(self, endpoint: str) -> tuple:
+        """Get rate limit for specific endpoint"""
+        for pattern, limits in self.limits.items():
+            if pattern in endpoint.lower():
+                return limits
+        return self.limits["default"]
+
+    def _cleanup_old_entries(self):
+        """Clean up old entries to prevent memory leaks"""
+        current_time = time.time()
+        # Remove clients not seen for 1 hour
+        cutoff_time = current_time - 3600
+
+        old_clients = [ip for ip, data in self.clients.items()
+                      if data["last_update"] < cutoff_time]
+        for ip in old_clients:
+            del self.clients[ip]
+
+        # Remove expired bans
+        expired_bans = [ip for ip, ban_time in self.banned_clients.items()
+                       if current_time > ban_time]
+        for ip in expired_bans:
+            del self.banned_clients[ip]
+
+    def is_allowed(self, client_ip: str, endpoint: str) -> Tuple[bool, str]:
+        """Check if request is allowed and return (allowed, reason)"""
+        current_time = time.time()
+
+        # Cleanup old entries periodically
+        if current_time % 300 < 1:  # Every 5 minutes
+            self._cleanup_old_entries()
+
+        # Check if client is banned
+        if client_ip in self.banned_clients:
+            if current_time < self.banned_clients[client_ip]:
+                return False, f"IP banned until {datetime.fromtimestamp(self.banned_clients[client_ip]).isoformat()}"
+            else:
+                # Ban expired, remove from banned list
+                del self.banned_clients[client_ip]
+
+        requests_per_minute, burst_limit, violation_threshold = self._get_limit(endpoint)
+        client_data = self.clients[client_ip]
+
+        # Token bucket algorithm with burst support
+        time_passed = current_time - client_data["last_update"]
+        tokens_to_add = (time_passed / 60.0) * requests_per_minute
+        # Allow bursting up to burst_limit tokens
+        client_data["tokens"] = min(burst_limit, client_data["tokens"] + tokens_to_add)
+        client_data["last_update"] = current_time
+
+        # Check if request is allowed
+        if client_data["tokens"] >= 1.0:
+            client_data["tokens"] -= 1.0
+            return True, "OK"
+        else:
+            # Rate limit exceeded
+            client_data["violations"] += 1
+
+            # Check if violations exceed threshold - ban the client
+            if client_data["violations"] >= violation_threshold:
+                ban_duration = 60  # 60 seconds ban (reduced from 15 minutes for better UX)
+                self.banned_clients[client_ip] = current_time + ban_duration
+                logger.warning(f"IP {client_ip} banned for 60 seconds due to {violation_threshold} rate limit violations")
+
+                # Security audit log
+                security_audit.log_rate_limit_violation(
+                    client_ip=client_ip,
+                    endpoint=endpoint,
+                    violations=client_data["violations"],
+                    banned=True
+                )
+
+                return False, f"IP banned for repeated violations"
+
+            # Log rate limit violation
+            security_audit.log_rate_limit_violation(
+                client_ip=client_ip,
+                endpoint=endpoint,
+                violations=client_data["violations"],
+                banned=False
+            )
+
+            return False, f"Rate limit exceeded. Try again in {int(60 - time_passed)} seconds"
+
+    def get_stats(self) -> dict:
+        """Get rate limiter statistics"""
+        return {
+            "active_clients": len(self.clients),
+            "banned_clients": len(self.banned_clients),
+            "total_violations": sum(data["violations"] for data in self.clients.values())
+        }
+
+
+# Global rate limiter instance
+rate_limiter = RateLimiter()
+
+
+def get_rate_limit_dependency(endpoint_type: str = "default"):
+    """Create a dependency for rate limiting specific endpoint types"""
+    def rate_limit_check(request: Request):
+        client_ip = request.client.host
+        endpoint_name = f"{endpoint_type}_{request.url.path}"
+
+        allowed, reason = rate_limiter.is_allowed(client_ip, endpoint_name)
+
+        if not allowed:
+            logger.warning(f"Rate limit exceeded for {client_ip} on {endpoint_name}: {reason}")
+            raise HTTPException(
+                status_code=status.HTTP_429_TOO_MANY_REQUESTS,
+                detail=f"Rate limit exceeded: {reason}",
+                headers={"Retry-After": "60"}
+            )
+        return True
+    return rate_limit_check
+
+
+# Rate limiting dependencies for different endpoint types
+rate_limit_auth = Depends(get_rate_limit_dependency("auth"))
+rate_limit_hosts = Depends(get_rate_limit_dependency("hosts"))
+rate_limit_containers = Depends(get_rate_limit_dependency("containers"))
+rate_limit_notifications = Depends(get_rate_limit_dependency("notifications"))
+rate_limit_default = Depends(get_rate_limit_dependency("default"))
\ No newline at end of file
diff --git a/dockmon/backend/stats_client.py b/dockmon/backend/stats_client.py
new file mode 100644
index 0000000..67c8e60
--- /dev/null
+++ b/dockmon/backend/stats_client.py
@@ -0,0 +1,360 @@
+"""
+Client for communicating with the Go stats service
+"""
+import aiohttp
+import asyncio
+import logging
+import os
+from typing import Dict, Optional, Callable
+import json
+
+logger = logging.getLogger(__name__)
+
+STATS_SERVICE_URL = "http://localhost:8081"
+TOKEN_FILE_PATH = "/tmp/stats-service-token"
+
+
+class StatsServiceClient:
+    """Client for the Go stats service"""
+
+    def __init__(self, base_url: str = STATS_SERVICE_URL):
+        self.base_url = base_url
+        self.session: Optional[aiohttp.ClientSession] = None
+        self.token: Optional[str] = None
+        self.ws_connection: Optional[aiohttp.ClientWebSocketResponse] = None
+        self.ws_task: Optional[asyncio.Task] = None
+        self.event_callback: Optional[Callable] = None
+        self._token_lock = asyncio.Lock()
+
+    async def _load_token(self) -> str:
+        """Load auth token from file (with retry for startup race condition)"""
+        # Fast path: check without lock first (double-check locking pattern)
+        if self.token:
+            return self.token
+
+        async with self._token_lock:
+            # Check again after acquiring lock (another thread may have loaded it)
+            if self.token:
+                return self.token
+
+            # Retry logic: Wait up to 5 seconds for token file to appear
+            for attempt in range(10):
+                try:
+                    if os.path.exists(TOKEN_FILE_PATH):
+                        with open(TOKEN_FILE_PATH, 'r') as f:
+                            self.token = f.read().strip()
+                            logger.info("Loaded stats service auth token")
+                            return self.token
+                except Exception as e:
+                    logger.warning(f"Failed to read token file (attempt {attempt + 1}): {e}")
+
+                await asyncio.sleep(0.5)
+
+            raise RuntimeError(f"Failed to load stats service token from {TOKEN_FILE_PATH}")
+
+    async def _get_session(self) -> aiohttp.ClientSession:
+        """Get or create aiohttp session with auth header"""
+        if self.session is None or self.session.closed:
+            token = await self._load_token()
+            timeout = aiohttp.ClientTimeout(total=5)
+            headers = {"Authorization": f"Bearer {token}"}
+            self.session = aiohttp.ClientSession(timeout=timeout, headers=headers)
+        return self.session
+
+    async def close(self):
+        """Close the HTTP session and WebSocket connection"""
+        # Close WebSocket
+        if self.ws_task:
+            self.ws_task.cancel()
+            try:
+                await self.ws_task
+            except asyncio.CancelledError:
+                pass
+
+        if self.ws_connection and not self.ws_connection.closed:
+            await self.ws_connection.close()
+
+        # Close HTTP session
+        if self.session and not self.session.closed:
+            await self.session.close()
+
+    async def health_check(self) -> bool:
+        """Check if stats service is healthy"""
+        try:
+            session = await self._get_session()
+            async with session.get(f"{self.base_url}/health") as resp:
+                return resp.status == 200
+        except Exception as e:
+            logger.warning(f"Stats service health check failed: {e}")
+            return False
+
+    async def add_docker_host(self, host_id: str, host_address: str, tls_ca: str = None, tls_cert: str = None, tls_key: str = None) -> bool:
+        """Register a Docker host with the stats service"""
+        try:
+            session = await self._get_session()
+            payload = {"host_id": host_id, "host_address": host_address}
+
+            # Add TLS certificates if provided
+            if tls_ca and tls_cert and tls_key:
+                payload["tls_ca_cert"] = tls_ca
+                payload["tls_cert"] = tls_cert
+                payload["tls_key"] = tls_key
+
+            async with session.post(
+                f"{self.base_url}/api/hosts/add",
+                json=payload
+            ) as resp:
+                if resp.status == 200:
+                    logger.info(f"Registered host {host_id} with stats service")
+                    return True
+                else:
+                    logger.error(f"Failed to register host {host_id}: {resp.status}")
+                    return False
+        except Exception as e:
+            logger.error(f"Error registering host {host_id} with stats service: {e}")
+            return False
+
+    async def remove_docker_host(self, host_id: str) -> bool:
+        """Remove a Docker host from the stats service"""
+        try:
+            session = await self._get_session()
+            async with session.post(
+                f"{self.base_url}/api/hosts/remove",
+                json={"host_id": host_id}
+            ) as resp:
+                if resp.status == 200:
+                    logger.info(f"Removed host {host_id[:8]} from stats service")
+                    return True
+                else:
+                    logger.warning(f"Failed to remove host {host_id[:8]} from stats service: {resp.status}")
+                    return False
+        except asyncio.TimeoutError:
+            # Timeout during host removal is expected - Go service closes connections immediately
+            logger.debug(f"Timeout removing host {host_id[:8]} from stats service (expected during cleanup)")
+            return False
+        except Exception as e:
+            logger.warning(f"Error removing host {host_id[:8]} from stats service: {e}")
+            return False
+
+    async def start_container_stream(self, container_id: str, container_name: str, host_id: str) -> bool:
+        """Start stats streaming for a container"""
+        try:
+            session = await self._get_session()
+            async with session.post(
+                f"{self.base_url}/api/streams/start",
+                json={
+                    "container_id": container_id,
+                    "container_name": container_name,
+                    "host_id": host_id
+                }
+            ) as resp:
+                if resp.status == 200:
+                    logger.debug(f"Started stats stream for container {container_id[:12]}")
+                    return True
+                else:
+                    error_text = await resp.text()
+                    logger.warning(f"Failed to start stream for {container_id[:12]}: HTTP {resp.status} - {error_text}")
+                    return False
+        except asyncio.TimeoutError:
+            # Timeout errors are expected during host cleanup - log at debug level
+            logger.debug(f"Timeout starting stream for {container_id[:12]} (expected during host cleanup)")
+            return False
+        except Exception as e:
+            logger.warning(f"Error starting stream for {container_id[:12]}: {type(e).__name__}: {str(e)}", exc_info=True)
+            return False
+
+    async def stop_container_stream(self, container_id: str, host_id: str) -> bool:
+        """Stop stats streaming for a container"""
+        try:
+            session = await self._get_session()
+            async with session.post(
+                f"{self.base_url}/api/streams/stop",
+                json={"container_id": container_id, "host_id": host_id}
+            ) as resp:
+                if resp.status == 200:
+                    logger.debug(f"Stopped stats stream for container {container_id[:12]}")
+                    return True
+                else:
+                    logger.warning(f"Failed to stop stream for {container_id[:12]}: {resp.status}")
+                    return False
+        except asyncio.TimeoutError:
+            # Timeout errors are expected when bulk stopping streams - log at debug level
+            logger.debug(f"Timeout stopping stream for {container_id[:12]} (expected during bulk stop)")
+            return False
+        except Exception as e:
+            logger.warning(f"Error stopping stream for {container_id[:12]}: {e}")
+            return False
+
+    async def get_host_stats(self) -> Dict[str, Dict]:
+        """
+        Get aggregated stats for all hosts
+        Returns: {host_id: {cpu_percent, memory_percent, ...}}
+        """
+        try:
+            session = await self._get_session()
+            async with session.get(f"{self.base_url}/api/stats/hosts") as resp:
+                if resp.status == 200:
+                    stats = await resp.json()
+                    logger.debug(f"Received stats for {len(stats)} hosts from stats service")
+                    return stats
+                else:
+                    logger.error(f"Failed to get host stats: {resp.status}")
+                    return {}
+        except Exception as e:
+            logger.error(f"Error getting host stats from stats service: {e}")
+            return {}
+
+    async def get_container_stats(self) -> Dict[str, Dict]:
+        """
+        Get stats for all containers (for debugging)
+        Returns: {container_id: {cpu_percent, memory_percent, ...}}
+        """
+        try:
+            session = await self._get_session()
+            async with session.get(f"{self.base_url}/api/stats/containers") as resp:
+                if resp.status == 200:
+                    return await resp.json()
+                else:
+                    logger.error(f"Failed to get container stats: {resp.status}")
+                    return {}
+        except Exception as e:
+            logger.error(f"Error getting container stats from stats service: {e}")
+            return {}
+
+    # Event service methods
+
+    async def add_event_host(self, host_id: str, host_address: str, tls_ca: str = None, tls_cert: str = None, tls_key: str = None) -> bool:
+        """Register a Docker host with the event monitoring service"""
+        try:
+            session = await self._get_session()
+            payload = {"host_id": host_id, "host_address": host_address}
+
+            # Add TLS certificates if provided
+            if tls_ca and tls_cert and tls_key:
+                payload["tls_ca_cert"] = tls_ca
+                payload["tls_cert"] = tls_cert
+                payload["tls_key"] = tls_key
+
+            async with session.post(
+                f"{self.base_url}/api/events/hosts/add",
+                json=payload
+            ) as resp:
+                if resp.status == 200:
+                    logger.info(f"Registered host {host_id[:8]} with event service")
+                    return True
+                else:
+                    logger.error(f"Failed to register host {host_id[:8]} with event service: {resp.status}")
+                    return False
+        except Exception as e:
+            logger.error(f"Error registering host {host_id[:8]} with event service: {e}")
+            return False
+
+    async def remove_event_host(self, host_id: str) -> bool:
+        """Remove a Docker host from event monitoring"""
+        try:
+            session = await self._get_session()
+            async with session.post(
+                f"{self.base_url}/api/events/hosts/remove",
+                json={"host_id": host_id}
+            ) as resp:
+                if resp.status == 200:
+                    logger.info(f"Removed host {host_id[:8]} from event service")
+                    return True
+                else:
+                    logger.warning(f"Failed to remove host {host_id[:8]} from event service: {resp.status}")
+                    return False
+        except Exception as e:
+            logger.warning(f"Error removing host {host_id[:8]} from event service: {e}")
+            return False
+
+    async def get_recent_events(self, host_id: Optional[str] = None) -> list:
+        """Get recent cached events"""
+        try:
+            session = await self._get_session()
+            url = f"{self.base_url}/api/events/recent"
+            if host_id:
+                url += f"?host_id={host_id}"
+
+            async with session.get(url) as resp:
+                if resp.status == 200:
+                    return await resp.json()
+                else:
+                    logger.error(f"Failed to get recent events: {resp.status}")
+                    return []
+        except Exception as e:
+            logger.error(f"Error getting recent events: {e}")
+            return []
+
+    async def connect_event_stream(self, event_callback: Callable):
+        """
+        Connect to the WebSocket event stream
+
+        Args:
+            event_callback: Async function to call with each event
+        """
+        self.event_callback = event_callback
+
+        # Start WebSocket connection in background
+        self.ws_task = asyncio.create_task(self._event_stream_loop())
+        logger.info("Started event stream WebSocket connection task")
+
+    async def _event_stream_loop(self):
+        """Background task that maintains WebSocket connection and processes events"""
+        backoff = 1
+        max_backoff = 30
+
+        while True:
+            try:
+                # Load token
+                token = await self._load_token()
+
+                # Connect to WebSocket with token in URL
+                ws_url = f"{self.base_url.replace('http', 'ws')}/ws/events?token={token}"
+
+                session = await self._get_session()
+                async with session.ws_connect(ws_url) as ws:
+                    self.ws_connection = ws
+                    logger.info("Connected to event stream WebSocket")
+                    backoff = 1  # Reset backoff on successful connection
+
+                    # Process messages
+                    async for msg in ws:
+                        if msg.type == aiohttp.WSMsgType.TEXT:
+                            try:
+                                event = json.loads(msg.data)
+                                if self.event_callback:
+                                    await self.event_callback(event)
+                            except json.JSONDecodeError as e:
+                                logger.error(f"Failed to decode event JSON: {e}")
+                            except Exception as e:
+                                logger.error(f"Error processing event: {e}")
+
+                        elif msg.type == aiohttp.WSMsgType.ERROR:
+                            logger.error(f"WebSocket error: {ws.exception()}")
+                            break
+
+                        elif msg.type == aiohttp.WSMsgType.CLOSED:
+                            logger.warning("WebSocket connection closed by server")
+                            break
+
+                    self.ws_connection = None
+
+            except asyncio.CancelledError:
+                logger.info("Event stream WebSocket task cancelled")
+                break
+
+            except Exception as e:
+                logger.error(f"Event stream WebSocket error: {e}, reconnecting in {backoff}s")
+                await asyncio.sleep(backoff)
+                backoff = min(backoff * 2, max_backoff)
+
+
+# Global instance
+_stats_client = None
+
+def get_stats_client() -> StatsServiceClient:
+    """Get the global stats client instance"""
+    global _stats_client
+    if _stats_client is None:
+        _stats_client = StatsServiceClient()
+    return _stats_client
diff --git a/dockmon/backend/websocket/__init__.py b/dockmon/backend/websocket/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/dockmon/backend/websocket/connection.py b/dockmon/backend/websocket/connection.py
new file mode 100644
index 0000000..662f052
--- /dev/null
+++ b/dockmon/backend/websocket/connection.py
@@ -0,0 +1,69 @@
+"""
+WebSocket Connection Management for DockMon
+Handles WebSocket connections and message broadcasting
+"""
+
+import asyncio
+import json
+import logging
+from typing import List
+
+from fastapi import WebSocket
+
+
+logger = logging.getLogger(__name__)
+
+
+class DateTimeEncoder(json.JSONEncoder):
+    """Custom JSON encoder for datetime objects"""
+    def default(self, obj):
+        from datetime import datetime
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        return super().default(obj)
+
+
+class ConnectionManager:
+    """Manages WebSocket connections with thread-safe operations"""
+
+    def __init__(self):
+        self.active_connections: List[WebSocket] = []
+        self._lock = asyncio.Lock()
+
+    async def connect(self, websocket: WebSocket):
+        await websocket.accept()
+        async with self._lock:
+            self.active_connections.append(websocket)
+        logger.info(f"New WebSocket connection. Total connections: {len(self.active_connections)}")
+
+    async def disconnect(self, websocket: WebSocket):
+        async with self._lock:
+            if websocket in self.active_connections:
+                self.active_connections.remove(websocket)
+        logger.info(f"WebSocket disconnected. Total connections: {len(self.active_connections)}")
+
+    def has_active_connections(self) -> bool:
+        """Check if there are any active WebSocket connections"""
+        return bool(self.active_connections)
+
+    async def broadcast(self, message: dict):
+        """Send message to all connected clients"""
+        # Get snapshot of connections with lock
+        async with self._lock:
+            connections = self.active_connections.copy()
+
+        # Send messages without lock (IO can block)
+        dead_connections = []
+        for connection in connections:
+            try:
+                await connection.send_text(json.dumps(message, cls=DateTimeEncoder))
+            except Exception as e:
+                logger.error(f"Error sending message: {e}")
+                dead_connections.append(connection)
+
+        # Clean up dead connections with lock
+        if dead_connections:
+            async with self._lock:
+                for conn in dead_connections:
+                    if conn in self.active_connections:
+                        self.active_connections.remove(conn)
\ No newline at end of file
diff --git a/dockmon/backend/websocket/rate_limiter.py b/dockmon/backend/websocket/rate_limiter.py
new file mode 100644
index 0000000..e1db5b8
--- /dev/null
+++ b/dockmon/backend/websocket/rate_limiter.py
@@ -0,0 +1,108 @@
+"""
+WebSocket Rate Limiting for DockMon
+Provides generous rate limiting to prevent DoS while supporting large deployments
+"""
+
+import time
+from collections import defaultdict, deque
+from typing import Dict, Deque, Tuple
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class WebSocketRateLimiter:
+    """
+    Rate limiter for WebSocket connections.
+    Designed to be generous for legitimate use while preventing abuse.
+
+    Supports monitoring hundreds of containers without issues.
+    """
+
+    def __init__(self):
+        # Track message timestamps per connection
+        # Format: {connection_id: deque of timestamps}
+        self.message_history: Dict[str, Deque[float]] = defaultdict(lambda: deque(maxlen=1000))
+
+        # Rate limits (generous for large deployments)
+        self.limits = {
+            # Allow 100 messages per second (very generous for real-time monitoring)
+            "messages_per_second": 100,
+            # Allow 1000 messages per minute (for burst activity)
+            "messages_per_minute": 1000,
+            # Allow 10000 messages per hour (for sustained monitoring)
+            "messages_per_hour": 10000
+        }
+
+        # Track violations for logging
+        self.violations: Dict[str, int] = defaultdict(int)
+
+    def check_rate_limit(self, connection_id: str) -> Tuple[bool, str]:
+        """
+        Check if a connection has exceeded rate limits.
+
+        Returns:
+            (allowed, reason) - allowed is True if within limits,
+                                reason explains why if rejected
+        """
+        current_time = time.time()
+        history = self.message_history[connection_id]
+
+        # Add current request
+        history.append(current_time)
+
+        # Count messages in different time windows
+        messages_last_second = sum(1 for t in history if current_time - t <= 1)
+        messages_last_minute = sum(1 for t in history if current_time - t <= 60)
+        messages_last_hour = sum(1 for t in history if current_time - t <= 3600)
+
+        # Check per-second limit (prevent bursts)
+        if messages_last_second > self.limits["messages_per_second"]:
+            self.violations[connection_id] += 1
+            logger.warning(f"WebSocket rate limit exceeded for {connection_id}: "
+                         f"{messages_last_second} msgs/sec (limit: {self.limits['messages_per_second']})")
+            return False, f"Rate limit exceeded: {messages_last_second} messages per second"
+
+        # Check per-minute limit
+        if messages_last_minute > self.limits["messages_per_minute"]:
+            self.violations[connection_id] += 1
+            logger.warning(f"WebSocket rate limit exceeded for {connection_id}: "
+                         f"{messages_last_minute} msgs/min (limit: {self.limits['messages_per_minute']})")
+            return False, f"Rate limit exceeded: {messages_last_minute} messages per minute"
+
+        # Check per-hour limit
+        if messages_last_hour > self.limits["messages_per_hour"]:
+            self.violations[connection_id] += 1
+            logger.warning(f"WebSocket rate limit exceeded for {connection_id}: "
+                         f"{messages_last_hour} msgs/hour (limit: {self.limits['messages_per_hour']})")
+            return False, f"Rate limit exceeded: {messages_last_hour} messages per hour"
+
+        # Reset violations on successful request
+        if connection_id in self.violations:
+            del self.violations[connection_id]
+
+        return True, "OK"
+
+    def cleanup_connection(self, connection_id: str):
+        """Clean up tracking data when a connection closes"""
+        if connection_id in self.message_history:
+            del self.message_history[connection_id]
+        if connection_id in self.violations:
+            del self.violations[connection_id]
+
+    def get_connection_stats(self, connection_id: str) -> dict:
+        """Get current rate limiting stats for a connection"""
+        current_time = time.time()
+        history = self.message_history.get(connection_id, deque())
+
+        return {
+            "messages_last_second": sum(1 for t in history if current_time - t <= 1),
+            "messages_last_minute": sum(1 for t in history if current_time - t <= 60),
+            "messages_last_hour": sum(1 for t in history if current_time - t <= 3600),
+            "violations": self.violations.get(connection_id, 0),
+            "limits": self.limits
+        }
+
+
+# Global rate limiter instance
+ws_rate_limiter = WebSocketRateLimiter()
\ No newline at end of file
diff --git a/dockmon/docker-compose.yaml b/dockmon/docker-compose.yaml
new file mode 100644
index 0000000..4e7f07a
--- /dev/null
+++ b/dockmon/docker-compose.yaml
@@ -0,0 +1,31 @@
+services:
+  dockmon:
+    build:
+      context: .
+      dockerfile: docker/Dockerfile
+    container_name: dockmon
+    restart: unless-stopped
+    security_opt:
+      - no-new-privileges:true
+    ports:
+      - "8001:443"   # HTTPS only - backend access through nginx proxy
+    environment:
+      - TZ=UTC
+      - PYTHONPATH=/app/backend
+      - PYTHONUNBUFFERED=1
+    volumes:
+      - dockmon_data:/app/data
+      - /var/run/docker.sock:/var/run/docker.sock  # For local Docker monitoring (auto-configured on first run)
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 30s
+    labels:
+      - "com.dockmon.description=All-in-One Docker Container Monitor"
+      - "com.dockmon.version=1.0"
+
+volumes:
+  dockmon_data:
+    driver: local
\ No newline at end of file
diff --git a/dockmon/docker/Dockerfile b/dockmon/docker/Dockerfile
new file mode 100644
index 0000000..83f093d
--- /dev/null
+++ b/dockmon/docker/Dockerfile
@@ -0,0 +1,111 @@
+# DockMon All-in-One Container
+# Multi-stage build: Go stats service + Python backend + Nginx frontend
+
+# Stage 1: Build Go stats service
+FROM golang:1.23-alpine AS go-builder
+
+WORKDIR /build
+
+# Copy go mod files
+COPY stats-service/go.mod stats-service/go.sum* ./
+
+# Download dependencies
+RUN go mod download
+
+# Copy source code
+COPY stats-service/*.go ./
+
+# Build binary (static linking for alpine)
+RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o stats-service .
+
+# Stage 2: Final image with Python + Go binary
+FROM python:3.11.10-slim
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    nginx \
+    supervisor \
+    curl \
+    gcc \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create app directory
+WORKDIR /app
+
+# Copy Go stats service binary from builder
+COPY --from=go-builder /build/stats-service /usr/local/bin/stats-service
+RUN chmod +x /usr/local/bin/stats-service
+
+# Copy and install Python dependencies
+COPY backend/requirements.txt /app/backend/
+RUN pip install --no-cache-dir -r /app/backend/requirements.txt
+
+# Copy backend code
+COPY backend/ /app/backend/
+
+# Copy frontend files
+COPY src/index.html /usr/share/nginx/html/index.html
+COPY src/login.html /usr/share/nginx/html/login.html
+COPY src/favicon.ico /usr/share/nginx/html/favicon.ico
+COPY src/lucide.min.js /usr/share/nginx/html/lucide.min.js
+COPY src/images/ /usr/share/nginx/html/images/
+COPY src/css/ /usr/share/nginx/html/css/
+COPY src/js/ /usr/share/nginx/html/js/
+RUN chmod 644 /usr/share/nginx/html/*.html /usr/share/nginx/html/*.ico /usr/share/nginx/html/*.js
+RUN chmod -R 644 /usr/share/nginx/html/css/ /usr/share/nginx/html/js/
+RUN find /usr/share/nginx/html/css /usr/share/nginx/html/js -type d -exec chmod 755 {} \;
+
+# Create certs directory (certificates will be generated at runtime if not present)
+RUN mkdir -p /etc/nginx/certs
+
+# Copy nginx configuration
+COPY docker/nginx.conf /etc/nginx/conf.d/default.conf
+RUN rm -f /etc/nginx/sites-enabled/default /etc/nginx/sites-available/default
+
+# Add WebSocket upgrade mapping to main nginx.conf (must be in http block)
+RUN sed -i '/^http {/a \    # WebSocket upgrade mapping\n    map $http_upgrade $connection_upgrade {\n        default upgrade;\n        '"''"' close;\n    }\n' /etc/nginx/nginx.conf
+
+# Copy supervisor configuration
+COPY docker/supervisord.conf /etc/supervisor/conf.d/supervisord.conf
+
+# Create data directory with correct permissions
+RUN mkdir -p /app/data && \
+    chmod 700 /app/data
+
+# Create startup script
+RUN echo '#!/bin/bash' > /startup.sh && \
+    echo 'set -e' >> /startup.sh && \
+    echo '' >> /startup.sh && \
+    echo '# Ensure certificates exist (generate if missing)' >> /startup.sh && \
+    echo 'if [ ! -f /etc/nginx/certs/dockmon.crt ]; then' >> /startup.sh && \
+    echo '  mkdir -p /etc/nginx/certs' >> /startup.sh && \
+    echo '  echo "Generating SSL certificates..."' >> /startup.sh && \
+    echo '  openssl req -x509 -nodes -days 3650 -newkey rsa:2048 \' >> /startup.sh && \
+    echo '    -keyout /etc/nginx/certs/dockmon.key \' >> /startup.sh && \
+    echo '    -out /etc/nginx/certs/dockmon.crt \' >> /startup.sh && \
+    echo '    -subj "/C=US/ST=State/L=City/O=DockMon/CN=localhost" > /dev/null 2>&1' >> /startup.sh && \
+    echo '  echo "SSL certificates generated successfully"' >> /startup.sh && \
+    echo '  chmod 600 /etc/nginx/certs/dockmon.key' >> /startup.sh && \
+    echo '  chmod 644 /etc/nginx/certs/dockmon.crt' >> /startup.sh && \
+    echo 'fi' >> /startup.sh && \
+    echo '' >> /startup.sh && \
+    echo '# Wait for backend to be ready' >> /startup.sh && \
+    echo 'sleep 2' >> /startup.sh && \
+    echo '' >> /startup.sh && \
+    echo '# Start supervisor' >> /startup.sh && \
+    echo 'exec /usr/bin/supervisord -c /etc/supervisor/conf.d/supervisord.conf' >> /startup.sh && \
+    chmod +x /startup.sh
+
+# Expose ports (8081 is internal for stats service)
+EXPOSE 443 8080
+
+# Health check - checks both backend and stats service
+HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
+    CMD curl -f http://localhost:8080/health && curl -f http://localhost:8081/health || exit 1
+
+# Volume for persistent data
+VOLUME ["/app/data"]
+
+# Start supervisor
+CMD ["/startup.sh"]
diff --git a/dockmon/docker/generate-certs.sh b/dockmon/docker/generate-certs.sh
new file mode 100755
index 0000000..a993f9b
--- /dev/null
+++ b/dockmon/docker/generate-certs.sh
@@ -0,0 +1,40 @@
+#!/bin/bash
+
+# Generate self-signed SSL certificates for DockMon
+# These certificates are for development/internal use only
+
+CERT_DIR="./docker/certs"
+CERT_DAYS=3650  # 10 years
+
+# Create certificate directory
+mkdir -p "$CERT_DIR"
+
+# Generate private key
+openssl genrsa -out "$CERT_DIR/dockmon.key" 2048
+
+# Generate certificate signing request
+openssl req -new -key "$CERT_DIR/dockmon.key" \
+  -out "$CERT_DIR/dockmon.csr" \
+  -subj "/C=US/ST=State/L=City/O=DockMon/CN=localhost"
+
+# Generate self-signed certificate
+openssl x509 -req -days $CERT_DAYS \
+  -in "$CERT_DIR/dockmon.csr" \
+  -signkey "$CERT_DIR/dockmon.key" \
+  -out "$CERT_DIR/dockmon.crt"
+
+# Create a combined certificate file for nginx
+cat "$CERT_DIR/dockmon.crt" "$CERT_DIR/dockmon.key" > "$CERT_DIR/dockmon.pem"
+
+# Set appropriate permissions
+chmod 600 "$CERT_DIR/dockmon.key"
+chmod 644 "$CERT_DIR/dockmon.crt"
+chmod 600 "$CERT_DIR/dockmon.pem"
+
+# Clean up CSR
+rm "$CERT_DIR/dockmon.csr"
+
+echo "✅ SSL certificates generated successfully in $CERT_DIR"
+echo "   - Certificate: $CERT_DIR/dockmon.crt"
+echo "   - Private Key: $CERT_DIR/dockmon.key"
+echo "   - Combined PEM: $CERT_DIR/dockmon.pem"
\ No newline at end of file
diff --git a/dockmon/docker/nginx.conf b/dockmon/docker/nginx.conf
new file mode 100644
index 0000000..6cc2456
--- /dev/null
+++ b/dockmon/docker/nginx.conf
@@ -0,0 +1,116 @@
+# HTTPS server only - no HTTP redirect
+server {
+    listen 443 ssl default_server;
+    server_name _;
+
+    # SSL Configuration
+    ssl_certificate /etc/nginx/certs/dockmon.crt;
+    ssl_certificate_key /etc/nginx/certs/dockmon.key;
+
+    # Modern SSL configuration
+    ssl_protocols TLSv1.2 TLSv1.3;
+    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384;
+    ssl_prefer_server_ciphers off;
+
+    # SSL session caching
+    ssl_session_cache shared:SSL:10m;
+    ssl_session_timeout 10m;
+    ssl_session_tickets off;
+
+    # Security headers
+    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header X-XSS-Protection "1; mode=block" always;
+
+    root /usr/share/nginx/html;
+    index index.html;
+
+    # Enable gzip compression
+    gzip on;
+    gzip_types text/plain text/css text/javascript application/javascript application/json;
+    gzip_min_length 1000;
+
+    # Proxy API requests to local backend (same container)
+    location /api/ {
+        proxy_pass http://127.0.0.1:8080/api/;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header X-Forwarded-Host $server_name;
+
+        # Timeouts for long-running requests
+        proxy_connect_timeout 60s;
+        proxy_send_timeout 60s;
+        proxy_read_timeout 60s;
+    }
+
+    # Proxy WebSocket connections
+    location /ws/ {
+        proxy_pass http://127.0.0.1:8080/ws/;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+
+        # Disable buffering for WebSocket
+        proxy_buffering off;
+        proxy_cache off;
+        proxy_redirect off;
+
+        # WebSocket timeouts
+        proxy_connect_timeout 60s;
+        proxy_send_timeout 60s;
+        proxy_read_timeout 3600s;
+    }
+
+    # Main WebSocket for events
+    location = /ws {
+        proxy_pass http://127.0.0.1:8080/ws;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+
+        # Disable buffering for WebSocket
+        proxy_buffering off;
+        proxy_cache off;
+        proxy_redirect off;
+
+        # WebSocket timeouts
+        proxy_connect_timeout 60s;
+        proxy_send_timeout 60s;
+        proxy_read_timeout 3600s;
+    }
+
+    # Direct backend health check
+    location /api/health {
+        proxy_pass http://127.0.0.1:8080/health;
+        access_log off;
+    }
+
+    # Serve static files
+    location / {
+        try_files $uri $uri/ /index.html;
+
+        # Don't cache HTML files - always fetch fresh
+        location ~* \.html$ {
+            expires -1;
+            add_header Cache-Control "no-store, no-cache, must-revalidate, proxy-revalidate, max-age=0";
+        }
+
+        # Cache static assets (images, fonts, etc)
+        location ~* \.(jpg|jpeg|png|gif|ico|svg|woff|woff2|ttf|eot)$ {
+            expires 30d;
+            add_header Cache-Control "public, immutable";
+        }
+    }
+}
\ No newline at end of file
diff --git a/dockmon/docker/supervisord.conf b/dockmon/docker/supervisord.conf
new file mode 100644
index 0000000..acbfe6b
--- /dev/null
+++ b/dockmon/docker/supervisord.conf
@@ -0,0 +1,45 @@
+[supervisord]
+nodaemon=true
+user=root
+logfile=/var/log/supervisor/supervisord.log
+pidfile=/var/run/supervisord.pid
+
+[program:stats-service]
+command=/usr/local/bin/stats-service
+directory=/app
+autostart=true
+autorestart=true
+startsecs=5
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+priority=100
+
+[program:backend]
+command=uvicorn main:app --host 127.0.0.1 --port 8080 --log-level info
+directory=/app/backend
+autostart=true
+autorestart=true
+startsecs=10
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+environment=PYTHONPATH="/app/backend",PYTHONUNBUFFERED="1"
+priority=200
+
+[program:nginx]
+command=nginx -g "daemon off;"
+autostart=true
+autorestart=true
+startsecs=5
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+# Wait for backend to be ready
+priority=999
+
+[group:dockmon]
+programs=stats-service,backend,nginx
\ No newline at end of file
diff --git a/dockmon/screenshots/alerts.png b/dockmon/screenshots/alerts.png
new file mode 100644
index 0000000..910afe1
Binary files /dev/null and b/dockmon/screenshots/alerts.png differ
diff --git a/dockmon/screenshots/blackout_window.png b/dockmon/screenshots/blackout_window.png
new file mode 100644
index 0000000..9cdf262
Binary files /dev/null and b/dockmon/screenshots/blackout_window.png differ
diff --git a/dockmon/screenshots/dashboard.png b/dockmon/screenshots/dashboard.png
new file mode 100644
index 0000000..abd6894
Binary files /dev/null and b/dockmon/screenshots/dashboard.png differ
diff --git a/dockmon/screenshots/host_list.png b/dockmon/screenshots/host_list.png
new file mode 100644
index 0000000..31b0d5d
Binary files /dev/null and b/dockmon/screenshots/host_list.png differ
diff --git a/dockmon/scripts/dockmon-lxc.sh b/dockmon/scripts/dockmon-lxc.sh
new file mode 100644
index 0000000..e4844b7
--- /dev/null
+++ b/dockmon/scripts/dockmon-lxc.sh
@@ -0,0 +1,1006 @@
+#!/bin/bash
+
+# DockMon LXC Container Auto-Creation Script for Proxmox
+# Run this script on your Proxmox host to automatically create and configure DockMon
+# Usage: bash dockmon-lxc.sh
+
+set -e
+
+# Ensure /usr/sbin is in PATH for Proxmox commands
+export PATH="/usr/sbin:/usr/bin:/sbin:/bin:$PATH"
+
+# Color codes for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+NC='\033[0m' # No Color
+
+# Default Configuration (modify as needed)
+CONTAINER_ID=""  # Leave empty for next available ID
+CONTAINER_NAME="dockmon"
+DEBIAN_VERSION=""  # Will be selected by user
+TEMPLATE=""  # Will be set based on Debian version
+STORAGE="local-lvm"
+DISK_SIZE="4"
+MEMORY="512"
+SWAP="512"
+CORES="1"
+BRIDGE="vmbr0"
+IP_CONFIG="dhcp"  # Set to "dhcp" or specify like "192.168.1.100/24"
+GATEWAY=""  # Set if using static IP, e.g., "192.168.1.1"
+DNS=""  # Leave empty for host settings or set like "8.8.8.8"
+ROOT_PASSWORD=""  # Will be set by user
+SSH_KEY=""  # Optional: path to SSH public key file
+START_ON_BOOT="1"  # 1 for yes, 0 for no
+PROXMOX_NODE=$(hostname)
+
+# Template options
+DEBIAN_12_TEMPLATE="debian-12-standard_12.2-1_amd64.tar.zst"
+DEBIAN_13_TEMPLATE="debian-13-standard_13.0-1_amd64.tar.zst"
+
+# GitHub repository
+GITHUB_REPO="https://github.com/darthnorse/dockmon.git"
+
+# Function to print colored output
+print_info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+print_cyan() {
+    echo -e "${CYAN}$1${NC}"
+}
+
+# Detect if running in non-interactive mode (curl | bash)
+INTERACTIVE=true
+if [[ ! -t 0 ]]; then
+    INTERACTIVE=false
+fi
+
+# Helper function for interactive prompts with defaults
+prompt_or_default() {
+    local prompt="$1"
+    local default="$2"
+    local result
+
+    if [[ "$INTERACTIVE" == "true" ]]; then
+        read -p "$prompt" result
+        echo "${result:-$default}"
+    else
+        echo "$default"
+    fi
+}
+
+# Header
+clear
+echo -e "${GREEN}════════════════════════════════════════════════════════${NC}"
+echo -e "${GREEN}     DockMon LXC Container Auto-Creation for Proxmox     ${NC}"
+echo -e "${GREEN}════════════════════════════════════════════════════════${NC}"
+echo ""
+
+# Non-interactive mode notification
+if [[ "$INTERACTIVE" == "false" ]]; then
+    print_info "Non-interactive mode detected - using default settings"
+    print_info "For customization, download and run the script directly"
+    echo ""
+fi
+
+# Check if running on Proxmox VE (community-scripts approach)
+check_root() {
+    if [[ $EUID -ne 0 ]]; then
+        print_error "This script must be run as root"
+        exit 1
+    fi
+}
+
+check_proxmox() {
+    if [ "$1" = "--bypass-proxmox-check" ]; then
+        print_info "Bypassing Proxmox check for testing"
+        return 0
+    fi
+
+    if ! command -v pveversion >/dev/null 2>&1; then
+        print_error "No PVE Detected!"
+        print_error "This script must be run on a Proxmox VE host"
+        exit 1
+    fi
+
+    # Get Proxmox version and validate
+    local pve=$(pveversion | grep "pve-manager" | awk '{print substr($2, 1, 3)}')
+    if [[ ! "$pve" =~ ^(8\.[0-9]|9\.[0-9])$ ]]; then
+        print_error "This version of Proxmox VE is not supported"
+        print_info "Requires PVE Version 8.0 or higher"
+        print_info "Detected: $(pveversion | grep pve-manager)"
+        exit 1
+    fi
+
+    print_info "Detected Proxmox VE: $(pveversion | grep pve-manager | awk '{print $2}')"
+}
+
+# Perform checks
+check_root
+check_proxmox "$1"
+
+# Function to get next available container ID
+get_next_ctid() {
+    local max_id=100
+    for ctid in $(pct list 2>/dev/null | tail -n +2 | awk '{print $1}'); do
+        if [ "$ctid" -ge "$max_id" ]; then
+            max_id=$((ctid + 1))
+        fi
+    done
+    echo $max_id
+}
+
+# Function to check if container ID exists
+check_ctid_exists() {
+    pct status $1 &>/dev/null
+    return $?
+}
+
+# Function to validate IP address format
+validate_ip() {
+    if [[ $1 =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}$ ]]; then
+        return 0
+    fi
+    return 1
+}
+
+# Function to validate IP with CIDR
+validate_ip_cidr() {
+    if [[ $1 =~ ^[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/[0-9]{1,2}$ ]]; then
+        return 0
+    fi
+    return 1
+}
+
+# Select Debian version
+echo -e "${CYAN}Step 1: Select Debian Version${NC}"
+echo "══════════════════════════════════════"
+echo "1) Debian 12 (Bookworm) - Stable, Recommended"
+echo "2) Debian 13 (Trixie) - Testing"
+echo ""
+
+# Interactive vs non-interactive selection
+if [[ "$INTERACTIVE" == "true" ]]; then
+    # Interactive mode
+    while true; do
+        read -p "Select Debian version (1 or 2): " debian_choice
+        case $debian_choice in
+            1)
+                DEBIAN_VERSION="12"
+                TEMPLATE=$DEBIAN_12_TEMPLATE
+                print_success "Selected Debian 12 (Bookworm)"
+                break
+                ;;
+            2)
+                DEBIAN_VERSION="13"
+                TEMPLATE=$DEBIAN_13_TEMPLATE
+                print_success "Selected Debian 13 (Trixie)"
+                break
+                ;;
+            *)
+                print_error "Invalid selection. Please enter 1 or 2"
+                ;;
+        esac
+    done
+else
+    # Non-interactive mode - use defaults
+    DEBIAN_VERSION="12"
+    TEMPLATE=$DEBIAN_12_TEMPLATE
+    print_success "Using Debian 12 (Bookworm) - default"
+fi
+echo ""
+
+# Set root password
+echo -e "${CYAN}Step 2: Set Root Password${NC}"
+echo "══════════════════════════════════════"
+echo "Enter the root password for the container"
+echo "(Password will not be visible while typing)"
+echo ""
+
+if [[ "$INTERACTIVE" == "true" ]]; then
+    while true; do
+        read -s -p "Enter root password: " ROOT_PASSWORD
+        echo
+        read -s -p "Confirm root password: " ROOT_PASSWORD_CONFIRM
+        echo
+
+        if [ "$ROOT_PASSWORD" != "$ROOT_PASSWORD_CONFIRM" ]; then
+            print_error "Passwords do not match! Please try again."
+            echo ""
+        elif [ -z "$ROOT_PASSWORD" ]; then
+            print_error "Password cannot be empty! Please try again."
+            echo ""
+        else
+            print_success "Root password set successfully"
+            break
+        fi
+    done
+else
+    # Non-interactive mode - generate random password
+    ROOT_PASSWORD=$(openssl rand -base64 12 2>/dev/null || echo "dockmon123")
+    print_success "Generated random root password: $ROOT_PASSWORD"
+    print_warning "Save this password! It will be displayed again at the end."
+fi
+echo ""
+
+# Select storage
+echo -e "${CYAN}Step 3: Select Storage${NC}"
+echo "══════════════════════════════════════"
+print_info "Available storage pools:"
+echo ""
+pvesm status | grep -E "^[[:alnum:]]" | awk '{printf "  %-20s %s\n", $1, "(" $2 ")"}'
+echo ""
+
+while true; do
+    read -p "Select storage pool [$STORAGE]: " input
+    STORAGE=${input:-$STORAGE}
+    
+    # Verify storage exists
+    if pvesm status | grep -q "^$STORAGE "; then
+        print_success "Selected storage: $STORAGE"
+        break
+    else
+        print_error "Storage pool '$STORAGE' not found. Please select from the list above."
+    fi
+done
+echo ""
+
+# Configuration options
+echo -e "${CYAN}Step 4: Container Configuration${NC}"
+echo "══════════════════════════════════════"
+echo -e "${BLUE}Default Configuration:${NC}"
+echo "  Node: $PROXMOX_NODE"
+echo "  Storage: $STORAGE (selected)"
+echo "  Disk Size: ${DISK_SIZE}GB"
+echo "  Memory: ${MEMORY}MB"
+echo "  CPU Cores: $CORES"
+echo "  Network Bridge: $BRIDGE"
+echo "  IP Configuration: $IP_CONFIG"
+echo "  Start on Boot: $([ $START_ON_BOOT -eq 1 ] && echo 'Yes' || echo 'No')"
+echo ""
+
+read -p "Do you want to customize these settings? (y/n): " -n 1 -r
+echo
+if [[ $REPLY =~ ^[Yy]$ ]]; then
+    echo ""
+    print_info "Enter custom configuration (press Enter to keep defaults):"
+    echo ""
+    
+    # Disk size
+    read -p "Disk Size in GB [$DISK_SIZE]: " input
+    DISK_SIZE=${input:-$DISK_SIZE}
+    
+    # Memory
+    read -p "Memory in MB [$MEMORY]: " input
+    MEMORY=${input:-$MEMORY}
+    
+    # CPU cores
+    read -p "CPU Cores [$CORES]: " input
+    CORES=${input:-$CORES}
+    
+    # Network bridge
+    print_cyan "Available bridges:"
+    ip link show type bridge | grep -E "^[0-9]+" | awk -F': ' '{print "  - " $2}'
+    read -p "Network Bridge [$BRIDGE]: " input
+    BRIDGE=${input:-$BRIDGE}
+    
+    # IP configuration
+    echo ""
+    print_cyan "IP Configuration:"
+    echo "  1) DHCP (automatic)"
+    echo "  2) Static IP"
+    read -p "Select IP configuration (1 or 2) [1]: " ip_choice
+    
+    if [ "$ip_choice" == "2" ]; then
+        while true; do
+            read -p "Enter IP address with CIDR (e.g., 192.168.1.100/24): " IP_CONFIG
+            if validate_ip_cidr "$IP_CONFIG"; then
+                break
+            else
+                print_error "Invalid IP format. Please use format: 192.168.1.100/24"
+            fi
+        done
+        
+        while true; do
+            read -p "Enter Gateway IP: " GATEWAY
+            if validate_ip "$GATEWAY"; then
+                break
+            else
+                print_error "Invalid gateway IP format"
+            fi
+        done
+        
+        read -p "DNS Server [8.8.8.8]: " input
+        DNS=${input:-"8.8.8.8"}
+    else
+        IP_CONFIG="dhcp"
+    fi
+    
+    # Start on boot
+    read -p "Start container on boot? (y/n) [y]: " -n 1 -r
+    echo
+    if [[ $REPLY =~ ^[Nn]$ ]]; then
+        START_ON_BOOT="0"
+    fi
+fi
+echo ""
+
+# SSH key option
+read -p "Do you want to add an SSH public key for root access? (y/n): " -n 1 -r
+echo
+if [[ $REPLY =~ ^[Yy]$ ]]; then
+    read -p "Enter path to SSH public key file: " SSH_KEY
+    if [ ! -f "$SSH_KEY" ]; then
+        print_warning "SSH key file not found, skipping SSH key configuration"
+        SSH_KEY=""
+    fi
+fi
+echo ""
+
+# Get or assign container ID
+echo -e "${CYAN}Step 5: Container ID Assignment${NC}"
+echo "══════════════════════════════════════"
+
+# Show existing containers for reference
+print_info "Existing containers:"
+pct list | head -10
+echo ""
+
+# Ask user if they want to specify their own ID
+read -p "Do you want to specify a custom container ID? (y/n) [n]: " -n 1 -r
+echo
+
+if [[ $REPLY =~ ^[Yy]$ ]]; then
+    while true; do
+        read -p "Enter desired container ID (e.g., 200): " CUSTOM_ID
+
+        # Validate input is a number
+        if ! [[ "$CUSTOM_ID" =~ ^[0-9]+$ ]]; then
+            print_error "Container ID must be a number"
+            continue
+        fi
+
+        # Check if ID is in valid range (typically 100-999999)
+        if [ "$CUSTOM_ID" -lt 100 ] || [ "$CUSTOM_ID" -gt 999999 ]; then
+            print_error "Container ID should be between 100 and 999999"
+            continue
+        fi
+
+        # Check if ID already exists
+        if check_ctid_exists $CUSTOM_ID; then
+            print_error "Container ID $CUSTOM_ID already exists!"
+            read -p "Try a different ID? (y/n): " -n 1 -r
+            echo
+            if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+                break
+            fi
+        else
+            CONTAINER_ID=$CUSTOM_ID
+            print_success "Will use Container ID: $CONTAINER_ID"
+            break
+        fi
+    done
+fi
+
+# If no custom ID was set or user cancelled, use next available
+if [ -z "$CONTAINER_ID" ]; then
+    CONTAINER_ID=$(get_next_ctid)
+    print_info "Using next available Container ID: $CONTAINER_ID"
+fi
+echo ""
+
+# Download and prepare template dynamically
+echo -e "${CYAN}Step 6: Template Preparation${NC}"
+echo "══════════════════════════════════════"
+
+# Function to get latest Debian template
+get_latest_debian_template() {
+    local version=$1
+    print_info "Fetching latest Debian $version templates from Proxmox..."
+
+    # Update template list
+    pveam update >/dev/null 2>&1
+
+    # Find the latest Debian template for the specified version
+    local available_template=$(pveam available | grep "debian-$version" | grep "standard" | head -1 | awk '{print $2}')
+
+    if [ -n "$available_template" ]; then
+        echo "$available_template"
+        return 0
+    else
+        return 1
+    fi
+}
+
+# Function to download template
+download_template() {
+    local template_name=$1
+    local template_path="/var/lib/vz/template/cache/$template_name"
+
+    print_info "Checking if template exists locally..."
+
+    if [ -f "$template_path" ]; then
+        print_success "Template already available: $template_name"
+        return 0
+    fi
+
+    print_info "Downloading template: $template_name"
+    print_info "This may take several minutes depending on your connection..."
+
+    # Download the template
+    if pveam download local "$template_name"; then
+        print_success "Template downloaded successfully: $template_name"
+        return 0
+    else
+        print_error "Failed to download template: $template_name"
+        return 1
+    fi
+}
+
+# Get the latest template for selected Debian version
+print_info "Determining latest Debian $DEBIAN_VERSION template..."
+
+LATEST_TEMPLATE=$(get_latest_debian_template $DEBIAN_VERSION)
+
+if [ -n "$LATEST_TEMPLATE" ]; then
+    print_info "Latest available: $LATEST_TEMPLATE"
+    TEMPLATE=$LATEST_TEMPLATE
+else
+    print_warning "Could not find latest template, using fallback..."
+    if [ "$DEBIAN_VERSION" == "12" ]; then
+        TEMPLATE=$DEBIAN_12_TEMPLATE
+    else
+        TEMPLATE=$DEBIAN_13_TEMPLATE
+    fi
+
+    # Check if fallback template exists in available list
+    if ! pveam available | grep -q "$TEMPLATE"; then
+        print_error "Fallback template $TEMPLATE not available!"
+        print_info "Available Debian $DEBIAN_VERSION templates:"
+        pveam available | grep "debian-$DEBIAN_VERSION" | awk '{print "  - " $2}'
+        exit 1
+    fi
+fi
+
+# Download the template
+if ! download_template "$TEMPLATE"; then
+    # If download fails, try to find any available Debian template for this version
+    print_warning "Primary download failed, searching for alternative templates..."
+
+    available_templates=$(pveam available | grep "debian-$DEBIAN_VERSION" | awk '{print $2}')
+
+    if [ -n "$available_templates" ]; then
+        print_info "Available Debian $DEBIAN_VERSION templates:"
+        echo "$available_templates" | nl -w2 -s'. '
+        echo ""
+
+        while true; do
+            read -p "Select template number (or 0 to exit): " template_num
+
+            if [ "$template_num" == "0" ]; then
+                print_error "Template selection cancelled"
+                exit 1
+            fi
+
+            selected_template=$(echo "$available_templates" | sed -n "${template_num}p")
+
+            if [ -n "$selected_template" ]; then
+                TEMPLATE=$selected_template
+                if download_template "$TEMPLATE"; then
+                    break
+                else
+                    print_error "Failed to download selected template"
+                fi
+            else
+                print_error "Invalid selection. Please try again."
+            fi
+        done
+    else
+        print_error "No Debian $DEBIAN_VERSION templates available!"
+        exit 1
+    fi
+fi
+
+TEMPLATE_PATH="/var/lib/vz/template/cache/$TEMPLATE"
+print_success "Template ready: $TEMPLATE"
+echo ""
+
+# Build network configuration
+if [ "$IP_CONFIG" == "dhcp" ]; then
+    NET_CONFIG="name=eth0,bridge=$BRIDGE,ip=dhcp"
+else
+    NET_CONFIG="name=eth0,bridge=$BRIDGE,ip=$IP_CONFIG"
+    if [ -n "$GATEWAY" ]; then
+        NET_CONFIG="$NET_CONFIG,gw=$GATEWAY"
+    fi
+fi
+
+# Create the container
+echo -e "${CYAN}Step 7: Creating LXC Container${NC}"
+echo "══════════════════════════════════════"
+print_info "Creating container with ID $CONTAINER_ID..."
+print_info "Using template: $TEMPLATE"
+
+# Create temporary file for password
+PASS_FILE=$(mktemp)
+echo -e "$ROOT_PASSWORD\n$ROOT_PASSWORD" > "$PASS_FILE"
+
+# Create container with password from file
+print_info "Executing container creation..."
+pct create $CONTAINER_ID "$TEMPLATE_PATH" \
+    --hostname $CONTAINER_NAME \
+    --storage $STORAGE \
+    --rootfs $STORAGE:$DISK_SIZE \
+    --memory $MEMORY \
+    --swap $SWAP \
+    --cores $CORES \
+    --net0 $NET_CONFIG \
+    --features nesting=1 \
+    --unprivileged 1 \
+    --onboot $START_ON_BOOT \
+    --password < "$PASS_FILE"
+
+# Remove temporary password file
+rm -f "$PASS_FILE"
+
+if [ $? -ne 0 ]; then
+    print_error "Failed to create container!"
+    exit 1
+fi
+
+print_success "Container $CONTAINER_ID created successfully!"
+
+# Set DNS if specified
+if [ -n "$DNS" ]; then
+    pct set $CONTAINER_ID --nameserver "$DNS"
+fi
+
+# Add SSH key if provided
+if [ -n "$SSH_KEY" ] && [ -f "$SSH_KEY" ]; then
+    print_info "Adding SSH key..."
+    pct set $CONTAINER_ID --ssh-public-keys "$SSH_KEY"
+fi
+echo ""
+
+# Start the container
+echo -e "${CYAN}Step 8: Starting Container${NC}"
+echo "══════════════════════════════════════"
+print_info "Starting container..."
+pct start $CONTAINER_ID
+
+# Wait for container to be ready
+print_info "Waiting for container to be ready..."
+sleep 10
+
+# Get container IP
+print_info "Getting container IP address..."
+for i in {1..30}; do
+    CONTAINER_IP=$(pct exec $CONTAINER_ID -- ip -4 addr show eth0 2>/dev/null | grep inet | awk '{print $2}' | cut -d/ -f1)
+    if [ -n "$CONTAINER_IP" ]; then
+        break
+    fi
+    sleep 2
+done
+
+if [ -z "$CONTAINER_IP" ]; then
+    print_warning "Could not determine container IP address"
+    CONTAINER_IP="<container-ip>"
+fi
+echo ""
+
+# Install DockMon inside the container
+echo -e "${CYAN}Step 9: Installing DockMon${NC}"
+echo "══════════════════════════════════════"
+print_info "Installing DockMon in the container..."
+
+# Create installation script
+cat << 'INSTALL_SCRIPT' > /tmp/install-dockmon.sh
+#!/bin/bash
+set -e
+
+# Update system
+echo "Updating system packages..."
+apt-get update
+DEBIAN_FRONTEND=noninteractive apt-get upgrade -y
+
+# Install required packages
+echo "Installing nginx, git, Python 3, and required dependencies..."
+DEBIAN_FRONTEND=noninteractive apt-get install -y nginx git curl python3 python3-pip python3-venv supervisor
+
+# Clone DockMon repository
+echo "Cloning DockMon repository..."
+cd /opt
+git clone https://github.com/darthnorse/dockmon.git
+
+# Set up Python backend
+echo "Setting up DockMon backend..."
+cd /opt/dockmon/backend
+
+# Create virtual environment
+python3 -m venv venv
+source venv/bin/activate
+
+# Install Python dependencies
+pip install --no-cache-dir -r requirements.txt
+
+# Create data directory
+mkdir -p /opt/dockmon/backend/data
+chown -R www-data:www-data /opt/dockmon/backend/data
+
+# Copy application to web root
+echo "Setting up DockMon frontend..."
+cp /opt/dockmon/src/index.html /var/www/html/index.html
+cp -r /opt/dockmon/images /var/www/html/
+
+# Update frontend to point to backend API (if needed)
+sed -i 's|http://localhost:8080|http://localhost:8080|g' /var/www/html/index.html
+
+# Configure nginx to serve on port 8001
+echo "Configuring nginx for port 8001..."
+cat << 'NGINX_CONF' > /etc/nginx/sites-available/dockmon
+server {
+    listen 8001 default_server;
+    listen [::]:8001 default_server;
+
+    root /var/www/html;
+    index index.html;
+
+    server_name _;
+
+    location / {
+        try_files \$uri \$uri/ =404;
+    }
+
+    # Optional: Add some basic security headers
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header X-XSS-Protection "1; mode=block" always;
+}
+NGINX_CONF
+
+# Enable the new site and disable default
+ln -sf /etc/nginx/sites-available/dockmon /etc/nginx/sites-enabled/
+rm -f /etc/nginx/sites-enabled/default
+
+# Configure nginx to start on boot
+systemctl enable nginx
+systemctl restart nginx
+
+# Create systemd service for DockMon backend
+cat << 'BACKEND_SERVICE' > /etc/systemd/system/dockmon-backend.service
+[Unit]
+Description=DockMon Backend API
+After=network.target
+Wants=network.target
+
+[Service]
+Type=simple
+User=www-data
+Group=www-data
+WorkingDirectory=/opt/dockmon/backend
+Environment=PYTHONPATH=/opt/dockmon/backend
+ExecStart=/opt/dockmon/backend/venv/bin/python main.py
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+BACKEND_SERVICE
+
+# Create supervisor configuration as backup process manager
+cat << 'SUPERVISOR_CONF' > /etc/supervisor/conf.d/dockmon-backend.conf
+[program:dockmon-backend]
+command=/opt/dockmon/backend/venv/bin/python main.py
+directory=/opt/dockmon/backend
+user=www-data
+autostart=true
+autorestart=true
+stderr_logfile=/var/log/dockmon-backend.err.log
+stdout_logfile=/var/log/dockmon-backend.out.log
+environment=PYTHONPATH="/opt/dockmon/backend"
+SUPERVISOR_CONF
+
+# Create a simple frontend systemd service
+cat << 'FRONTEND_SERVICE' > /etc/systemd/system/dockmon-frontend.service
+[Unit]
+Description=DockMon Web Interface
+After=network.target nginx.service dockmon-backend.service
+Requires=nginx.service
+Wants=dockmon-backend.service
+
+[Service]
+Type=oneshot
+ExecStart=/bin/true
+RemainAfterExit=yes
+
+[Install]
+WantedBy=multi-user.target
+FRONTEND_SERVICE
+
+systemctl daemon-reload
+systemctl enable dockmon-backend.service
+systemctl enable dockmon-frontend.service
+systemctl start dockmon-backend.service
+
+# Start supervisor as backup
+systemctl enable supervisor
+systemctl start supervisor
+
+# Create update script
+echo "Creating update script..."
+cat << 'UPDATE_SCRIPT' > /usr/local/bin/update
+#!/bin/bash
+
+# DockMon Update Script
+# Updates both the system and DockMon to latest versions
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Functions for colored output
+print_info() {
+    echo -e "\${BLUE}[INFO]\${NC} \$1"
+}
+
+print_success() {
+    echo -e "\${GREEN}[SUCCESS]\${NC} \$1"
+}
+
+print_error() {
+    echo -e "\${RED}[ERROR]\${NC} \$1"
+}
+
+print_warning() {
+    echo -e "\${YELLOW}[WARNING]\${NC} \$1"
+}
+
+# Header
+echo -e "\${GREEN}════════════════════════════════════════\${NC}"
+echo -e "\${GREEN}       DockMon System Update Tool       \${NC}"
+echo -e "\${GREEN}════════════════════════════════════════\${NC}"
+echo ""
+
+# Check if running as root
+if [ "\$EUID" -ne 0 ]; then 
+    print_error "This script must be run as root!"
+    print_info "Try: sudo update"
+    exit 1
+fi
+
+# Step 1: Update Debian packages
+echo -e "\${BLUE}Step 1: Updating Debian System\${NC}"
+echo "════════════════════════════════════"
+print_info "Updating package lists..."
+apt-get update
+
+print_info "Upgrading installed packages..."
+DEBIAN_FRONTEND=noninteractive apt-get upgrade -y
+
+print_info "Performing distribution upgrade..."
+DEBIAN_FRONTEND=noninteractive apt-get dist-upgrade -y
+
+print_info "Removing unnecessary packages..."
+apt-get autoremove -y
+
+print_info "Cleaning package cache..."
+apt-get autoclean
+
+print_success "System update completed!"
+echo ""
+
+# Step 2: Update DockMon
+echo -e "\${BLUE}Step 2: Updating DockMon\${NC}"
+echo "════════════════════════════════════"
+
+# Check if DockMon directory exists
+if [ ! -d "/opt/dockmon" ]; then
+    print_error "DockMon directory not found at /opt/dockmon"
+    print_info "Attempting to clone repository..."
+    cd /opt
+    git clone https://github.com/darthnorse/dockmon.git
+    if [ \$? -ne 0 ]; then
+        print_error "Failed to clone DockMon repository"
+        exit 1
+    fi
+fi
+
+# Navigate to DockMon directory
+cd /opt/dockmon
+
+# Store current version (if exists)
+if [ -f "src/index.html" ]; then
+    OLD_VERSION=\$(grep -oP 'DockMon v\K[0-9.]+' src/index.html | head -1 || echo "unknown")
+else
+    OLD_VERSION="not installed"
+fi
+
+print_info "Current version: \$OLD_VERSION"
+
+# Fetch latest changes
+print_info "Fetching latest updates from GitHub..."
+git fetch origin
+
+# Check if there are updates
+LOCAL=\$(git rev-parse HEAD)
+REMOTE=\$(git rev-parse origin/main)
+
+if [ "\$LOCAL" = "\$REMOTE" ]; then
+    print_info "DockMon is already up to date"
+else
+    print_info "Updates available, pulling latest version..."
+    
+    # Pull latest changes
+    git pull origin main
+    
+    if [ \$? -ne 0 ]; then
+        print_warning "Git pull failed, attempting to reset..."
+        git reset --hard origin/main
+    fi
+    
+    # Get new version
+    NEW_VERSION=\$(grep -oP 'DockMon v\K[0-9.]+' src/index.html | head -1 || echo "unknown")
+    print_success "Updated DockMon from v\$OLD_VERSION to v\$NEW_VERSION"
+fi
+
+# Update the web application
+print_info "Deploying updated application..."
+cp -f /opt/dockmon/src/index.html /var/www/html/index.html
+cp -rf /opt/dockmon/images /var/www/html/
+
+if [ \$? -eq 0 ]; then
+    print_success "Application deployed successfully!"
+else
+    print_error "Failed to deploy application"
+    exit 1
+fi
+
+# Restart nginx to ensure everything is fresh
+print_info "Restarting web server..."
+systemctl restart nginx
+
+if systemctl is-active --quiet nginx; then
+    print_success "Web server restarted successfully!"
+else
+    print_error "Web server failed to restart"
+    exit 1
+fi
+
+echo ""
+
+# Step 3: Check for script updates
+echo -e "\${BLUE}Step 3: Checking for Script Updates\${NC}"
+echo "════════════════════════════════════"
+
+# Check if this update script itself needs updating
+if [ -f "/opt/dockmon/scripts/update.sh" ]; then
+    if ! cmp -s "/opt/dockmon/scripts/update.sh" "/usr/local/bin/update"; then
+        print_info "Update script has a newer version, updating..."
+        cp -f /opt/dockmon/scripts/update.sh /usr/local/bin/update
+        chmod +x /usr/local/bin/update
+        print_success "Update script updated! Please run 'update' again if needed."
+    else
+        print_info "Update script is current"
+    fi
+fi
+
+echo ""
+
+# Summary
+echo -e "\${GREEN}════════════════════════════════════════\${NC}"
+echo -e "\${GREEN}        Update Complete! ✅              \${NC}"
+echo -e "\${GREEN}════════════════════════════════════════\${NC}"
+echo ""
+echo -e "\${BLUE}Summary:\${NC}"
+echo "• System packages: Updated"
+echo "• DockMon application: \$([ "\$LOCAL" = "\$REMOTE" ] && echo "Already current" || echo "Updated")"
+echo "• Web server: Running"
+echo ""
+echo -e "\${BLUE}DockMon Access:\${NC}"
+echo "• Web Interface: http://\$(hostname -I | awk '{print \$1}')"
+echo ""
+
+# Check if reboot is required
+if [ -f /var/run/reboot-required ]; then
+    echo -e "\${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\${NC}"
+    echo -e "\${YELLOW}⚠️  REBOOT REQUIRED\${NC}"
+    echo -e "\${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\${NC}"
+    echo "A system reboot is required to complete updates."
+    echo "Please run: reboot"
+    echo ""
+fi
+
+exit 0
+UPDATE_SCRIPT
+
+# Make update script executable and accessible
+chmod +x /usr/local/bin/update
+
+# Create shorter alias
+ln -sf /usr/local/bin/update /usr/local/bin/dockmon-update
+
+# Also create the update script in the repository for future updates
+mkdir -p /opt/dockmon/scripts
+cp /usr/local/bin/update /opt/dockmon/scripts/update.sh
+chmod +x /opt/dockmon/scripts/update.sh
+
+echo "DockMon installation completed!"
+INSTALL_SCRIPT
+
+# Copy and execute installation script in container
+pct push $CONTAINER_ID /tmp/install-dockmon.sh /tmp/install-dockmon.sh
+pct exec $CONTAINER_ID -- chmod +x /tmp/install-dockmon.sh
+pct exec $CONTAINER_ID -- /tmp/install-dockmon.sh
+
+# Clean up
+rm /tmp/install-dockmon.sh
+
+# Final status check
+print_info "Verifying installation..."
+if pct exec $CONTAINER_ID -- systemctl is-active nginx >/dev/null 2>&1; then
+    print_success "Nginx is running"
+else
+    print_warning "Nginx might not be running properly"
+fi
+echo ""
+
+# Summary
+echo -e "${GREEN}════════════════════════════════════════════════════════${NC}"
+echo -e "${GREEN}           DockMon Installation Complete! 🎉             ${NC}"
+echo -e "${GREEN}════════════════════════════════════════════════════════${NC}"
+echo ""
+echo -e "${BLUE}Container Details:${NC}"
+echo "══════════════════════════════════════"
+echo "Container ID:     $CONTAINER_ID"
+echo "Container Name:   $CONTAINER_NAME"
+echo "Debian Version:   $DEBIAN_VERSION"
+echo "IP Address:       $CONTAINER_IP"
+echo "Memory:           ${MEMORY}MB"
+echo "Disk Size:        ${DISK_SIZE}GB"
+echo "CPU Cores:        $CORES"
+echo "Start on Boot:    $([ $START_ON_BOOT -eq 1 ] && echo 'Yes' || echo 'No')"
+echo ""
+echo -e "${BLUE}Access DockMon:${NC}"
+echo "══════════════════════════════════════"
+echo -e "Web Interface:    ${GREEN}http://$CONTAINER_IP:8001${NC}"
+echo -e "SSH Access:       ${GREEN}ssh root@$CONTAINER_IP${NC}"
+echo ""
+echo -e "${BLUE}Container Management:${NC}"
+echo "══════════════════════════════════════"
+echo "Start:     pct start $CONTAINER_ID"
+echo "Stop:      pct stop $CONTAINER_ID"
+echo "Restart:   pct restart $CONTAINER_ID"
+echo "Console:   pct console $CONTAINER_ID"
+echo "Remove:    pct destroy $CONTAINER_ID"
+echo ""
+echo -e "${YELLOW}Notes:${NC}"
+echo "• Template used: $TEMPLATE (downloaded automatically)"
+echo "• Frontend (nginx) serves on port 8001"
+echo "• Backend API runs on port 8080"
+echo "• Root password: (the password you set)"
+echo "• Services: dockmon-backend, dockmon-frontend, nginx, supervisor"
+echo "• To update DockMon, run inside container: update"
+echo "• Backend logs: journalctl -u dockmon-backend -f"
+echo "• Supervisor logs: tail -f /var/log/dockmon-backend.out.log"
+echo ""
+echo -e "${GREEN}Enjoy DockMon!${NC} 🐳"
\ No newline at end of file
diff --git a/dockmon/scripts/setup-docker-mtls.sh b/dockmon/scripts/setup-docker-mtls.sh
new file mode 100755
index 0000000..db7966e
--- /dev/null
+++ b/dockmon/scripts/setup-docker-mtls.sh
@@ -0,0 +1,554 @@
+#!/bin/bash
+
+# DockMon Docker mTLS Setup Script (Unified Edition)
+# Automatically detects and configures for standard Linux, unRAID, Synology, etc.
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Default values
+DAYS_VALID=3650
+HOST_NAME=""
+HOST_IP=""
+SYSTEM_TYPE="unknown"
+DOCKER_RESTART_CMD=""
+DOCKER_CONFIG_METHOD=""
+
+# Function to print colored output
+print_info() {
+    echo -e "${GREEN}[INFO]${NC} $1"
+}
+
+print_warn() {
+    echo -e "${YELLOW}[WARN]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+print_system() {
+    echo -e "${BLUE}[SYSTEM]${NC} $1"
+}
+
+# Detect system type
+detect_system() {
+    print_info "Detecting system type..."
+
+    # Check for unRAID
+    if [ -f "/etc/unraid-version" ] || [ -d "/boot/config" ]; then
+        SYSTEM_TYPE="unraid"
+        UNRAID_VERSION=$(cat /etc/unraid-version 2>/dev/null || echo "Unknown")
+        print_system "Detected unRAID ($UNRAID_VERSION)"
+        CERT_DIR="/boot/config/docker-tls"
+        DOCKER_RESTART_CMD="/etc/rc.d/rc.docker restart"
+        DOCKER_CONFIG_METHOD="unraid"
+        return 0
+    fi
+
+    # Check for Synology
+    if [ -f "/etc/synoinfo.conf" ]; then
+        SYSTEM_TYPE="synology"
+        print_system "Detected Synology NAS"
+        CERT_DIR="/volume1/docker/certs"
+        DOCKER_RESTART_CMD="synoservicectl --restart pkgctl-Docker"
+        DOCKER_CONFIG_METHOD="synology"
+        return 0
+    fi
+
+    # Check for QNAP
+    if [ -f "/etc/config/qpkg.conf" ]; then
+        SYSTEM_TYPE="qnap"
+        print_system "Detected QNAP NAS"
+        CERT_DIR="/share/docker/certs"
+        DOCKER_RESTART_CMD="/etc/init.d/container-station.sh restart"
+        DOCKER_CONFIG_METHOD="qnap"
+        return 0
+    fi
+
+    # Check for TrueNAS/FreeNAS
+    if [ -f "/etc/version" ] && grep -q "TrueNAS\|FreeNAS" /etc/version 2>/dev/null; then
+        SYSTEM_TYPE="truenas"
+        print_system "Detected TrueNAS/FreeNAS"
+        CERT_DIR="/mnt/tank/docker/certs"
+        DOCKER_RESTART_CMD="service docker restart"
+        DOCKER_CONFIG_METHOD="truenas"
+        return 0
+    fi
+
+    # Check for systemd-based systems (standard Linux)
+    if command -v systemctl &> /dev/null && systemctl list-units --full -all | grep -q "docker.service"; then
+        SYSTEM_TYPE="systemd"
+        print_system "Detected systemd-based Linux"
+        CERT_DIR="$HOME/.docker/certs"
+        DOCKER_RESTART_CMD="sudo systemctl restart docker"
+        DOCKER_CONFIG_METHOD="systemd"
+        return 0
+    fi
+
+    # Check for OpenRC (Alpine Linux, etc.)
+    if command -v rc-service &> /dev/null; then
+        SYSTEM_TYPE="openrc"
+        print_system "Detected OpenRC-based system"
+        CERT_DIR="$HOME/.docker/certs"
+        DOCKER_RESTART_CMD="sudo rc-service docker restart"
+        DOCKER_CONFIG_METHOD="openrc"
+        return 0
+    fi
+
+    # Default fallback
+    SYSTEM_TYPE="generic"
+    print_warn "Could not detect specific system type, using generic configuration"
+    CERT_DIR="$HOME/.docker/certs"
+    DOCKER_CONFIG_METHOD="manual"
+}
+
+# Parse command line arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --host)
+            HOST_NAME="$2"
+            shift 2
+            ;;
+        --ip)
+            HOST_IP="$2"
+            shift 2
+            ;;
+        --dir)
+            CERT_DIR="$2"
+            CUSTOM_CERT_DIR=true
+            shift 2
+            ;;
+        --days)
+            DAYS_VALID="$2"
+            shift 2
+            ;;
+        --system)
+            SYSTEM_TYPE="$2"
+            shift 2
+            ;;
+        --help)
+            echo "Usage: $0 [OPTIONS]"
+            echo ""
+            echo "Options:"
+            echo "  --host HOSTNAME   Hostname for the Docker host"
+            echo "  --ip IP_ADDRESS   IP address for the Docker host"
+            echo "  --dir PATH        Directory to store certificates"
+            echo "  --days DAYS       Certificate validity in days (default: 365)"
+            echo "  --system TYPE     Force system type (unraid|synology|systemd|manual)"
+            echo "  --help           Show this help message"
+            echo ""
+            echo "Supported Systems:"
+            echo "  - unRAID         Automatic detection and configuration"
+            echo "  - Synology       Automatic detection and configuration"
+            echo "  - QNAP           Automatic detection and configuration"
+            echo "  - TrueNAS        Automatic detection and configuration"
+            echo "  - SystemD Linux  Standard Linux with systemd"
+            echo "  - Generic        Manual configuration required"
+            exit 0
+            ;;
+        *)
+            print_error "Unknown option: $1"
+            echo "Use --help for usage information"
+            exit 1
+            ;;
+    esac
+done
+
+# Detect system if not specified
+if [ "$SYSTEM_TYPE" = "unknown" ] || [ -z "$SYSTEM_TYPE" ]; then
+    detect_system
+fi
+
+# Override cert directory if not custom set and system detected
+if [ -z "$CUSTOM_CERT_DIR" ]; then
+    case $SYSTEM_TYPE in
+        unraid)
+            # Check for existing certificates in both new and legacy locations
+            if [ -f "/boot/config/docker-tls/ca.pem" ] && [ -f "/boot/config/docker-tls/client-cert.pem" ]; then
+                CERT_DIR="/boot/config/docker-tls"
+                UNRAID_EXISTING_CERTS=true
+            elif [ -f "/boot/config/docker/certs/ca.pem" ] && [ -f "/boot/config/docker/certs/client-cert.pem" ]; then
+                CERT_DIR="/boot/config/docker/certs"
+                UNRAID_EXISTING_CERTS=true
+            else
+                CERT_DIR="/boot/config/docker-tls"
+                UNRAID_EXISTING_CERTS=false
+            fi
+            ;;
+        synology)
+            CERT_DIR="/volume1/docker/certs"
+            ;;
+        qnap)
+            CERT_DIR="/share/docker/certs"
+            ;;
+        truenas)
+            CERT_DIR="/mnt/tank/docker/certs"
+            ;;
+    esac
+fi
+
+# Detect hostname and IP if not provided
+if [ -z "$HOST_NAME" ]; then
+    HOST_NAME=$(hostname -f 2>/dev/null || hostname)
+    print_info "Using detected hostname: $HOST_NAME"
+fi
+
+if [ -z "$HOST_IP" ]; then
+    # Try to get the primary IP address
+    if command -v ip &> /dev/null; then
+        HOST_IP=$(ip route get 1 2>/dev/null | grep -oP 'src \K\S+' || echo "")
+    fi
+    if [ -z "$HOST_IP" ]; then
+        HOST_IP=$(hostname -I 2>/dev/null | awk '{print $1}' || echo "127.0.0.1")
+    fi
+    print_info "Using detected IP: $HOST_IP"
+fi
+
+print_info "==================================="
+print_info "DockMon Docker mTLS Setup"
+print_system "Platform: $SYSTEM_TYPE"
+print_info "==================================="
+print_info "Hostname: $HOST_NAME"
+print_info "IP Address: $HOST_IP"
+print_info "Certificate Directory: $CERT_DIR"
+print_info "Validity Period: $DAYS_VALID days"
+echo ""
+
+# Create certificate directory
+mkdir -p "$CERT_DIR"
+cd "$CERT_DIR"
+
+# Check if certificates already exist
+if [ -f "ca.pem" ] || [ -f "server-cert.pem" ] || [ -f "client-cert.pem" ]; then
+    print_warn "Existing certificates found in $CERT_DIR"
+    read -p "Do you want to overwrite them? (y/N): " -n 1 -r
+    echo
+    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+        print_info "Exiting without changes"
+        exit 0
+    fi
+    # Backup existing certificates
+    BACKUP_DIR="$CERT_DIR/backup-$(date +%Y%m%d-%H%M%S)"
+    mkdir -p "$BACKUP_DIR"
+    mv -f *.pem "$BACKUP_DIR" 2>/dev/null || true
+    print_info "Existing certificates backed up to: $BACKUP_DIR"
+fi
+
+print_info "Generating Certificate Authority (CA)..."
+
+# Generate CA private key
+openssl genrsa -out ca-key.pem 4096 2>/dev/null
+
+# Generate CA certificate
+openssl req -new -x509 -days $DAYS_VALID -key ca-key.pem -sha256 -out ca.pem \
+    -subj "/C=US/ST=State/L=City/O=DockMon/CN=DockMon CA" 2>/dev/null
+
+print_info "Generating Server certificates..."
+
+# Generate server private key
+openssl genrsa -out server-key.pem 4096 2>/dev/null
+
+# Generate server certificate request
+openssl req -subj "/CN=$HOST_NAME" -sha256 -new -key server-key.pem -out server.csr 2>/dev/null
+
+# Create extensions file for server certificate
+cat > extfile.cnf <<EOF
+subjectAltName = DNS:$HOST_NAME,DNS:localhost,IP:$HOST_IP,IP:127.0.0.1
+extendedKeyUsage = serverAuth
+EOF
+
+# Sign server certificate
+openssl x509 -req -days $DAYS_VALID -sha256 -in server.csr -CA ca.pem -CAkey ca-key.pem \
+    -CAcreateserial -out server-cert.pem -extfile extfile.cnf 2>/dev/null
+
+print_info "Generating Client certificates for DockMon..."
+
+# Generate client private key
+openssl genrsa -out client-key.pem 4096 2>/dev/null
+
+# Generate client certificate request
+openssl req -subj '/CN=DockMon Client' -new -key client-key.pem -out client.csr 2>/dev/null
+
+# Create extensions file for client certificate
+echo "extendedKeyUsage = clientAuth" > extfile-client.cnf
+
+# Sign client certificate
+openssl x509 -req -days $DAYS_VALID -sha256 -in client.csr -CA ca.pem -CAkey ca-key.pem \
+    -CAcreateserial -out client-cert.pem -extfile extfile-client.cnf 2>/dev/null
+
+# Clean up temporary files
+rm -f *.csr extfile*.cnf ca.srl
+
+# Set appropriate permissions
+chmod 400 *-key.pem
+chmod 444 *.pem
+
+print_info "Certificates generated successfully!"
+echo ""
+
+# System-specific setup
+case $SYSTEM_TYPE in
+    unraid)
+        print_system "Configuring for unRAID..."
+
+        if [ "$UNRAID_EXISTING_CERTS" = true ]; then
+            print_info "Found existing Docker TLS certificates in: $CERT_DIR"
+            print_warn "unRAID 7.x automatically generates Docker TLS certificates on fresh installs"
+            print_warn "You can use these existing certificates instead of generating new ones"
+            echo ""
+        fi
+        ;;
+
+    synology)
+        print_system "Configuring for Synology NAS..."
+        print_warn "NOTE: Synology support is UNTESTED - proceed at your own risk"
+        ;;
+
+    qnap)
+        print_system "Configuring for QNAP NAS..."
+        print_warn "NOTE: QNAP support is UNTESTED - proceed at your own risk"
+        ;;
+
+    truenas)
+        print_system "Configuring for TrueNAS..."
+        print_warn "NOTE: TrueNAS support is UNTESTED - proceed at your own risk"
+        ;;
+
+    systemd)
+        print_system "Configuring for systemd-based Linux..."
+
+        # Generate systemd override with correct paths for /etc/docker/certs
+        OVERRIDE_FILE="$CERT_DIR/docker-override.conf"
+        cat > "$OVERRIDE_FILE" <<EOF
+[Service]
+ExecStart=
+ExecStart=/usr/bin/dockerd \\
+    -H unix:///var/run/docker.sock \\
+    -H tcp://0.0.0.0:2376 \\
+    --tlsverify \\
+    --tlscacert=/etc/docker/certs/ca.pem \\
+    --tlscert=/etc/docker/certs/server-cert.pem \\
+    --tlskey=/etc/docker/certs/server-key.pem
+EOF
+        ;;
+
+    *)
+        print_warn "Manual configuration required for $SYSTEM_TYPE"
+        print_info "Generic configuration files have been created"
+        ;;
+esac
+
+echo ""
+echo "========================================"
+echo "ADD HOST TO DOCKMON"
+echo "========================================"
+echo ""
+echo "Step 1: Display and copy certificate contents:"
+echo ""
+echo "   # Display CA Certificate (copy entire output including BEGIN/END lines)"
+echo "   cat $CERT_DIR/ca.pem"
+echo ""
+echo "   # Display Client Certificate (copy entire output including BEGIN/END lines)"
+echo "   cat $CERT_DIR/client-cert.pem"
+echo ""
+echo "   # Display Client Key (copy entire output including BEGIN/END lines)"
+echo "   cat $CERT_DIR/client-key.pem"
+echo ""
+echo "Step 2: Add host in DockMon web interface:"
+echo "   1. Go to Host Management page"
+echo "   2. Click 'Add Host' button"
+echo "   3. Fill in:"
+echo "      - Name: [Your descriptive name]"
+echo "      - URL: tcp://$HOST_IP:2376"
+echo "      - CA Certificate: [Paste ENTIRE contents of ca.pem]"
+echo "      - Client Certificate: [Paste ENTIRE contents of client-cert.pem]"
+echo "      - Client Key: [Paste ENTIRE contents of client-key.pem]"
+echo "   4. Click 'Test Connection'"
+echo "   5. If successful, click 'Save'"
+echo ""
+print_warn "IMPORTANT: Keep the private keys (*-key.pem) secure!"
+print_warn "Never commit certificates to version control!"
+
+# Offer to configure Docker automatically if available
+if [ "$SYSTEM_TYPE" != "manual" ] && command -v docker &> /dev/null; then
+    echo ""
+    read -p "Do you want to configure Docker for mTLS now? (y/N): " -n 1 -r
+    echo
+    if [[ $REPLY =~ ^[Yy]$ ]]; then
+        case $SYSTEM_TYPE in
+            unraid)
+                print_warn "Please configure Docker manually via unRAID Web UI as described above"
+                print_info "After configuration, restart Docker with: /etc/rc.d/rc.docker restart"
+                ;;
+            systemd)
+                print_info "Configuring Docker daemon..."
+
+                # Check if override.conf already exists and warn user
+                if [ -f /etc/systemd/system/docker.service.d/override.conf ]; then
+                    echo ""
+                    print_warn "Existing Docker daemon override configuration found!"
+                    echo ""
+                    echo "Current configuration:"
+                    sudo cat /etc/systemd/system/docker.service.d/override.conf | head -15
+                    echo ""
+                    read -p "This will be REPLACED with mTLS configuration. Continue? (y/N): " -n 1 -r
+                    echo ""
+                    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
+                        print_info "Configuration cancelled. Manual setup instructions available by re-running and selecting 'N'"
+                        exit 0
+                    fi
+
+                    BACKUP_FILE="/etc/systemd/system/docker.service.d/override.conf.backup-$(date +%Y%m%d-%H%M%S)"
+                    sudo cp /etc/systemd/system/docker.service.d/override.conf "$BACKUP_FILE"
+                    print_info "Backed up existing override.conf to: $BACKUP_FILE"
+                fi
+
+                sudo mkdir -p /etc/docker/certs
+                sudo cp "$CERT_DIR"/{ca.pem,server-cert.pem,server-key.pem} /etc/docker/certs/
+                sudo chmod 400 /etc/docker/certs/*-key.pem
+                sudo chmod 444 /etc/docker/certs/*.pem
+
+                sudo mkdir -p /etc/systemd/system/docker.service.d/
+                cat <<EOF | sudo tee /etc/systemd/system/docker.service.d/override.conf > /dev/null
+[Service]
+ExecStart=
+ExecStart=/usr/bin/dockerd \\
+    -H unix:///var/run/docker.sock \\
+    -H tcp://0.0.0.0:2376 \\
+    --tlsverify \\
+    --tlscacert=/etc/docker/certs/ca.pem \\
+    --tlscert=/etc/docker/certs/server-cert.pem \\
+    --tlskey=/etc/docker/certs/server-key.pem
+EOF
+
+                print_info "Restarting Docker daemon..."
+                sudo systemctl daemon-reload
+                sudo systemctl restart docker
+
+                sleep 3
+
+                print_info "Testing mTLS connection..."
+                if docker --tlsverify \
+                    --tlscacert="$CERT_DIR/ca.pem" \
+                    --tlscert="$CERT_DIR/client-cert.pem" \
+                    --tlskey="$CERT_DIR/client-key.pem" \
+                    -H=tcp://localhost:2376 version > /dev/null 2>&1; then
+                    print_info "✅ mTLS configuration successful!"
+                    echo ""
+                    print_info "Test the connection from your local machine:"
+                    echo "  docker --tlsverify \\"
+                    echo "    --tlscacert=$CERT_DIR/ca.pem \\"
+                    echo "    --tlscert=$CERT_DIR/client-cert.pem \\"
+                    echo "    --tlskey=$CERT_DIR/client-key.pem \\"
+                    echo "    -H=tcp://$HOST_IP:2376 version"
+                else
+                    print_error "Failed to connect. Check logs: sudo journalctl -u docker -n 50"
+                fi
+                ;;
+            *)
+                print_warn "Automatic configuration not available for $SYSTEM_TYPE"
+                ;;
+        esac
+    else
+        # User selected No - show manual instructions based on system type
+        echo ""
+        case $SYSTEM_TYPE in
+            systemd)
+                print_info "==================================="
+                print_info "Manual Configuration Instructions:"
+                print_info "==================================="
+                echo ""
+                echo "1. Backup existing Docker override (if it exists):"
+                echo "   [ -f /etc/systemd/system/docker.service.d/override.conf ] && \\"
+                echo "     sudo cp /etc/systemd/system/docker.service.d/override.conf \\"
+                echo "     /etc/systemd/system/docker.service.d/override.conf.backup-\$(date +%Y%m%d-%H%M%S)"
+                echo ""
+                echo "2. Copy certificates to system directory:"
+                echo "   sudo mkdir -p /etc/docker/certs"
+                echo "   sudo cp $CERT_DIR/{ca.pem,server-cert.pem,server-key.pem} /etc/docker/certs/"
+                echo "   sudo chmod 400 /etc/docker/certs/*-key.pem"
+                echo "   sudo chmod 444 /etc/docker/certs/*.pem"
+                echo ""
+                echo "3. Configure Docker daemon:"
+                echo "   sudo mkdir -p /etc/systemd/system/docker.service.d/"
+                echo "   sudo cp $CERT_DIR/docker-override.conf /etc/systemd/system/docker.service.d/override.conf"
+                echo ""
+                echo "4. Restart Docker:"
+                echo "   sudo systemctl daemon-reload"
+                echo "   sudo systemctl restart docker"
+                echo ""
+                echo "5. Test the mTLS connection:"
+                echo "   docker --tlsverify \\"
+                echo "     --tlscacert=$CERT_DIR/ca.pem \\"
+                echo "     --tlscert=$CERT_DIR/client-cert.pem \\"
+                echo "     --tlskey=$CERT_DIR/client-key.pem \\"
+                echo "     -H=tcp://$HOST_IP:2376 version"
+                ;;
+            unraid)
+                print_info "==================================="
+                print_info "unRAID Configuration Instructions:"
+                print_info "==================================="
+                echo ""
+                echo "To enable Docker remote access with TLS on unRAID:"
+                echo ""
+                echo "1. Stop Docker service:"
+                echo "   - Via Web UI: Settings → Docker → Set 'Enable Docker' to No → Apply"
+                echo "   - Via SSH: /etc/rc.d/rc.docker stop"
+                echo ""
+                echo "2. Backup existing Docker configuration:"
+                echo "   cp /boot/config/docker.cfg /boot/config/docker.cfg.backup-\$(date +%Y%m%d-%H%M%S)"
+                echo ""
+                echo "3. Edit /boot/config/docker.cfg via SSH:"
+                echo "   nano /boot/config/docker.cfg"
+                echo ""
+                echo "4. Add or update the DOCKER_OPTS line:"
+                echo "   DOCKER_OPTS=\"-H unix:///var/run/docker.sock -H tcp://0.0.0.0:2376 \\"
+                echo "     --tlsverify \\"
+                echo "     --tlscacert=$CERT_DIR/ca.pem \\"
+                echo "     --tlscert=$CERT_DIR/server-cert.pem \\"
+                echo "     --tlskey=$CERT_DIR/server-key.pem\""
+                echo ""
+                echo "5. Start Docker service:"
+                echo "   - Via Web UI: Settings → Docker → Set 'Enable Docker' to Yes → Apply"
+                echo "   - Via SSH: /etc/rc.d/rc.docker start"
+                echo ""
+                echo "6. Test the connection:"
+                echo "   docker --tlsverify \\"
+                echo "     --tlscacert=$CERT_DIR/ca.pem \\"
+                echo "     --tlscert=$CERT_DIR/client-cert.pem \\"
+                echo "     --tlskey=$CERT_DIR/client-key.pem \\"
+                echo "     -H=tcp://$HOST_IP:2376 version"
+                ;;
+            synology)
+                print_info "==================================="
+                print_info "Synology Configuration Instructions (UNTESTED):"
+                print_info "==================================="
+                echo ""
+                echo "1. Open Synology DSM Web UI"
+                echo "2. Go to Package Center → Docker"
+                echo "3. Stop Docker package"
+                echo "4. SSH into your Synology and run:"
+                echo "   sudo vi /var/packages/Docker/etc/dockerd.json"
+                echo "5. Add the following configuration:"
+                echo '   {'
+                echo '     "hosts": ["unix:///var/run/docker.sock", "tcp://0.0.0.0:2376"],'
+                echo '     "tls": true,'
+                echo '     "tlsverify": true,'
+                echo "     \"tlscacert\": \"$CERT_DIR/ca.pem\","
+                echo "     \"tlscert\": \"$CERT_DIR/server-cert.pem\","
+                echo "     \"tlskey\": \"$CERT_DIR/server-key.pem\""
+                echo '   }'
+                echo "6. Start Docker package from Package Center"
+                ;;
+        esac
+    fi
+fi
+
+print_info "Setup complete!"
\ No newline at end of file
diff --git a/dockmon/scripts/update-pinned-images.sh b/dockmon/scripts/update-pinned-images.sh
new file mode 100755
index 0000000..b9028b0
--- /dev/null
+++ b/dockmon/scripts/update-pinned-images.sh
@@ -0,0 +1,44 @@
+#!/bin/bash
+# Script to update pinned Docker image versions
+# Run this occasionally to update to newer stable versions
+
+set -e
+
+echo "🔄 Updating pinned Docker image versions..."
+
+# Function to get SHA256 digest for an image
+get_image_digest() {
+    local image_name=$1
+    echo "📥 Pulling $image_name..."
+    docker pull "$image_name" >/dev/null 2>&1
+    local digest=$(docker inspect "$image_name" --format='{{index .RepoDigests 0}}' 2>/dev/null)
+    if [ -z "$digest" ]; then
+        # Fallback: get digest from manifest
+        digest=$(docker images --digests "$image_name" --format "{{.Repository}}:{{.Tag}}@{{.Digest}}" | head -1)
+    fi
+    echo "$digest"
+}
+
+echo ""
+echo "🐍 Getting Python 3.11-slim digest..."
+PYTHON_DIGEST=$(get_image_digest "python:3.11-slim")
+echo "   $PYTHON_DIGEST"
+
+echo ""
+echo "🌐 Getting nginx:alpine-slim digest..."
+NGINX_DIGEST=$(get_image_digest "nginx:alpine-slim")
+echo "   $NGINX_DIGEST"
+
+echo ""
+echo "📝 Dockerfile to update:"
+echo ""
+echo "docker/Dockerfile should use:"
+echo "FROM ${PYTHON_DIGEST}"
+echo ""
+
+echo "💡 To update the Dockerfile:"
+echo "1. Edit docker/Dockerfile line 4"
+echo "2. Replace the existing FROM line with the digest above"
+echo ""
+echo "✅ Done! Your images are now pinned to specific versions."
+echo "   This prevents Docker Hub registry issues and ensures reproducible builds."
\ No newline at end of file
diff --git a/dockmon/scripts/update.sh b/dockmon/scripts/update.sh
new file mode 100755
index 0000000..cf74db4
--- /dev/null
+++ b/dockmon/scripts/update.sh
@@ -0,0 +1,234 @@
+#!/bin/bash
+
+# DockMon Update Script
+# Updates both the system and DockMon to latest versions
+# Place this in scripts/update.sh in your repository
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Functions for colored output
+print_info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+# Header
+echo -e "${GREEN}════════════════════════════════════════${NC}"
+echo -e "${GREEN}       DockMon System Update Tool       ${NC}"
+echo -e "${GREEN}════════════════════════════════════════${NC}"
+echo ""
+
+# Check if running as root
+if [ "$EUID" -ne 0 ]; then 
+    print_error "This script must be run as root!"
+    print_info "Try: sudo update"
+    exit 1
+fi
+
+# Step 1: Update Debian packages
+echo -e "${BLUE}Step 1: Updating Debian System${NC}"
+echo "════════════════════════════════════"
+print_info "Updating package lists..."
+apt-get update
+
+print_info "Upgrading installed packages..."
+DEBIAN_FRONTEND=noninteractive apt-get upgrade -y
+
+print_info "Performing distribution upgrade..."
+DEBIAN_FRONTEND=noninteractive apt-get dist-upgrade -y
+
+print_info "Removing unnecessary packages..."
+apt-get autoremove -y
+
+print_info "Cleaning package cache..."
+apt-get autoclean
+
+print_success "System update completed!"
+echo ""
+
+# Step 2: Update DockMon
+echo -e "${BLUE}Step 2: Updating DockMon${NC}"
+echo "════════════════════════════════════"
+
+# Check if DockMon directory exists
+if [ ! -d "/opt/dockmon" ]; then
+    print_error "DockMon directory not found at /opt/dockmon"
+    print_info "Attempting to clone repository..."
+    cd /opt
+    git clone https://github.com/darthnorse/dockmon.git
+    if [ $? -ne 0 ]; then
+        print_error "Failed to clone DockMon repository"
+        exit 1
+    fi
+fi
+
+# Navigate to DockMon directory
+cd /opt/dockmon
+
+# Store current version (if exists)
+if [ -f "src/index.html" ]; then
+    OLD_VERSION=$(grep -oP 'DockMon v\K[0-9.]+' src/index.html | head -1 || echo "unknown")
+else
+    OLD_VERSION="not installed"
+fi
+
+print_info "Current version: $OLD_VERSION"
+
+# Fetch latest changes
+print_info "Fetching latest updates from GitHub..."
+git fetch origin
+
+# Check if there are updates
+LOCAL=$(git rev-parse HEAD)
+REMOTE=$(git rev-parse origin/main)
+
+if [ "$LOCAL" = "$REMOTE" ]; then
+    print_info "DockMon is already up to date"
+else
+    print_info "Updates available, pulling latest version..."
+    
+    # Pull latest changes
+    git pull origin main
+    
+    if [ $? -ne 0 ]; then
+        print_warning "Git pull failed, attempting to reset..."
+        git reset --hard origin/main
+    fi
+    
+    # Get new version
+    NEW_VERSION=$(grep -oP 'DockMon v\K[0-9.]+' src/index.html | head -1 || echo "unknown")
+    print_success "Updated DockMon from v$OLD_VERSION to v$NEW_VERSION"
+fi
+
+# Update backend dependencies if needed
+print_info "Checking backend dependencies..."
+if [ -f "/opt/dockmon/backend/requirements.txt" ]; then
+    print_info "Updating Python dependencies..."
+    cd /opt/dockmon/backend
+
+    # Activate virtual environment
+    source venv/bin/activate
+
+    # Update pip packages
+    pip install --no-cache-dir -r requirements.txt --upgrade
+
+    print_success "Backend dependencies updated!"
+fi
+
+# Stop backend service before updating
+print_info "Stopping DockMon backend service..."
+systemctl stop dockmon-backend.service 2>/dev/null || true
+supervisorctl stop dockmon-backend 2>/dev/null || true
+
+# Update the web application
+print_info "Deploying updated application..."
+cp -f /opt/dockmon/src/index.html /var/www/html/index.html
+cp -rf /opt/dockmon/images /var/www/html/
+
+if [ $? -eq 0 ]; then
+    print_success "Frontend deployed successfully!"
+else
+    print_error "Failed to deploy frontend"
+    exit 1
+fi
+
+# Restart all services
+print_info "Restarting DockMon services..."
+
+# Start backend service
+systemctl start dockmon-backend.service
+if systemctl is-active --quiet dockmon-backend; then
+    print_success "Backend service started successfully!"
+else
+    print_warning "Backend service failed to start via systemd, trying supervisor..."
+    supervisorctl start dockmon-backend
+fi
+
+# Restart nginx
+systemctl restart nginx
+if systemctl is-active --quiet nginx; then
+    print_success "Frontend web server restarted successfully!"
+else
+    print_error "Web server failed to restart"
+    exit 1
+fi
+
+# Check backend health
+print_info "Checking backend health..."
+sleep 5
+if curl -s -f http://localhost:8080/api/settings > /dev/null; then
+    print_success "Backend API is responding!"
+else
+    print_warning "Backend API not responding immediately - may still be starting up"
+fi
+
+echo ""
+
+# Step 3: Check for script updates
+echo -e "${BLUE}Step 3: Checking for Script Updates${NC}"
+echo "════════════════════════════════════"
+
+# Check if this update script itself needs updating
+if [ -f "/opt/dockmon/scripts/update.sh" ]; then
+    if ! cmp -s "/opt/dockmon/scripts/update.sh" "/usr/local/bin/update"; then
+        print_info "Update script has a newer version, updating..."
+        cp -f /opt/dockmon/scripts/update.sh /usr/local/bin/update
+        chmod +x /usr/local/bin/update
+        print_success "Update script updated! Please run 'update' again if needed."
+    else
+        print_info "Update script is current"
+    fi
+fi
+
+echo ""
+
+# Summary
+echo -e "${GREEN}════════════════════════════════════════${NC}"
+echo -e "${GREEN}        Update Complete! ✅              ${NC}"
+echo -e "${GREEN}════════════════════════════════════════${NC}"
+echo ""
+echo -e "${BLUE}Summary:${NC}"
+echo "• System packages: Updated"
+echo "• DockMon application: $([ "$LOCAL" = "$REMOTE" ] && echo "Already current" || echo "Updated")"
+echo "• Backend API service: $(systemctl is-active --quiet dockmon-backend && echo "Running" || echo "Check logs")"
+echo "• Frontend web server: $(systemctl is-active --quiet nginx && echo "Running" || echo "Check logs")"
+echo ""
+echo -e "${BLUE}DockMon Access:${NC}"
+echo "• Web Interface: http://$(hostname -I | awk '{print $1}')"
+echo "• Backend API: http://$(hostname -I | awk '{print $1}'):8080"
+echo ""
+echo -e "${BLUE}Service Management:${NC}"
+echo "• Backend logs: journalctl -u dockmon-backend -f"
+echo "• Supervisor logs: tail -f /var/log/dockmon-backend.out.log"
+echo "• Service status: systemctl status dockmon-backend"
+echo ""
+
+# Check if reboot is required
+if [ -f /var/run/reboot-required ]; then
+    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    echo -e "${YELLOW}⚠️  REBOOT REQUIRED${NC}"
+    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
+    echo "A system reboot is required to complete updates."
+    echo "Please run: reboot"
+    echo ""
+fi
+
+exit 0
\ No newline at end of file
diff --git a/dockmon/src/css/main.css b/dockmon/src/css/main.css
new file mode 100644
index 0000000..022468a
--- /dev/null
+++ b/dockmon/src/css/main.css
@@ -0,0 +1,2494 @@
+        :root {
+            /* Modern color scheme */
+            --primary: #0084F4;
+            --primary-dark: #0066CC;
+            --primary-light: #E8F4FD;
+            --success: #00C48C;
+            --warning: #FFA26B;
+            --danger: #FF647C;
+            --dark: #1A1D29;
+            --dark-secondary: #252837;
+            --dark-tertiary: #2D3142;
+            --text-primary: #FFFFFF;
+            --text-secondary: #A0A3BD;
+            --text-tertiary: #6E7191;
+            --border: #353849;
+            --surface: #1E2139;
+            --surface-light: #262A41;
+            --background: #161821;
+            
+            /* Spacing */
+            --spacing-xs: 4px;
+            --spacing-sm: 8px;
+            --spacing-md: 16px;
+            --spacing-lg: 24px;
+            --spacing-xl: 32px;
+            --spacing-2xl: 48px;
+            
+            /* Transitions */
+            --transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
+        }
+
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', sans-serif;
+            background: var(--background);
+            color: var(--text-primary);
+            line-height: 1.6;
+            overflow-x: hidden;
+        }
+
+        /* Lucide Icons */
+        .lucide-icon, [data-lucide] {
+            display: inline-block;
+            vertical-align: middle;
+            width: 16px;
+            height: 16px;
+        }
+
+        /* Layout */
+        .app-layout {
+            display: flex;
+            height: 100vh;
+        }
+
+        /* Sidebar */
+        .sidebar {
+            width: 260px;
+            background: var(--dark);
+            border-right: 1px solid var(--border);
+            display: flex;
+            flex-direction: column;
+            transition: var(--transition);
+            z-index: 100;
+        }
+
+        .sidebar-header {
+            padding: var(--spacing-lg);
+            border-bottom: 1px solid var(--border);
+            display: flex;
+            align-items: center;
+            gap: var(--spacing-md);
+        }
+
+        .logo {
+            width: 36px;
+            height: 36px;
+            border-radius: 8px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .logo img {
+            width: 32px;
+            height: 32px;
+            border-radius: 6px;
+        }
+
+        .logo-text {
+            font-size: 26px;
+            font-weight: 600;
+            color: var(--text-primary);
+        }
+
+        .sidebar-nav {
+            flex: 1;
+            padding: var(--spacing-lg) 0;
+            overflow-y: auto;
+        }
+
+        .nav-section {
+            margin-bottom: var(--spacing-xl);
+        }
+
+        .nav-section-title {
+            padding: 0 var(--spacing-lg);
+            margin-bottom: var(--spacing-sm);
+            font-size: 11px;
+            font-weight: 600;
+            text-transform: uppercase;
+            letter-spacing: 1px;
+            color: var(--text-tertiary);
+        }
+
+        .nav-item {
+            display: flex;
+            align-items: center;
+            gap: var(--spacing-md);
+            padding: var(--spacing-md) var(--spacing-lg);
+            color: var(--text-secondary);
+            text-decoration: none;
+            transition: var(--transition);
+            cursor: pointer;
+            border: none;
+            background: none;
+            width: 100%;
+            font-size: 14px;
+            position: relative;
+        }
+
+        .nav-item::before {
+            content: '';
+            position: absolute;
+            left: 0;
+            top: 0;
+            bottom: 0;
+            width: 3px;
+            background: var(--primary);
+            opacity: 0;
+            transition: var(--transition);
+        }
+
+        .nav-item:hover {
+            background: var(--surface);
+            color: var(--text-primary);
+        }
+
+        .nav-item.active {
+            background: var(--surface);
+            color: var(--primary);
+        }
+
+        .nav-item.active::before {
+            opacity: 1;
+        }
+
+        .nav-icon {
+            width: 20px;
+            height: 20px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 16px;
+        }
+
+        .nav-badge {
+            margin-left: auto;
+            padding: 2px 8px;
+            background: var(--primary);
+            color: white;
+            border-radius: 10px;
+            font-size: 11px;
+            font-weight: 600;
+        }
+
+        /* Sidebar footer */
+        .sidebar-footer {
+            margin-top: auto;
+            padding: var(--spacing-md);
+            border-top: 1px solid var(--border);
+        }
+
+        .logout-item {
+            color: var(--text-secondary) !important;
+            transition: all 0.2s ease;
+        }
+
+        .logout-item:hover {
+            color: var(--danger) !important;
+            background: rgba(220, 53, 69, 0.1) !important;
+        }
+
+        /* Main Content */
+        .main-content {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            background: var(--background);
+            overflow: hidden;
+        }
+
+        /* Top Bar */
+        .topbar {
+            height: 60px;
+            background: var(--dark);
+            border-bottom: 1px solid var(--border);
+            display: flex;
+            align-items: center;
+            gap: var(--spacing-lg);
+            padding: 0 var(--spacing-xl);
+        }
+
+        .topbar-left {
+            display: flex;
+            align-items: center;
+            gap: var(--spacing-md);
+            flex: 0 0 auto;
+        }
+
+        .topbar-title {
+            font-size: 20px;
+            font-weight: 600;
+            color: var(--text-primary);
+            display: flex;
+            align-items: center;
+            gap: var(--spacing-md);
+        }
+
+        #quietHoursIndicator {
+            margin: 0 auto;
+        }
+
+        .topbar-actions {
+            display: flex;
+            align-items: center;
+            gap: var(--spacing-md);
+            margin-left: auto;
+        }
+
+        /* Content Area */
+        .content {
+            flex: 1;
+            padding: var(--spacing-lg) var(--spacing-xl);
+            overflow-y: auto;
+            overflow-x: hidden;
+        }
+
+        /* Cards */
+        .card {
+            background: var(--surface);
+            border: 1px solid var(--border);
+            border-radius: 8px;
+            padding: var(--spacing-lg);
+            margin-bottom: var(--spacing-lg);
+            transition: var(--transition);
+        }
+
+        .card:hover {
+            border-color: var(--primary);
+            box-shadow: 0 4px 12px rgba(0, 132, 244, 0.1);
+        }
+
+        .card-header {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            margin-bottom: var(--spacing-lg);
+            padding-bottom: var(--spacing-md);
+            border-bottom: 1px solid var(--border);
+        }
+
+        .card-title {
+            font-size: 16px;
+            font-weight: 600;
+            color: var(--text-primary);
+            display: flex;
+            align-items: center;
+            gap: var(--spacing-sm);
+        }
+
+        /* GridStack Overrides */
+        .grid-stack {
+            margin-bottom: var(--spacing-xl);
+        }
+
+        .grid-stack-item-content {
+            background: var(--surface);
+            border: 1px solid var(--border);
+            border-radius: 12px;
+            overflow: hidden;
+            display: flex;
+            flex-direction: column;
+            height: 100%;
+        }
+
+        .grid-stack-item.ui-draggable-dragging .grid-stack-item-content {
+            box-shadow: 0 10px 40px rgba(0, 0, 0, 0.5);
+            opacity: 0.8;
+        }
+
+        .grid-stack-item.ui-resizable-resizing .grid-stack-item-content {
+            opacity: 0.7;
+        }
+
+        .widget-header {
+            padding: var(--spacing-md) var(--spacing-lg);
+            border-bottom: 1px solid var(--border);
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            background: var(--dark-secondary);
+            cursor: move;
+            min-height: 50px;
+            flex-shrink: 0;
+        }
+
+        .widget-title {
+            font-size: 14px;
+            font-weight: 600;
+            color: var(--text-primary);
+            display: flex;
+            align-items: center;
+            gap: var(--spacing-sm);
+        }
+
+        /* Host Metrics Sparklines */
+        .host-metrics {
+            display: flex;
+            gap: 12px;
+            align-items: center;
+        }
+
+        .metric-sparkline {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            gap: 4px;
+        }
+
+        .metric-sparkline canvas {
+            background: var(--surface);
+            border-radius: 4px;
+            display: block;
+            width: 60px !important;
+            height: 20px !important;
+            max-width: 60px;
+            max-height: 20px;
+        }
+
+        .metric-label {
+            font-size: 10px;
+            color: var(--text-secondary);
+            font-weight: 500;
+            white-space: nowrap;
+        }
+
+        .widget-actions {
+            display: flex;
+            gap: var(--spacing-xs);
+        }
+
+        .widget-action {
+            width: 24px;
+            height: 24px;
+            border-radius: 6px;
+            background: transparent;
+            border: none;
+            color: var(--text-secondary);
+            cursor: pointer;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            transition: var(--transition);
+        }
+
+        .widget-action:hover {
+            background: var(--surface-light);
+            color: var(--text-primary);
+        }
+
+        .widget-action.lock-btn.locked {
+            color: var(--warning);
+        }
+
+        .widget-body {
+            flex: 1;
+            padding: var(--spacing-lg);
+            overflow: auto;
+        }
+
+        /* Stats Grid */
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(100px, 1fr));
+            gap: var(--spacing-sm);
+            height: 100%;
+            padding: 2px;
+        }
+
+        /* Responsive adjustments */
+        .grid-stack-item[gs-w="12"] .stats-grid {
+            grid-template-columns: repeat(4, 1fr);
+        }
+
+        .grid-stack-item[gs-w="8"] .stats-grid,
+        .grid-stack-item[gs-w="9"] .stats-grid,
+        .grid-stack-item[gs-w="10"] .stats-grid,
+        .grid-stack-item[gs-w="11"] .stats-grid {
+            grid-template-columns: repeat(2, 1fr);
+        }
+
+        .grid-stack-item[gs-w="4"] .stats-grid,
+        .grid-stack-item[gs-w="5"] .stats-grid,
+        .grid-stack-item[gs-w="6"] .stats-grid,
+        .grid-stack-item[gs-w="7"] .stats-grid {
+            grid-template-columns: repeat(2, 1fr);
+        }
+
+        .grid-stack-item[gs-w="3"] .stats-grid,
+        .grid-stack-item[gs-w="2"] .stats-grid {
+            grid-template-columns: 1fr;
+        }
+
+        /* Widget-specific styles */
+        .widget-hosts .hosts-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
+            gap: var(--spacing-md);
+        }
+
+        .grid-stack-item[gs-w="3"] .widget-hosts .hosts-grid,
+        .grid-stack-item[gs-w="4"] .widget-hosts .hosts-grid,
+        .grid-stack-item[gs-w="5"] .widget-hosts .hosts-grid,
+        .grid-stack-item[gs-w="6"] .widget-hosts .hosts-grid {
+            grid-template-columns: 1fr;
+        }
+
+        .grid-stack-item[gs-w="7"] .widget-hosts .hosts-grid,
+        .grid-stack-item[gs-w="8"] .widget-hosts .hosts-grid,
+        .grid-stack-item[gs-w="9"] .widget-hosts .hosts-grid,
+        .grid-stack-item[gs-w="10"] .widget-hosts .hosts-grid,
+        .grid-stack-item[gs-w="11"] .widget-hosts .hosts-grid,
+        .grid-stack-item[gs-w="12"] .widget-hosts .hosts-grid {
+            grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
+        }
+
+        /* Compact layout for smaller widgets */
+        .grid-stack-item[gs-h="2"] .widget-hosts .container-list {
+            max-height: 60px;
+            overflow-y: auto;
+        }
+
+        .grid-stack-item[gs-h="3"] .widget-hosts .container-list {
+            max-height: 90px;
+            overflow-y: auto;
+        }
+
+        .grid-stack-item[gs-h="4"] .widget-hosts .container-list {
+            max-height: 130px;
+            overflow-y: auto;
+        }
+
+        /* Make host cards more compact in small widgets */
+        .grid-stack-item[gs-w="3"] .host-card,
+        .grid-stack-item[gs-w="4"] .host-card {
+            padding: var(--spacing-sm);
+        }
+
+        .grid-stack-item[gs-w="3"] .host-header,
+        .grid-stack-item[gs-w="4"] .host-header {
+            margin-bottom: var(--spacing-sm);
+        }
+
+        .grid-stack-item[gs-w="3"] .container-item,
+        .grid-stack-item[gs-w="4"] .container-item {
+            padding: 4px 8px;
+        }
+
+        /* Ensure stats grid is always visible */
+        .grid-stack-item[gs-h="4"] .stats-grid,
+        .grid-stack-item[gs-h="5"] .stats-grid,
+        .grid-stack-item[gs-h="6"] .stats-grid {
+            align-content: center;
+            align-items: stretch;
+        }
+
+        /* Make stat cards smaller in compact widgets */
+        .grid-stack-item[gs-w="4"] .stat-card,
+        .grid-stack-item[gs-w="5"] .stat-card {
+            min-height: 60px;
+            padding: var(--spacing-sm);
+        }
+
+        .grid-stack-item[gs-w="4"] .stat-value,
+        .grid-stack-item[gs-w="5"] .stat-value {
+            font-size: 22px;
+        }
+
+        .grid-stack-item[gs-w="4"] .stat-label,
+        .grid-stack-item[gs-w="5"] .stat-label {
+            font-size: 10px;
+            margin-bottom: 4px;
+        }
+
+        /* Host card improvements */
+        .host-card {
+            background: var(--dark-secondary);
+            border: 1px solid var(--border);
+            border-radius: 8px;
+            padding: var(--spacing-md);
+            transition: var(--transition);
+        }
+
+        .host-card:hover {
+            border-color: var(--primary);
+            background: var(--surface);
+        }
+
+        .stat-card {
+            background: var(--surface);
+            border: 1px solid var(--border);
+            border-radius: 8px;
+            padding: var(--spacing-md);
+            position: relative;
+            overflow: hidden;
+            transition: var(--transition);
+            display: flex;
+            flex-direction: column;
+            justify-content: center;
+            align-items: center;
+            text-align: center;
+            min-height: 80px;
+        }
+
+        .stat-card:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
+        }
+
+        .stat-card::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: 0;
+            right: 0;
+            height: 3px;
+            background: linear-gradient(90deg, var(--primary), var(--primary-dark));
+        }
+
+        .stat-icon {
+            width: 40px;
+            height: 40px;
+            background: var(--primary);
+            background: linear-gradient(135deg, var(--primary), var(--primary-dark));
+            border-radius: 8px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 20px;
+            margin-bottom: var(--spacing-md);
+        }
+
+        .stat-label {
+            font-size: 12px;
+            color: var(--text-secondary);
+            text-transform: uppercase;
+            letter-spacing: 0.5px;
+            font-weight: 500;
+            margin-bottom: var(--spacing-xs);
+            text-align: center;
+        }
+
+        .stat-value {
+            font-size: 28px;
+            font-weight: 700;
+            color: var(--text-primary);
+            line-height: 1;
+            text-align: center;
+        }
+
+        .stat-change {
+            position: absolute;
+            top: var(--spacing-md);
+            right: var(--spacing-md);
+            padding: 4px 8px;
+            background: var(--success);
+            color: white;
+            border-radius: 4px;
+            font-size: 12px;
+            font-weight: 600;
+        }
+
+        .stat-change.negative {
+            background: var(--danger);
+        }
+
+        /* Buttons */
+        .btn {
+            padding: 10px 20px;
+            border-radius: 6px;
+            border: none;
+            font-size: 14px;
+            font-weight: 500;
+            cursor: pointer;
+            transition: var(--transition);
+            display: inline-flex;
+            align-items: center;
+            gap: var(--spacing-sm);
+        }
+
+        .btn-primary {
+            background: var(--primary);
+            color: white;
+        }
+
+        .btn-primary:hover {
+            background: var(--primary-dark);
+            transform: translateY(-1px);
+        }
+
+        .btn-secondary {
+            background: var(--surface-light);
+            color: var(--text-primary);
+            border: 1px solid var(--border);
+        }
+
+        .btn-secondary:hover {
+            background: var(--dark-tertiary);
+            border-color: var(--primary);
+        }
+
+        .btn-danger {
+            background: var(--danger);
+            color: white;
+        }
+
+        .btn-danger:hover {
+            background: #d32f2f;
+            transform: translateY(-1px);
+        }
+
+        .btn-success {
+            background: var(--success);
+            color: white;
+        }
+
+        .btn-danger {
+            background: var(--danger);
+            color: white;
+        }
+
+        .btn-icon {
+            padding: 8px;
+            border-radius: 6px;
+            background: var(--surface-light);
+            border: 1px solid var(--border);
+            cursor: pointer;
+            transition: var(--transition);
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            color: var(--text-secondary);
+        }
+
+        .btn-icon:hover {
+            background: var(--dark-tertiary);
+            border-color: var(--primary);
+            color: var(--text-primary);
+        }
+
+        /* Host Grid */
+        .hosts-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(400px, 1fr));
+            gap: var(--spacing-lg);
+        }
+
+        .host-card {
+            background: var(--surface);
+            border: 1px solid var(--border);
+            border-radius: 8px;
+            overflow: hidden;
+            transition: var(--transition);
+        }
+
+        .host-card:hover {
+            border-color: var(--primary);
+            box-shadow: 0 4px 12px rgba(0, 132, 244, 0.1);
+        }
+
+        .host-header {
+            padding: var(--spacing-md) var(--spacing-lg);
+            background: var(--surface-light);
+            border-bottom: 1px solid var(--border);
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+        }
+
+        .host-name {
+            font-weight: 600;
+            color: var(--text-primary);
+            display: flex;
+            align-items: center;
+            gap: var(--spacing-sm);
+        }
+
+        .host-status {
+            padding: 4px 12px;
+            border-radius: 4px;
+            font-size: 12px;
+            font-weight: 600;
+            text-transform: uppercase;
+        }
+
+        .host-status-dot {
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            display: inline-block;
+            margin-left: 4px;
+            flex-shrink: 0;
+        }
+
+        .host-status-dot.status-online {
+            background: var(--success);
+        }
+
+        .host-status-dot.status-offline {
+            background: var(--danger);
+        }
+
+        .status-online {
+            background: rgba(0, 196, 140, 0.1);
+            color: var(--success);
+        }
+
+        .status-offline {
+            background: rgba(255, 100, 124, 0.1);
+            color: var(--danger);
+        }
+
+        .status-starting {
+            background: rgba(144, 238, 144, 0.1);
+            color: #90ee90;
+            font-style: italic;
+        }
+
+        .status-stopping {
+            background: rgba(255, 165, 0, 0.1);
+            color: #ffa500;
+            font-style: italic;
+        }
+
+        .security-warning {
+            color: #ff6b35;
+            margin-left: 8px;
+            font-size: 14px;
+            cursor: help;
+        }
+
+        .security-status {
+            font-size: 9px;
+            font-weight: 600;
+            padding: 2px 6px;
+            border-radius: 8px;
+            text-transform: uppercase;
+            letter-spacing: 0.3px;
+        }
+
+        .security-status.secure {
+            color: var(--success);
+            background-color: rgba(34, 197, 94, 0.1);
+        }
+
+        .security-status.insecure {
+            color: #e67e22;
+            background-color: rgba(230, 126, 34, 0.1);
+        }
+
+        .security-alert {
+            background: linear-gradient(135deg, #ff6b35, #f7931e);
+            color: white;
+            padding: 12px;
+            border-radius: 8px;
+            margin-bottom: 15px;
+            border-left: 4px solid #e55039;
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+
+        .security-alert strong {
+            font-weight: 600;
+        }
+
+        .form-input[name$="-text"] {
+            font-family: 'Courier New', monospace;
+            font-size: 12px;
+            line-height: 1.4;
+            resize: vertical;
+            min-height: 80px;
+        }
+
+        .form-input[name$="-text"]::placeholder {
+            font-family: inherit;
+            color: var(--text-tertiary);
+            opacity: 0.7;
+        }
+
+        /* Container List */
+        .container-list {
+            padding: var(--spacing-sm);
+        }
+
+        .container-item {
+            padding: var(--spacing-sm);
+            background: var(--dark);
+            border-radius: 6px;
+            margin-bottom: var(--spacing-sm);
+            display: grid;
+            grid-template-columns: 1fr 145px auto 80px;
+            align-items: center;
+            gap: var(--spacing-xs);
+            transition: var(--transition);
+            cursor: pointer;
+        }
+
+        .container-item:hover {
+            background: var(--surface-light);
+            transform: translateX(4px);
+        }
+
+        .container-item:last-child {
+            margin-bottom: 0;
+        }
+
+        .container-info {
+            display: flex;
+            align-items: center;
+            gap: var(--spacing-md);
+            min-width: 0;
+        }
+
+        .container-icon {
+            width: 32px;
+            height: 32px;
+            border-radius: 6px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 16px;
+        }
+
+        .container-running {
+            background: rgba(0, 196, 140, 0.2);
+            color: var(--success);
+        }
+
+        .container-stopped {
+            background: rgba(255, 100, 124, 0.2);
+            color: var(--danger);
+        }
+
+        .container-exited {
+            background: rgba(255, 100, 124, 0.2);
+            color: var(--danger);
+        }
+
+        .container-paused {
+            background: rgba(255, 162, 107, 0.2);
+            color: var(--warning);
+        }
+
+        .container-details {
+            flex: 1;
+        }
+
+        .container-name {
+            font-size: 14px;
+            font-weight: 500;
+            color: var(--text-primary);
+            margin-bottom: 2px;
+        }
+
+        .container-id {
+            font-size: 12px;
+            color: var(--text-tertiary);
+            font-family: 'Monaco', 'Courier New', monospace;
+        }
+
+        .container-stats {
+            width: 160px;
+            display: flex;
+            gap: 8px;
+            align-items: center;
+            justify-content: flex-end;
+            flex-shrink: 0;
+        }
+
+        .container-stats-charts {
+            display: flex;
+            flex-direction: column;
+            gap: 2px;
+            flex-shrink: 0;
+        }
+
+        .container-stats-values {
+            display: flex;
+            flex-direction: column;
+            gap: 2px;
+            font-size: 8px;
+            color: var(--text-secondary);
+            min-width: 75px;
+        }
+
+        .container-stats-values > div {
+            white-space: nowrap;
+            line-height: 12px;
+        }
+
+        .container-info {
+            flex: 1;
+            min-width: 0;
+            cursor: pointer;
+        }
+
+        .container-icon {
+            pointer-events: none;
+        }
+
+        .container-details {
+            pointer-events: none;
+        }
+
+        .container-actions {
+            display: contents;
+            pointer-events: auto;
+        }
+
+        .container-state {
+            padding: 4px 10px;
+            border-radius: 4px;
+            font-size: 11px;
+            font-weight: 600;
+            text-transform: uppercase;
+            letter-spacing: 0.5px;
+            text-align: center;
+            white-space: nowrap;
+        }
+
+        /* Auto Restart Toggle - Dashboard (minimal style) */
+        .auto-restart-toggle {
+            display: flex;
+            align-items: center;
+            gap: 3px;
+            cursor: pointer;
+            transition: var(--transition);
+        }
+
+        .auto-restart-toggle.enabled {
+            color: var(--primary);
+        }
+
+        /* Auto Restart Toggle - Modal (button style) */
+        .modal .auto-restart-toggle {
+            display: inline-flex;
+            align-items: center;
+            gap: 8px;
+            padding: 10px 18px;
+            background: var(--dark-secondary);
+            border: 1px solid var(--border);
+            border-radius: 6px;
+            color: var(--text-primary);
+            font-size: 14px;
+            font-weight: 500;
+            cursor: pointer;
+            transition: var(--transition);
+        }
+
+        .modal .auto-restart-toggle:hover {
+            background: var(--dark-tertiary);
+            border-color: var(--border-hover);
+        }
+
+        .modal .auto-restart-toggle.enabled {
+            background: rgba(59, 130, 246, 0.1);
+            border-color: var(--primary);
+            color: var(--primary);
+        }
+
+        .modal .auto-restart-toggle.enabled:hover {
+            background: rgba(59, 130, 246, 0.15);
+        }
+
+        .toggle-switch {
+            position: relative;
+            width: 36px;
+            height: 20px;
+            background: var(--dark-tertiary);
+            border-radius: 20px;
+            cursor: pointer;
+            transition: var(--transition);
+        }
+
+        .toggle-switch.active {
+            background: var(--primary);
+        }
+
+        .toggle-switch::after {
+            content: '';
+            position: absolute;
+            width: 16px;
+            height: 16px;
+            background: white;
+            border-radius: 50%;
+            top: 2px;
+            left: 2px;
+            transition: transform 0.2s ease;
+        }
+
+        .toggle-switch.active::after {
+            transform: translateX(16px);
+        }
+
+        /* Modal */
+        .modal {
+            display: none;
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: rgba(0, 0, 0, 0.7);
+            backdrop-filter: blur(5px);
+            z-index: 1000;
+        }
+
+        .modal.active {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .modal-content {
+            background: var(--surface);
+            border: 1px solid var(--border);
+            border-radius: 12px;
+            padding: var(--spacing-xl);
+            max-width: 600px;
+            width: 90%;
+            max-height: 80vh;
+            overflow-y: auto;
+            animation: modalSlideIn 0.3s ease;
+            position: relative;
+        }
+
+        .modal-content.resizable {
+            resize: both;
+            overflow: auto;
+            min-width: 400px;
+            min-height: 300px;
+            max-width: 90vw;
+            max-height: 90vh;
+        }
+
+        .resize-handle {
+            position: absolute;
+            bottom: 0;
+            right: 0;
+            width: 20px;
+            height: 20px;
+            cursor: nwse-resize;
+            opacity: 0.5;
+        }
+
+        .resize-handle::after {
+            content: '';
+            position: absolute;
+            bottom: 3px;
+            right: 3px;
+            width: 5px;
+            height: 5px;
+            border-right: 2px solid var(--text-tertiary);
+            border-bottom: 2px solid var(--text-tertiary);
+        }
+
+        @keyframes modalSlideIn {
+            from {
+                opacity: 0;
+                transform: translateY(-30px);
+            }
+            to {
+                opacity: 1;
+                transform: translateY(0);
+            }
+        }
+
+        .modal-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: var(--spacing-lg);
+            padding-bottom: var(--spacing-md);
+            border-bottom: 1px solid var(--border);
+        }
+
+        .modal-title {
+            font-size: 20px;
+            font-weight: 600;
+            color: var(--text-primary);
+        }
+
+        .modal-close {
+            width: 32px;
+            height: 32px;
+            border-radius: 6px;
+            border: 1px solid var(--border);
+            background: var(--surface-light);
+            cursor: pointer;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            transition: var(--transition);
+        }
+
+        .modal-close:hover {
+            background: var(--danger);
+            border-color: var(--danger);
+            transform: rotate(90deg);
+        }
+
+        /* Tab styles */
+        .tab-content {
+            animation: fadeIn 0.3s ease;
+        }
+
+        .tab-content pre {
+            margin: 0;
+            white-space: pre-wrap;
+            word-break: break-all;
+        }
+
+        #container-logs {
+            scrollbar-width: thin;
+            scrollbar-color: var(--border) var(--dark);
+        }
+
+        #container-logs::-webkit-scrollbar {
+            width: 8px;
+        }
+
+        #container-logs::-webkit-scrollbar-track {
+            background: var(--dark);
+        }
+
+        #container-logs::-webkit-scrollbar-thumb {
+            background: var(--border);
+            border-radius: 4px;
+        }
+
+        #container-logs::-webkit-scrollbar-thumb:hover {
+            background: var(--primary);
+        }
+
+        /* Form Elements */
+        .form-group {
+            margin-bottom: var(--spacing-lg);
+        }
+
+        .form-label {
+            display: block;
+            margin-bottom: var(--spacing-sm);
+            font-size: 14px;
+            font-weight: 500;
+            color: var(--text-secondary);
+        }
+
+        .form-input {
+            width: 100%;
+            padding: 10px 14px;
+            background: var(--dark);
+            border: 1px solid var(--border);
+            border-radius: 6px;
+            color: var(--text-primary);
+            font-size: 14px;
+            transition: var(--transition);
+        }
+
+        .form-input:focus {
+            outline: none;
+            border-color: var(--primary);
+            box-shadow: 0 0 0 3px rgba(0, 132, 244, 0.1);
+        }
+
+        .checkbox-group {
+            display: flex;
+            flex-wrap: wrap;
+            gap: var(--spacing-md);
+            padding: var(--spacing-md);
+            background: var(--dark);
+            border-radius: 6px;
+        }
+
+        .checkbox-item {
+            display: flex;
+            align-items: center;
+            gap: var(--spacing-sm);
+            color: var(--text-secondary);
+        }
+
+        .checkbox-item input[type="checkbox"] {
+            width: 18px;
+            height: 18px;
+            cursor: pointer;
+        }
+
+        /* Settings Section */
+        .settings-section {
+            background: var(--dark);
+            padding: var(--spacing-lg);
+            border-radius: 8px;
+            margin-bottom: var(--spacing-lg);
+        }
+
+        .settings-row {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            padding: var(--spacing-md) 0;
+            border-bottom: 1px solid var(--border);
+        }
+
+        .settings-row:last-child {
+            border-bottom: none;
+        }
+
+        .settings-label {
+            display: flex;
+            flex-direction: column;
+            gap: var(--spacing-xs);
+        }
+
+        .settings-title {
+            font-weight: 500;
+            color: var(--text-primary);
+        }
+
+        .settings-description {
+            font-size: 12px;
+            color: var(--text-tertiary);
+        }
+
+        .settings-value {
+            display: flex;
+            align-items: center;
+            gap: var(--spacing-md);
+        }
+
+        .number-input {
+            width: 80px;
+            padding: 8px 12px;
+            background: var(--surface);
+            border: 1px solid var(--border);
+            border-radius: 6px;
+            color: var(--text-primary);
+            text-align: center;
+            font-size: 14px;
+            font-weight: 500;
+            transition: var(--transition);
+        }
+
+        .number-input:focus {
+            outline: none;
+            border-color: var(--primary);
+        }
+
+
+        /* Alert Rules and Hosts List Cards */
+        .list-card {
+            background: var(--dark);
+            padding: var(--spacing-md);
+            border-radius: 8px;
+            margin-bottom: var(--spacing-md);
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            transition: var(--transition);
+        }
+
+        .list-card:hover {
+            background: var(--surface-light);
+        }
+
+        .list-card-info {
+            flex: 1;
+        }
+
+        .list-card-title {
+            font-weight: 500;
+            color: var(--text-primary);
+            margin-bottom: var(--spacing-xs);
+        }
+
+        .list-card-details {
+            font-size: 13px;
+            color: var(--text-tertiary);
+        }
+
+        .alert-channels {
+            display: flex;
+            gap: var(--spacing-sm);
+            margin-top: var(--spacing-sm);
+        }
+
+        .list-card-actions {
+            display: flex;
+            gap: var(--spacing-xs);
+        }
+
+        .channel-badge {
+            padding: 2px 8px;
+            border-radius: 4px;
+            font-size: 11px;
+            font-weight: 600;
+        }
+
+        .channel-telegram {
+            background: rgba(0, 136, 204, 0.2);
+            color: #0088cc;
+        }
+
+        .channel-discord {
+            background: rgba(88, 101, 242, 0.2);
+            color: #5865F2;
+        }
+
+        .channel-pushover {
+            background: rgba(79, 195, 247, 0.2);
+            color: #4FC3F7;
+        }
+
+        /* Toast */
+        .toast {
+            position: fixed;
+            bottom: var(--spacing-xl);
+            right: var(--spacing-xl);
+            background: var(--surface-light);
+            border: 1px solid var(--border);
+            color: var(--text-primary);
+            padding: var(--spacing-md) var(--spacing-lg);
+            border-radius: 6px;
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
+            z-index: 2000;
+            display: none;
+            animation: toastSlideIn 0.3s ease;
+        }
+
+        .toast.show {
+            display: block;
+        }
+
+        @keyframes toastSlideIn {
+            from {
+                opacity: 0;
+                transform: translateX(100px);
+            }
+            to {
+                opacity: 1;
+                transform: translateX(0);
+            }
+        }
+
+        /* Mobile Navigation - Hidden by default on desktop */
+        .mobile-bottom-nav {
+            display: none;
+        }
+
+        /* Responsive */
+        @media (max-width: 768px) {
+            /* Hide sidebar completely on mobile */
+            .sidebar {
+                display: none !important;
+            }
+
+            /* Remove main content margin since sidebar is gone */
+            .main-content {
+                margin-left: 0 !important;
+                padding-bottom: 80px !important; /* Space for bottom nav */
+            }
+
+            /* Hide top-right controls on mobile */
+            .header-controls .refresh-btn,
+            .header-controls .add-host-btn,
+            .user-menu,
+            .hamburger-menu {
+                display: none !important;
+            }
+
+            /* Hide hamburger menu on mobile */
+            .menu-toggle {
+                display: none !important;
+            }
+
+            /* Hide topbar actions (refresh, add host buttons) on mobile */
+            .topbar-actions {
+                display: none !important;
+            }
+
+            /* Change Dashboard to DockMon on mobile */
+            .topbar-title {
+                font-size: 0 !important;
+            }
+
+            .topbar-title::before {
+                content: "DockMon";
+                font-size: 1.5rem;
+                font-weight: 600;
+                color: inherit;
+            }
+
+            .hosts-grid {
+                grid-template-columns: 1fr;
+            }
+
+            /* Don't override stats-grid on mobile - let the widget width rules handle it */
+
+            /* Mobile Dashboard Optimizations */
+            .grid-stack {
+                position: static !important;
+                display: flex !important;
+                flex-direction: column !important;
+                gap: 8px !important;
+                padding: 8px !important;
+            }
+
+            .grid-stack-item {
+                position: static !important;
+                width: 100% !important;
+                height: auto !important;
+                transform: none !important;
+                margin: 0 !important;
+            }
+
+            .grid-stack-item-content {
+                position: static !important;
+                width: 100% !important;
+                height: auto !important;
+                min-height: auto !important;
+            }
+
+            /* Hide resize handles on mobile */
+            .ui-resizable-handle {
+                display: none !important;
+            }
+
+            /* Make dragging less sensitive on mobile */
+            .grid-stack-item.ui-draggable-dragging {
+                opacity: 0.5;
+            }
+
+            /* Bigger touch targets */
+            .container-item {
+                padding: 12px 8px;
+                min-height: 48px;
+            }
+
+            .toggle-switch {
+                width: 44px;
+                height: 24px;
+            }
+
+            .toggle-switch::after {
+                width: 20px;
+                height: 20px;
+            }
+
+            /* Stats widget on mobile */
+            .grid-stack-item[data-widget-id="stats"] {
+                order: -1;
+            }
+
+            /* Better spacing for widget headers */
+            .widget-header {
+                padding: 12px;
+            }
+
+            .widget-title {
+                font-size: 13px;
+                gap: 4px !important;
+            }
+
+            .host-metrics {
+                gap: 4px !important;
+            }
+
+            .host-metrics canvas {
+                width: 40px !important;
+                height: 16px !important;
+            }
+
+            .metric-label {
+                font-size: 8px !important;
+                white-space: nowrap !important;
+            }
+
+            /* Simplified mobile container display - name + status only */
+            .container-item {
+                flex-direction: row !important;
+                align-items: center !important;
+                justify-content: flex-start !important;
+                padding: 12px 8px !important;
+                margin-bottom: 4px !important;
+                border-radius: 8px;
+                background: rgba(255, 255, 255, 0.05);
+                grid-template-columns: 1fr 70px 0px !important;
+            }
+
+            .container-info {
+                flex: 0 1 auto !important;
+                margin: 0 !important;
+                min-width: 0 !important;
+            }
+
+            .container-item .container-icon {
+                display: none !important;
+            }
+
+            .container-item .container-stats {
+                order: 3 !important;
+                width: 90px !important;
+                gap: 2px !important;
+                margin-left: auto !important;
+            }
+
+            .container-item .container-stats-charts {
+                gap: 1px !important;
+            }
+
+            .container-item .container-stats-charts canvas {
+                width: 26px !important;
+                height: 8px !important;
+            }
+
+            .container-item .container-stats-values {
+                font-size: 6px !important;
+                min-width: 55px !important;
+                gap: 1px !important;
+            }
+
+            .container-item .container-stats-values > div {
+                line-height: 8px !important;
+            }
+
+            .container-name {
+                font-size: 12px !important;
+                font-weight: 500 !important;
+                white-space: nowrap !important;
+                overflow: hidden !important;
+                text-overflow: ellipsis !important;
+                margin: 0 !important;
+                line-height: 1.2 !important;
+            }
+
+            /* Container status dot - inline with container name */
+            .container-status-dot {
+                display: inline-block;
+                width: 8px;
+                height: 8px;
+                border-radius: 50%;
+                flex-shrink: 0;
+            }
+
+            .container-status-dot.status-running {
+                background: #10b981; /* Green */
+            }
+
+            .container-status-dot.status-stopped,
+            .container-status-dot.status-exited {
+                background: #ef4444; /* Red */
+            }
+
+            .container-status-dot.status-restarting {
+                background: #f59e0b; /* Yellow */
+            }
+
+            .container-status-dot.status-error,
+            .container-status-dot.status-dead {
+                background: #ef4444; /* Red */
+            }
+
+            /* Hide clutter on mobile - but only in container list, not in modal */
+            .container-item .container-id,
+            .container-item .container-icon,
+            .container-item .container-controls,
+            .container-item .container-actions,
+            .container-item .container-state,
+            .container-item .auto-restart-toggle,
+            .container-item .toggle-switch,
+            .container-item button,
+            .container-item .btn {
+                display: none !important;
+            }
+
+            /* Show only status badge */
+            .status-badge {
+                font-size: 11px !important;
+                padding: 4px 8px !important;
+                border-radius: 12px !important;
+                font-weight: 600 !important;
+                text-transform: uppercase !important;
+                letter-spacing: 0.5px !important;
+                margin-left: 8px !important;
+            }
+
+            /* Ensure container actions are visible in modal on mobile */
+            .modal .container-actions {
+                display: flex !important;
+                gap: 10px !important;
+                flex-wrap: wrap !important;
+                margin-top: 15px !important;
+            }
+
+            /* Make action buttons mobile-friendly */
+            .modal .container-actions .btn {
+                display: flex !important;
+                align-items: center !important;
+                gap: 5px !important;
+                padding: 10px 15px !important;
+                font-size: 14px !important;
+                min-height: 44px !important; /* iOS touch target size */
+            }
+
+            /* Make auto-restart toggle visible and touch-friendly in modal */
+            .modal .auto-restart-toggle {
+                display: flex !important;
+                align-items: center !important;
+                padding: 10px 15px !important;
+                min-height: 44px !important;
+                font-size: 14px !important;
+                cursor: pointer !important;
+            }
+
+            /* Make host widgets full width on mobile */
+            .host-widget {
+                width: 100% !important;
+                margin-bottom: 12px !important;
+            }
+
+            .host-widget .container-list {
+                max-height: none !important;
+            }
+
+            /* Better host widget styling */
+            .host-widget .widget-content {
+                padding: 8px !important;
+            }
+
+            /* Mobile bottom navigation */
+            .mobile-bottom-nav {
+                display: flex !important;
+                position: fixed;
+                bottom: 0;
+                left: 0;
+                right: 0;
+                background: rgba(30, 41, 59, 0.95);
+                backdrop-filter: blur(10px);
+                border-top: 1px solid rgba(255, 255, 255, 0.1);
+                padding: 8px 0;
+                z-index: 1000;
+                height: 70px;
+                align-items: center;
+                justify-content: space-around;
+            }
+
+            .mobile-nav-item {
+                display: flex;
+                flex-direction: column;
+                align-items: center;
+                padding: 8px 12px;
+                cursor: pointer;
+                transition: all 0.2s ease;
+                border-radius: 8px;
+                min-width: 60px;
+                position: relative;
+            }
+
+            .mobile-nav-item:hover,
+            .mobile-nav-item.active {
+                background: rgba(59, 130, 246, 0.1);
+                color: #3b82f6;
+            }
+
+            .mobile-nav-icon {
+                font-size: 20px;
+                margin-bottom: 4px;
+            }
+
+            .mobile-nav-label {
+                font-size: 11px;
+                font-weight: 500;
+                text-transform: uppercase;
+                letter-spacing: 0.5px;
+            }
+
+            /* More menu dropdown */
+            .more-menu {
+                position: absolute;
+                bottom: 100%;
+                right: 0;
+                background: rgba(30, 41, 59, 0.95);
+                backdrop-filter: blur(10px);
+                border: 1px solid rgba(255, 255, 255, 0.1);
+                border-radius: 8px;
+                padding: 8px 0;
+                margin-bottom: 8px;
+                min-width: 140px;
+                display: none;
+                box-shadow: 0 10px 25px rgba(0, 0, 0, 0.3);
+            }
+
+            .more-menu.show {
+                display: block;
+            }
+
+            .more-menu-item {
+                padding: 12px 16px;
+                cursor: pointer;
+                transition: background 0.2s ease;
+                font-size: 14px;
+                display: flex;
+                align-items: center;
+                gap: 8px;
+            }
+
+            .more-menu-item:hover {
+                background: rgba(255, 255, 255, 0.1);
+            }
+
+            .more-menu-item i {
+                font-size: 16px;
+                width: 16px;
+            }
+
+            /* Hide desktop bottom nav on mobile */
+            .mobile-bottom-nav {
+                display: none;
+            }
+
+            /* Reduce font sizes globally on mobile */
+            .modal-content {
+                font-size: 12px !important;
+            }
+
+            .modal h2,
+            .modal h3 {
+                font-size: 16px !important;
+            }
+
+            .modal .tab-button {
+                font-size: 12px !important;
+                padding: 8px 12px !important;
+            }
+
+            .modal .stat-card h3 {
+                font-size: 11px !important;
+            }
+
+            .modal .stat-card {
+                padding: 12px !important;
+            }
+
+            /* Host management list and Alert rules (both use .list-card) */
+            .list-card {
+                padding: 12px !important;
+            }
+
+            .list-card-title {
+                font-size: 14px !important;
+            }
+
+            .list-card-details {
+                font-size: 11px !important;
+            }
+
+            /* Alert notifications list */
+            .alert-item {
+                font-size: 11px !important;
+                padding: 10px !important;
+            }
+
+            /* Container modal stats tab - single column on mobile */
+            .stats-tab-grid {
+                grid-template-columns: 1fr !important;
+            }
+
+            .alert-item .alert-message {
+                font-size: 11px !important;
+            }
+
+            .alert-item .alert-time {
+                font-size: 9px !important;
+            }
+
+            /* Event viewer */
+            .event-item {
+                font-size: 11px !important;
+                padding: 10px !important;
+            }
+
+            .event-item .event-type {
+                font-size: 10px !important;
+            }
+
+            .event-item .event-time {
+                font-size: 9px !important;
+            }
+
+            .event-message {
+                font-size: 11px !important;
+            }
+
+            /* General list items */
+            .list-item {
+                font-size: 12px !important;
+                padding: 10px !important;
+            }
+
+            /* Form labels and inputs */
+            label {
+                font-size: 12px !important;
+            }
+
+            input,
+            select,
+            textarea {
+                font-size: 12px !important;
+            }
+
+            /* Buttons */
+            .btn,
+            button {
+                font-size: 12px !important;
+                padding: 8px 12px !important;
+            }
+
+            /* Table text */
+            table {
+                font-size: 11px !important;
+            }
+
+            th {
+                font-size: 11px !important;
+            }
+
+            td {
+                font-size: 11px !important;
+            }
+        }
+
+        /* Show mobile nav only on mobile */
+        @media (max-width: 768px) {
+            .mobile-bottom-nav {
+                display: flex !important;
+            }
+        }
+
+        /* Page Sections */
+        .page-section {
+            display: none;
+        }
+
+        .page-section.active {
+            display: block;
+            animation: fadeIn 0.3s ease;
+        }
+
+        @keyframes fadeIn {
+            from { opacity: 0; }
+            to { opacity: 1; }
+        }
+
+        /* Mobile Menu Toggle */
+        .menu-toggle {
+            display: none;
+            padding: 8px;
+            background: var(--surface-light);
+            border: 1px solid var(--border);
+            border-radius: 6px;
+            cursor: pointer;
+        }
+
+        @media (max-width: 768px) {
+            .menu-toggle {
+                display: flex;
+            }
+        }
+
+        /* ==================== Event Log Styles ==================== */
+
+        .event-filters {
+            padding: var(--spacing-lg);
+            border-bottom: 1px solid var(--border);
+            background: var(--surface);
+        }
+
+        .filter-row {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: var(--spacing-md);
+        }
+
+        .filter-group {
+            display: flex;
+            flex-direction: column;
+            gap: var(--spacing-xs);
+        }
+
+        .filter-group label {
+            font-size: 12px;
+            font-weight: 500;
+            color: var(--text-secondary);
+            text-transform: uppercase;
+            letter-spacing: 0.5px;
+        }
+
+        .filter-group select,
+        .filter-group input {
+            padding: 8px 12px;
+            background: var(--dark);
+            border: 1px solid var(--border);
+            border-radius: 6px;
+            color: var(--text-primary);
+            font-size: 14px;
+            transition: var(--transition);
+        }
+
+        .filter-group select:focus,
+        .filter-group input:focus {
+            outline: none;
+            border-color: var(--primary);
+            background: var(--dark-secondary);
+        }
+
+        .filter-search {
+            grid-column: span 2;
+        }
+
+        /* Multi-select dropdown styles */
+        .multiselect {
+            position: relative;
+        }
+
+        .multiselect-trigger {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            padding: 8px 12px;
+            background: var(--dark);
+            border: 1px solid var(--border);
+            border-radius: 6px;
+            color: var(--text-primary);
+            font-size: 14px;
+            cursor: pointer;
+            transition: var(--transition);
+        }
+
+        .multiselect-trigger:hover {
+            border-color: var(--primary);
+            background: var(--dark-secondary);
+        }
+
+        .multiselect-trigger svg {
+            width: 16px;
+            height: 16px;
+            transition: transform 0.2s ease;
+        }
+
+        .multiselect.open .multiselect-trigger svg {
+            transform: rotate(180deg);
+        }
+
+        .multiselect-dropdown {
+            display: none;
+            position: absolute;
+            top: 100%;
+            left: 0;
+            right: 0;
+            margin-top: 4px;
+            background: var(--surface);
+            border: 1px solid var(--border);
+            border-radius: 6px;
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
+            max-height: 250px;
+            overflow-y: auto;
+            z-index: 1000;
+        }
+
+        .multiselect.open .multiselect-dropdown {
+            display: block;
+        }
+
+        .multiselect-dropdown label {
+            display: flex;
+            align-items: center;
+            padding: 8px 12px;
+            cursor: pointer;
+            transition: background 0.2s ease;
+            font-size: 14px;
+            font-weight: normal;
+            text-transform: none;
+            letter-spacing: normal;
+            color: var(--text-primary);
+        }
+
+        .multiselect-dropdown label:hover {
+            background: var(--dark);
+        }
+
+        .multiselect-dropdown input[type="checkbox"] {
+            margin-right: 8px;
+            cursor: pointer;
+        }
+
+        .multiselect-label {
+            flex: 1;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+        }
+
+        .events-list {
+            padding: var(--spacing-md) 0;
+            max-height: calc(100vh - 400px);
+            min-height: 500px;
+            overflow-y: auto;
+            background: var(--dark);
+            font-family: 'Monaco', 'Menlo', 'Consolas', monospace;
+            font-size: 13px;
+            line-height: 1.6;
+            text-align: left !important;
+            width: 100%;
+            direction: ltr;
+        }
+
+        .event-line {
+            display: block;
+            padding: 2px 0;
+            color: var(--text-secondary);
+            transition: background 0.1s ease;
+            text-align: left !important;
+            white-space: nowrap;
+            overflow-x: auto;
+        }
+
+        .event-line > span {
+            display: inline-block;
+            margin-right: 8px;
+            vertical-align: middle;
+        }
+
+        .event-line:hover {
+            background: rgba(255, 255, 255, 0.02);
+        }
+
+        .event-timestamp {
+            color: #6B7280;
+            flex-shrink: 0;
+            min-width: 180px;
+            margin-left: 0;
+            margin-right: 0;
+        }
+
+        .event-severity-dot {
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+            flex-shrink: 0;
+            margin-left: 0;
+            margin-right: 0;
+        }
+
+        .event-line.severity-critical .event-severity-dot {
+            background: #DC2626;
+        }
+
+        .event-line.severity-error .event-severity-dot {
+            background: var(--danger);
+        }
+
+        .event-line.severity-warning .event-severity-dot {
+            background: var(--warning);
+        }
+
+        .event-line.severity-info .event-severity-dot {
+            background: var(--primary);
+        }
+
+        .event-line.severity-debug .event-severity-dot {
+            background: var(--text-tertiary);
+        }
+
+        .event-level {
+            color: var(--text-secondary);
+            flex-shrink: 0;
+            min-width: 110px;
+            width: 110px;
+            margin-left: 0;
+            margin-right: 0;
+        }
+
+        .event-line.severity-critical .event-level {
+            color: #DC2626;
+        }
+
+        .event-line.severity-error .event-level {
+            color: var(--danger);
+        }
+
+        .event-line.severity-warning .event-level {
+            color: var(--warning);
+        }
+
+        .event-line.severity-info .event-level {
+            color: var(--primary);
+        }
+
+        .event-message-text {
+            color: var(--text-primary);
+            flex-shrink: 0;
+            margin-left: 0;
+            margin-right: 0;
+        }
+
+        .event-meta-inline {
+            color: var(--text-tertiary);
+            margin-left: 12px;
+            margin-right: 0;
+        }
+
+        /* Mobile view - hidden by default */
+        .event-mobile-content {
+            display: none;
+        }
+
+        /* Mobile responsive styles */
+        @media (max-width: 768px) {
+            /* Hide desktop view - target direct children of event-line, not mobile children */
+            .event-line > .event-timestamp,
+            .event-line > .event-severity-dot,
+            .event-line > .event-level,
+            .event-line > .event-message-text,
+            .event-line > .event-meta-inline {
+                display: none !important;
+            }
+
+            /* Show mobile view */
+            .event-mobile-content {
+                display: flex;
+                flex-direction: column;
+                gap: 4px;
+                width: 100%;
+                padding: 10px 12px;
+            }
+
+            .event-line {
+                padding: 0 !important;
+            }
+
+            .event-mobile-header {
+                font-size: 11px;
+                margin-bottom: 4px;
+            }
+
+            .event-mobile-header .event-severity-dot {
+                display: inline-block !important;
+                width: 8px !important;
+                height: 8px !important;
+                border-radius: 50% !important;
+                vertical-align: middle !important;
+                margin-right: 6px !important;
+            }
+
+            .event-mobile-header .event-mobile-time {
+                display: inline !important;
+                white-space: nowrap !important;
+                vertical-align: middle !important;
+            }
+
+            .event-mobile-time {
+                color: var(--text-tertiary);
+                font-size: 11px;
+            }
+
+            .event-mobile-message {
+                color: var(--text-primary);
+                font-size: 13px;
+                line-height: 1.4;
+                padding-left: 16px; /* Indent to align with text after dot */
+            }
+
+            /* Adjust filter section for mobile */
+            .filters-section {
+                flex-direction: column;
+            }
+
+            .filter-group {
+                width: 100%;
+            }
+        }
+
+        /* Container state color coding */
+        .state-running {
+            color: #10B981;
+            font-weight: 500;
+        }
+
+        .state-exited {
+            color: #EF4444;
+            font-weight: 500;
+        }
+
+        .state-stopped {
+            color: #F59E0B;
+            font-weight: 500;
+        }
+
+        .state-paused {
+            color: #F59E0B;
+            font-weight: 500;
+        }
+
+        .state-restarting {
+            color: #3B82F6;
+            font-weight: 500;
+        }
+
+        .state-created {
+            color: #6B7280;
+            font-weight: 500;
+        }
+
+        .state-dead {
+            color: #DC2626;
+            font-weight: 500;
+        }
+
+        .state-removing {
+            color: #9CA3AF;
+            font-weight: 500;
+        }
+
+        /* Container Logs Styles */
+        .logs-container {
+            background: #1a1a1a;
+            color: #e0e0e0;
+            font-family: 'Consolas', 'Monaco', 'Courier New', monospace;
+            font-size: 13px;
+            line-height: 1.5;
+            padding: 16px;
+            max-height: calc(100vh - 400px);
+            min-height: 500px;
+            overflow-y: auto;
+            overflow-x: auto;
+            white-space: pre-wrap;
+            word-wrap: break-word;
+        }
+
+        .logs-placeholder {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            height: calc(100vh - 400px);
+            min-height: 500px;
+            color: var(--text-tertiary);
+            gap: 16px;
+        }
+
+        .logs-placeholder p {
+            margin: 0;
+            font-size: 16px;
+        }
+
+        .log-line {
+            margin: 0;
+            padding: 2px 0;
+            border-left: 3px solid transparent;
+            padding-left: 8px;
+        }
+
+        .log-line:hover {
+            background: rgba(255, 255, 255, 0.05);
+        }
+
+        .log-timestamp {
+            color: #888;
+            margin-right: 12px;
+            user-select: none;
+        }
+
+        .log-container-name {
+            font-weight: 600;
+            margin-right: 8px;
+            padding: 2px 6px;
+            border-radius: 3px;
+            font-size: 11px;
+            user-select: none;
+        }
+
+        .log-text {
+            color: #e0e0e0;
+        }
+
+        /* Container-specific colors */
+        .log-line[data-container="0"] {
+            border-left-color: #3B82F6;
+        }
+        .log-line[data-container="0"] .log-container-name {
+            background: #3B82F6;
+            color: white;
+        }
+
+        .log-line[data-container="1"] {
+            border-left-color: #10B981;
+        }
+        .log-line[data-container="1"] .log-container-name {
+            background: #10B981;
+            color: white;
+        }
+
+        .log-line[data-container="2"] {
+            border-left-color: #F59E0B;
+        }
+        .log-line[data-container="2"] .log-container-name {
+            background: #F59E0B;
+            color: white;
+        }
+
+        .log-line[data-container="3"] {
+            border-left-color: #EF4444;
+        }
+        .log-line[data-container="3"] .log-container-name {
+            background: #EF4444;
+            color: white;
+        }
+
+        .log-line[data-container="4"] {
+            border-left-color: #8B5CF6;
+        }
+        .log-line[data-container="4"] .log-container-name {
+            background: #8B5CF6;
+            color: white;
+        }
+
+        .log-line[data-container="5"] {
+            border-left-color: #EC4899;
+        }
+        .log-line[data-container="5"] .log-container-name {
+            background: #EC4899;
+            color: white;
+        }
+
+        .log-line[data-container="6"] {
+            border-left-color: #14B8A6;
+        }
+        .log-line[data-container="6"] .log-container-name {
+            background: #14B8A6;
+            color: white;
+        }
+
+        .log-line[data-container="7"] {
+            border-left-color: #F97316;
+        }
+        .log-line[data-container="7"] .log-container-name {
+            background: #F97316;
+            color: white;
+        }
+
+        /* Old styles kept for backward compatibility */
+        .event-meta {
+            display: flex;
+            gap: var(--spacing-md);
+            color: var(--text-tertiary);
+            font-size: 12px;
+        }
+
+        .event-meta-item {
+            display: flex;
+            align-items: center;
+            gap: var(--spacing-xs);
+        }
+
+        .event-meta-item svg {
+            width: 14px;
+            height: 14px;
+        }
+
+        .event-timestamp {
+            margin-left: auto;
+            color: var(--text-tertiary);
+            font-size: 12px;
+            white-space: nowrap;
+        }
+
+        .pagination {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            padding: var(--spacing-lg);
+            border-top: 1px solid var(--border);
+        }
+
+        .pagination-info {
+            color: var(--text-secondary);
+            font-size: 14px;
+        }
+
+        .pagination-controls {
+            display: flex;
+            gap: var(--spacing-sm);
+        }
+
+        .pagination-btn {
+            padding: 8px 12px;
+            background: var(--dark);
+            border: 1px solid var(--border);
+            border-radius: 6px;
+            color: var(--text-primary);
+            font-size: 14px;
+            cursor: pointer;
+            transition: var(--transition);
+            display: flex;
+            align-items: center;
+            gap: var(--spacing-xs);
+        }
+
+        .pagination-btn:hover:not(:disabled) {
+            background: var(--surface);
+            border-color: var(--primary);
+        }
+
+        .pagination-btn:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+        }
+
+        .pagination-btn svg {
+            width: 14px;
+            height: 14px;
+        }
+
+        .events-empty {
+            padding: var(--spacing-2xl);
+            text-align: center;
+            color: var(--text-tertiary);
+        }
+
+        .events-empty svg {
+            width: 48px;
+            height: 48px;
+            margin-bottom: var(--spacing-md);
+            opacity: 0.5;
+        }
+
+        .events-loading {
+            padding: var(--spacing-2xl);
+            text-align: center;
+            color: var(--text-secondary);
+        }
+
+        @media (max-width: 768px) {
+            .filter-row {
+                grid-template-columns: 1fr;
+            }
+
+            .filter-search {
+                grid-column: span 1;
+            }
+
+            .event-meta {
+                flex-wrap: wrap;
+            }
+
+            .event-timestamp {
+                margin-left: 0;
+                width: 100%;
+            }
+        }
diff --git a/dockmon/src/css/variables.css b/dockmon/src/css/variables.css
new file mode 100644
index 0000000..e4ca016
--- /dev/null
+++ b/dockmon/src/css/variables.css
@@ -0,0 +1,30 @@
+        :root {
+            /* Modern color scheme */
+            --primary: #0084F4;
+            --primary-dark: #0066CC;
+            --primary-light: #E8F4FD;
+            --success: #00C48C;
+            --warning: #FFA26B;
+            --danger: #FF647C;
+            --dark: #1A1D29;
+            --dark-secondary: #252837;
+            --dark-tertiary: #2D3142;
+            --text-primary: #FFFFFF;
+            --text-secondary: #A0A3BD;
+            --text-tertiary: #6E7191;
+            --border: #353849;
+            --surface: #1E2139;
+            --surface-light: #262A41;
+            --background: #161821;
+            
+            /* Spacing */
+            --spacing-xs: 4px;
+            --spacing-sm: 8px;
+            --spacing-md: 16px;
+            --spacing-lg: 24px;
+            --spacing-xl: 32px;
+            --spacing-2xl: 48px;
+            
+            /* Transitions */
+            --transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
+        }
diff --git a/dockmon/src/favicon.ico b/dockmon/src/favicon.ico
new file mode 100644
index 0000000..d3194a5
Binary files /dev/null and b/dockmon/src/favicon.ico differ
diff --git a/dockmon/src/images/logo.png b/dockmon/src/images/logo.png
new file mode 100644
index 0000000..64f99b5
Binary files /dev/null and b/dockmon/src/images/logo.png differ
diff --git a/dockmon/src/images/logo_large.png b/dockmon/src/images/logo_large.png
new file mode 100644
index 0000000..64f99b5
Binary files /dev/null and b/dockmon/src/images/logo_large.png differ
diff --git a/dockmon/src/index.html b/dockmon/src/index.html
new file mode 100644
index 0000000..d9c41c4
--- /dev/null
+++ b/dockmon/src/index.html
@@ -0,0 +1,1015 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>DockMon</title>
+    <link rel="icon" type="image/x-icon" href="/favicon.ico">
+    <!-- GridStack.js CSS -->
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/gridstack@12.3.3/dist/gridstack.min.css">
+    <!-- DockMon CSS -->
+    <link rel="stylesheet" href="/css/main.css">
+    <!-- Lucide Icons -->
+    <script src="/lucide.min.js"></script>
+</head>
+<body>
+    <div class="app-layout">
+        <!-- Sidebar -->
+        <aside class="sidebar">
+            <div class="sidebar-header">
+                <div class="logo-text">DockMon</div>
+            </div>
+            <nav class="sidebar-nav">
+                <div class="nav-section">
+                    <div class="nav-section-title">Main</div>
+                    <a class="nav-item active" onclick="switchPage('dashboard')">
+                        <span class="nav-icon" data-lucide="layout-dashboard"></span>
+                        <span>Dashboard</span>
+                    </a>
+                    <a class="nav-item" onclick="switchPage('hosts')">
+                        <span class="nav-icon" data-lucide="server"></span>
+                        <span>Host Management</span>
+                    </a>
+                    <a class="nav-item" onclick="switchPage('alerts')">
+                        <span class="nav-icon" data-lucide="zap"></span>
+                        <span>Alert Rules</span>
+                    </a>
+                    <a class="nav-item" onclick="openNotificationSettings()">
+                        <span class="nav-icon" data-lucide="bell"></span>
+                        <span>Notification Settings</span>
+                    </a>
+                </div>
+                <div class="nav-section">
+                    <div class="nav-section-title">Audit</div>
+                    <a class="nav-item" onclick="switchPage('events')">
+                        <span class="nav-icon" data-lucide="activity"></span>
+                        <span>Events</span>
+                    </a>
+                    <a class="nav-item" onclick="switchPage('logs')">
+                        <span class="nav-icon" data-lucide="file-text"></span>
+                        <span>Container Logs</span>
+                    </a>
+                </div>
+                <div class="nav-section">
+                    <div class="nav-section-title">System</div>
+                    <a class="nav-item" onclick="openGlobalSettings()">
+                        <span class="nav-icon" data-lucide="settings"></span>
+                        <span>Settings</span>
+                    </a>
+                    <a class="nav-item" onclick="openAccountSettings()">
+                        <span class="nav-icon" data-lucide="user"></span>
+                        <span>Account</span>
+                    </a>
+                    <a class="nav-item" onclick="switchPage('about')">
+                        <span class="nav-icon" data-lucide="info"></span>
+                        <span>About</span>
+                    </a>
+                </div>
+            </nav>
+
+            <!-- Logout at bottom of sidebar -->
+            <div class="sidebar-footer">
+                <a class="nav-item logout-item" onclick="logout()">
+                    <span class="nav-icon" data-lucide="log-out"></span>
+                    <span>Logout</span>
+                </a>
+            </div>
+        </aside>
+
+        <!-- Main Content -->
+        <main class="main-content">
+            <!-- Top Bar -->
+            <header class="topbar">
+                <div class="topbar-left">
+                    <button class="menu-toggle" onclick="toggleSidebar()">☰</button>
+                    <h1 class="topbar-title" id="pageTitle">Dashboard</h1>
+                </div>
+
+                <!-- Blackout Window Indicator (centered) -->
+                <div id="quietHoursIndicator" style="display: none; align-items: center; gap: 8px; padding: 8px 16px; background: var(--warning-bg, rgba(255, 193, 7, 0.1)); border: 1px solid var(--warning, #ffc107); border-radius: 6px; color: var(--warning, #ffc107); font-weight: 500; font-size: 14px;">
+                    <span data-lucide="moon"></span>
+                    <span>In Blackout Window</span>
+                </div>
+
+                <div class="topbar-actions">
+                    <!-- Search Input -->
+                    <div class="search-container" style="position: relative; display: none;" id="dashboardSearchContainer">
+                        <span data-lucide="search" style="position: absolute; left: 12px; top: 50%; transform: translateY(-50%); width: 16px; height: 16px; color: var(--text-tertiary);"></span>
+                        <input
+                            type="text"
+                            id="containerSearch"
+                            class="form-input"
+                            placeholder="Search containers (name, image, or regex)"
+                            style="padding-left: 38px; min-width: 300px;"
+                            oninput="applyContainerFilters()"
+                        />
+                    </div>
+
+                    <!-- Sort Dropdown -->
+                    <select
+                        id="containerSort"
+                        class="form-input"
+                        style="min-width: 180px; display: none;"
+                        onchange="applyContainerFilters()"
+                    >
+                        <option value="name-asc">Name (A-Z)</option>
+                        <option value="name-desc">Name (Z-A)</option>
+                        <option value="status">Status (Running first)</option>
+                        <option value="memory-desc">Memory (High to Low)</option>
+                        <option value="memory-asc">Memory (Low to High)</option>
+                        <option value="cpu-desc">CPU (High to Low)</option>
+                        <option value="cpu-asc">CPU (Low to High)</option>
+                    </select>
+
+                    <button class="btn btn-secondary" onclick="refreshAll()">
+                        <span data-lucide="refresh-cw"></span> Refresh
+                    </button>
+                </div>
+            </header>
+
+            <!-- Content Area -->
+            <div class="content">
+                <!-- Dashboard Page -->
+                <div id="dashboard-page" class="page-section active">
+
+                    <!-- GridStack Container -->
+                    <div class="grid-stack" id="dashboard-grid">
+                        <!-- Widgets will be dynamically added here -->
+                    </div>
+                </div>
+
+                <!-- Hosts Management Page -->
+                <div id="hosts-page" class="page-section">
+                    <div class="card">
+                        <div class="card-header">
+                            <h2 class="card-title">
+                                <span data-lucide="server"></span> Docker Hosts
+                            </h2>
+                            <button class="btn btn-primary" onclick="openHostModal()">
+                                Add New Host
+                            </button>
+                        </div>
+                        <div id="hostsList">
+                            <!-- Hosts list will be rendered here -->
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Alert Rules Page -->
+                <div id="alerts-page" class="page-section">
+                    <div class="card">
+                        <div class="card-header">
+                            <h2 class="card-title">
+                                <span data-lucide="zap"></span> Alert Rules
+                            </h2>
+                            <button class="btn btn-primary" onclick="openAlertRuleModal()">
+                                Create Rule
+                            </button>
+                        </div>
+                        <div id="alertRulesList">
+                            <!-- Alert rules will be rendered here -->
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Events Page -->
+                <div id="events-page" class="page-section">
+                    <div class="card">
+                        <div class="card-header">
+                            <h2 class="card-title">
+                                <span data-lucide="activity"></span> Event Log
+                            </h2>
+                            <div style="display: flex; gap: var(--spacing-sm);">
+                                <button class="btn btn-secondary" onclick="toggleEventSortOrder()" id="sortOrderBtn" title="Toggle sort order">
+                                    <span data-lucide="arrow-down-wide-narrow"></span> Newest First
+                                </button>
+                                <button class="btn btn-secondary" onclick="refreshEvents()">
+                                    <span data-lucide="refresh-cw"></span> Refresh
+                                </button>
+                            </div>
+                        </div>
+
+                        <!-- Filters -->
+                        <div class="event-filters">
+                            <div class="filter-row">
+                                <div class="filter-group">
+                                    <label>Time Range</label>
+                                    <select id="eventTimeRange" onchange="filterEvents()">
+                                        <option value="24">Last 24 hours</option>
+                                        <option value="12">Last 12 hours</option>
+                                        <option value="6">Last 6 hours</option>
+                                        <option value="1">Last hour</option>
+                                        <option value="all">All time</option>
+                                    </select>
+                                </div>
+
+                                <div class="filter-group">
+                                    <label>Category</label>
+                                    <div class="multiselect" id="eventCategoryMultiselect">
+                                        <div class="multiselect-trigger" onclick="toggleMultiselect('eventCategory')">
+                                            <span class="multiselect-label">All Categories</span>
+                                            <span data-lucide="chevron-down"></span>
+                                        </div>
+                                        <div class="multiselect-dropdown" id="eventCategoryDropdown">
+                                            <label><input type="checkbox" value="container" onchange="updateMultiselect('eventCategory')"> Container</label>
+                                            <label><input type="checkbox" value="host" onchange="updateMultiselect('eventCategory')"> Host</label>
+                                            <label><input type="checkbox" value="alert" onchange="updateMultiselect('eventCategory')"> Alert</label>
+                                            <label><input type="checkbox" value="notification" onchange="updateMultiselect('eventCategory')"> Notification</label>
+                                            <label><input type="checkbox" value="system" onchange="updateMultiselect('eventCategory')"> System</label>
+                                            <label><input type="checkbox" value="user" onchange="updateMultiselect('eventCategory')"> User</label>
+                                        </div>
+                                    </div>
+                                </div>
+
+                                <div class="filter-group">
+                                    <label>Severity</label>
+                                    <div class="multiselect" id="eventSeverityMultiselect">
+                                        <div class="multiselect-trigger" onclick="toggleMultiselect('eventSeverity')">
+                                            <span class="multiselect-label">All Severities</span>
+                                            <span data-lucide="chevron-down"></span>
+                                        </div>
+                                        <div class="multiselect-dropdown" id="eventSeverityDropdown">
+                                            <label><input type="checkbox" value="critical" onchange="updateMultiselect('eventSeverity')"> Critical</label>
+                                            <label><input type="checkbox" value="error" onchange="updateMultiselect('eventSeverity')"> Error</label>
+                                            <label><input type="checkbox" value="warning" onchange="updateMultiselect('eventSeverity')"> Warning</label>
+                                            <label><input type="checkbox" value="info" onchange="updateMultiselect('eventSeverity')"> Info</label>
+                                            <label><input type="checkbox" value="debug" onchange="updateMultiselect('eventSeverity')"> Debug</label>
+                                        </div>
+                                    </div>
+                                </div>
+
+                                <div class="filter-group">
+                                    <label>Host</label>
+                                    <div class="multiselect" id="eventHostMultiselect">
+                                        <div class="multiselect-trigger" onclick="toggleMultiselect('eventHost')">
+                                            <span class="multiselect-label">All Hosts</span>
+                                            <span data-lucide="chevron-down"></span>
+                                        </div>
+                                        <div class="multiselect-dropdown" id="eventHostDropdown">
+                                            <!-- Dynamically populated -->
+                                        </div>
+                                    </div>
+                                </div>
+
+                                <div class="filter-group filter-search">
+                                    <label>Search</label>
+                                    <input type="text" id="eventSearch" placeholder="Search events (text or regex)..." onkeyup="debounceEventSearch()">
+                                </div>
+                            </div>
+                        </div>
+
+                        <!-- Events List -->
+                        <div id="eventsList" class="events-list">
+                            <!-- Events will be rendered here -->
+                        </div>
+
+                        <!-- Pagination -->
+                        <div id="eventsPagination" class="pagination">
+                            <!-- Pagination controls will be rendered here -->
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Container Logs Page -->
+                <div id="logs-page" class="page-section">
+                    <div class="card">
+                        <div class="card-header">
+                            <h2 class="card-title">
+                                <span data-lucide="file-text"></span> Container Logs
+                            </h2>
+                            <div style="display: flex; gap: var(--spacing-sm); align-items: center;">
+                                <button class="btn btn-secondary" id="logsSortBtn" onclick="toggleLogsSort()" title="Toggle sort order">
+                                    <span data-lucide="arrow-down-wide-narrow"></span> Newest First
+                                </button>
+                                <label style="display: flex; align-items: center; gap: 8px; cursor: pointer; margin: 0;">
+                                    <input type="checkbox" id="logsAutoRefresh" onchange="toggleLogsAutoRefresh()" checked>
+                                    <span>Auto-refresh</span>
+                                </label>
+                                <button class="btn btn-secondary" onclick="clearLogs()">
+                                    <span data-lucide="trash-2"></span> Clear
+                                </button>
+                                <button class="btn btn-secondary" onclick="downloadLogs()">
+                                    <span data-lucide="download"></span> Download
+                                </button>
+                            </div>
+                        </div>
+
+                        <!-- Filters and Controls -->
+                        <div class="event-filters">
+                            <div class="filter-row">
+                                <div class="filter-group" style="flex: 2;">
+                                    <label>Containers</label>
+                                    <div class="multiselect" id="logsContainerMultiselect">
+                                        <div class="multiselect-trigger" onclick="toggleMultiselect('logsContainer')">
+                                            <span class="multiselect-label">Select containers to view logs...</span>
+                                            <span data-lucide="chevron-down"></span>
+                                        </div>
+                                        <div class="multiselect-dropdown" id="logsContainerDropdown">
+                                            <!-- Containers will be populated here -->
+                                        </div>
+                                    </div>
+                                </div>
+
+                                <div class="filter-group">
+                                    <label>Lines</label>
+                                    <select id="logsTailCount" onchange="reloadLogs()">
+                                        <option value="50">50</option>
+                                        <option value="100" selected>100</option>
+                                        <option value="200">200</option>
+                                        <option value="500">500</option>
+                                        <option value="1000">1000</option>
+                                        <option value="all">All</option>
+                                    </select>
+                                </div>
+
+                                <div class="filter-group filter-search">
+                                    <label>Search</label>
+                                    <input type="text" id="logsSearchInput" placeholder="Filter logs (text or regex)..." oninput="filterLogs()">
+                                </div>
+
+                                <div class="filter-group" style="display: flex; align-items: flex-end;">
+                                    <label style="display: flex; align-items: center; gap: 8px; cursor: pointer; margin: 0;">
+                                        <input type="checkbox" id="logsTimestamps" onchange="toggleTimestamps()" checked>
+                                        <span>Timestamps</span>
+                                    </label>
+                                </div>
+                            </div>
+                        </div>
+
+                        <!-- Logs Display -->
+                        <div id="logsContainer" class="logs-container">
+                            <div class="logs-placeholder">
+                                <span data-lucide="file-text" style="width: 48px; height: 48px; opacity: 0.3;"></span>
+                                <p>Select one or more containers to view logs</p>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- About Page -->
+                <div id="about-page" class="page-section">
+                    <div class="card">
+                        <div class="card-header">
+                            <h2 class="card-title">
+                                <span data-lucide="info"></span> About
+                            </h2>
+                        </div>
+                        <div style="padding: var(--spacing-lg); color: var(--text-secondary);">
+                            <p><strong>Docker Monitor v1.1.2</strong></p>
+                            <p style="margin-top: var(--spacing-md);">A modern web-based Docker container monitoring solution with real-time alerts and auto-restart capabilities.</p>
+                            <p style="margin-top: var(--spacing-md);">Features:</p>
+                            <ul style="margin-left: var(--spacing-lg); margin-top: var(--spacing-sm);">
+                                <li>Multi-host Docker monitoring</li>
+                                <li>Container auto-restart with configurable retries</li>
+                                <li>Multi-channel alerting (Telegram, Discord, Pushover)</li>
+                                <li>Real-time status updates</li>
+                                <li>Modern, responsive interface</li>
+                            </ul>
+                            <p style="margin-top: var(--spacing-lg);">
+                                <strong>Source Code:</strong>
+                                <a href="https://github.com/darthnorse/dockmon" target="_blank" style="color: var(--accent-color); text-decoration: none;">
+                                    GitHub Repository
+                                </a>
+                            </p>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </main>
+    </div>
+
+    <!-- Modals -->
+    <!-- Add Host Modal -->
+    <div class="modal" id="hostModal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h2 class="modal-title">Add Docker Host</h2>
+                <button class="modal-close" onclick="closeModal('hostModal')">✕</button>
+            </div>
+            <form onsubmit="addHost(event)">
+                <div class="security-alert" id="security-warning" style="display: none;">
+                    <span>⚠️</span>
+                    <div>
+                        <strong>Security Warning:</strong> This connection is not encrypted! Anyone on the network can take control of your Docker host.
+                        <a href="https://github.com/darthnorse/dockmon#-security-mtls-configuration-strongly-recommended" target="_blank" style="color: white; text-decoration: underline;">Learn how to set up mTLS</a>
+                    </div>
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label">Host Name</label>
+                    <input type="text" name="hostname" class="form-input" placeholder="Production Server" required>
+                </div>
+                <div class="form-group">
+                    <label class="form-label">Host URL</label>
+                    <input type="text" name="hosturl" class="form-input" placeholder="tcp://192.168.1.100:2376" required
+                           onchange="checkHostSecurity(this.value)" oninput="checkHostSecurity(this.value)">
+                    <small style="color: var(--text-tertiary);">
+                        Examples: <code>unix:///var/run/docker.sock</code> (local), <code>tcp://host:2376</code> (remote with mTLS)
+                    </small>
+                </div>
+
+                <div class="form-group" id="tls-certificates" style="display: none;">
+                    <label class="form-label">TLS Certificates (Required for secure remote connections)</label>
+
+                    <!-- Certificate Input -->
+                    <div id="cert-paste-mode" style="display: grid; gap: 10px;">
+                        <div>
+                            <label style="font-size: 14px; color: var(--text-secondary);">CA Certificate (ca.pem)</label>
+                            <textarea name="tlsca-text" class="form-input" placeholder="-----BEGIN CERTIFICATE-----&#10;...paste CA certificate content...&#10;-----END CERTIFICATE-----" rows="4"></textarea>
+                        </div>
+                        <div>
+                            <label style="font-size: 14px; color: var(--text-secondary);">Client Certificate (client-cert.pem)</label>
+                            <textarea name="tlscert-text" class="form-input" placeholder="-----BEGIN CERTIFICATE-----&#10;...paste client certificate content...&#10;-----END CERTIFICATE-----" rows="4"></textarea>
+                        </div>
+                        <div>
+                            <label style="font-size: 14px; color: var(--text-secondary);">Client Key (client-key.pem)</label>
+                            <textarea name="tlskey-text" class="form-input" placeholder="-----BEGIN PRIVATE KEY-----&#10;...paste client private key content...&#10;-----END PRIVATE KEY-----" rows="4"></textarea>
+                        </div>
+                    </div>
+
+                    <small style="color: var(--text-tertiary);">
+                        Use our <a href="https://github.com/darthnorse/dockmon/blob/main/scripts/setup-docker-mtls.sh" target="_blank">mTLS setup script</a> to generate these certificates.
+                    </small>
+                </div>
+                <button type="submit" class="btn btn-primary" style="width: 100%;">
+                    Add Host
+                </button>
+            </form>
+        </div>
+    </div>
+
+    <!-- Alert Rule Modal -->
+    <div class="modal" id="alertRuleModal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h2 class="modal-title">Create Alert Rule</h2>
+                <button class="modal-close" onclick="closeModal('alertRuleModal')">✕</button>
+            </div>
+            <form onsubmit="createAlertRule(event)">
+                <div class="form-group">
+                    <label class="form-label">Rule Name</label>
+                    <input type="text" class="form-input" id="alertRuleName" placeholder="Enter a name for this alert rule" required>
+                </div>
+                <div class="form-group">
+                    <label class="form-label">Container Selection</label>
+                    <div style="margin-bottom: 15px;">
+                        <label class="checkbox-item" style="display: flex; align-items: center; gap: 8px; margin-bottom: 10px;">
+                            <input type="checkbox" id="selectAllContainers" onchange="toggleAllContainers(this)">
+                            <strong>Monitor All Containers (all hosts)</strong>
+                        </label>
+                    </div>
+                    <div id="containerSelectionCheckboxes" style="max-height: 300px; overflow-y: auto; border: 1px solid var(--border); border-radius: 4px; padding: 10px;">
+                        <!-- Container checkboxes will be populated here -->
+                    </div>
+                </div>
+                <!-- Docker Events Section -->
+                <div class="form-group">
+                    <label class="form-label">Docker Events <span style="color: var(--text-tertiary); font-size: 12px; font-weight: normal;">(React to what happens)</span></label>
+                    <div style="display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 15px; margin-top: 10px;">
+                        <div>
+                            <h4 style="color: #dc2626; font-size: 14px; margin-bottom: 10px; font-weight: 500;"><i data-lucide="alert-circle" style="width:14px;height:14px;"></i> Critical</h4>
+                            <div class="checkbox-group">
+                                <label class="checkbox-item" title="Container was killed due to memory limit exceeded">
+                                    <input type="checkbox" data-event="oom"> Out of Memory
+                                </label>
+                                <label class="checkbox-item" title="Container exited with error code (crashed or failed)">
+                                    <input type="checkbox" data-event="die-nonzero"> Die (non-zero exit)
+                                </label>
+                                <label class="checkbox-item" title="Container health check failed - container may still be running">
+                                    <input type="checkbox" data-event="health_status:unhealthy"> Health: Unhealthy
+                                </label>
+                            </div>
+                        </div>
+                        <div>
+                            <h4 style="color: #d97706; font-size: 14px; margin-bottom: 10px; font-weight: 500;"><i data-lucide="alert-triangle" style="width:14px;height:14px;"></i> Warning</h4>
+                            <div class="checkbox-group">
+                                <label class="checkbox-item" title="Container was forcefully terminated (SIGKILL)">
+                                    <input type="checkbox" data-event="kill"> Killed
+                                </label>
+                                <label class="checkbox-item" title="Container exited cleanly (exit code 0) but unexpectedly">
+                                    <input type="checkbox" data-event="die-zero"> Die (clean exit)
+                                </label>
+                                <label class="checkbox-item" title="Container restarted multiple times in short period">
+                                    <input type="checkbox" data-event="restart-loop"> Restart Loop
+                                </label>
+                                <label class="checkbox-item" title="Container stuck in 'removing' state for over 2 minutes">
+                                    <input type="checkbox" data-event="stuck-removing"> Stuck Removing
+                                </label>
+                            </div>
+                        </div>
+                        <div>
+                            <h4 style="color: var(--text-secondary); font-size: 14px; margin-bottom: 10px; font-weight: 500;"><i data-lucide="info" style="width:14px;height:14px;"></i> Info</h4>
+                            <div class="checkbox-group">
+                                <label class="checkbox-item" title="Container was started successfully">
+                                    <input type="checkbox" data-event="start"> Started
+                                </label>
+                                <label class="checkbox-item" title="Container was stopped gracefully (SIGTERM)">
+                                    <input type="checkbox" data-event="stop"> Stopped
+                                </label>
+                                <label class="checkbox-item" title="Container health check passed">
+                                    <input type="checkbox" data-event="health_status:healthy"> Health: Healthy
+                                </label>
+                                <label class="checkbox-item" title="New container was created from image">
+                                    <input type="checkbox" data-event="create"> Created
+                                </label>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Docker States Section -->
+                <div class="form-group">
+                    <label class="form-label">Docker States <span style="color: var(--text-tertiary); font-size: 12px; font-weight: normal;">(React to current status)</span></label>
+                    <div style="display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 20px; margin-top: 10px;">
+                        <div>
+                            <h4 style="color: #ef4444; font-size: 14px; margin-bottom: 10px; font-weight: 500;"><i data-lucide="alert-circle" style="width:14px;height:14px;"></i> Critical</h4>
+                            <div class="checkbox-group">
+                                <label class="checkbox-item" title="Container has stopped running (exited with any code)">
+                                    <input type="checkbox" checked data-state="exited"> Exited
+                                </label>
+                                <label class="checkbox-item" title="Container has exited and cannot be restarted">
+                                    <input type="checkbox" checked data-state="dead"> Dead
+                                </label>
+                            </div>
+                        </div>
+                        <div>
+                            <h4 style="color: #d97706; font-size: 14px; margin-bottom: 10px; font-weight: 500;"><i data-lucide="alert-triangle" style="width:14px;height:14px;"></i> Warning</h4>
+                            <div class="checkbox-group">
+                                <label class="checkbox-item" title="Container has been paused and is not running">
+                                    <input type="checkbox" data-state="paused"> Paused
+                                </label>
+                                <label class="checkbox-item" title="Container is being removed (deletion in progress)">
+                                    <input type="checkbox" data-state="removing"> Removing
+                                </label>
+                            </div>
+                        </div>
+                        <div>
+                            <h4 style="color: var(--text-secondary); font-size: 14px; margin-bottom: 10px; font-weight: 500;"><i data-lucide="info" style="width:14px;height:14px;"></i> Info</h4>
+                            <div class="checkbox-group">
+                                <label class="checkbox-item" title="Container has been created but not started">
+                                    <input type="checkbox" data-state="created"> Created
+                                </label>
+                                <label class="checkbox-item" title="Container is currently running and active">
+                                    <input type="checkbox" data-state="running"> Running
+                                </label>
+                                <label class="checkbox-item" title="Container is in the process of restarting">
+                                    <input type="checkbox" data-state="restarting"> Restarting
+                                </label>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+                <div class="form-group">
+                    <label class="form-label">Alert Channels</label>
+                    <div id="notificationChannelsSection">
+                        <p style="color: var(--text-tertiary); font-size: 14px; margin-bottom: 15px;">
+                            Configure notification channels first in Settings to enable alerts.
+                        </p>
+                        <button type="button" class="btn btn-secondary" onclick="openNotificationSettings()">
+                            Configure Channels
+                        </button>
+                    </div>
+                </div>
+                <div class="form-group">
+                    <label class="form-label">Cooldown Period (minutes)</label>
+                    <input type="number" class="form-input" id="cooldownMinutes" min="1" max="1440" value="15"
+                           placeholder="Minutes between alerts">
+                    <small style="color: var(--text-tertiary);">Minimum time between alerts for the same container (default: 15 minutes)</small>
+                </div>
+                <button type="submit" class="btn btn-primary" style="width: 100%;">
+                    Create Alert Rule
+                </button>
+            </form>
+        </div>
+    </div>
+
+    <!-- Global Settings Modal -->
+    <div class="modal" id="globalSettingsModal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h2 class="modal-title">Global Settings</h2>
+                <button class="modal-close" onclick="closeModal('globalSettingsModal')">✕</button>
+            </div>
+            <div class="settings-section">
+                <h3 style="margin-bottom: var(--spacing-lg); color: var(--text-primary);">Auto-Restart Configuration</h3>
+                <div class="settings-row">
+                    <div class="settings-label">
+                        <div class="settings-title">Maximum Retry Attempts</div>
+                        <div class="settings-description">Number of times to attempt restarting a container before giving up</div>
+                    </div>
+                    <div class="settings-value">
+                        <input type="number" class="number-input" id="maxRetries" min="0" max="10">
+                        <span style="font-size: 14px; color: var(--text-tertiary);">retries</span>
+                    </div>
+                </div>
+                <div class="settings-row">
+                    <div class="settings-label">
+                        <div class="settings-title">Retry Delay</div>
+                        <div class="settings-description">Time to wait between restart attempts</div>
+                    </div>
+                    <div class="settings-value">
+                        <input type="number" class="number-input" id="retryDelay" min="5" max="300">
+                        <span style="font-size: 14px; color: var(--text-tertiary);">seconds</span>
+                    </div>
+                </div>
+                <div class="settings-row">
+                    <div class="settings-label">
+                        <div class="settings-title">Enable Auto-Restart by Default</div>
+                        <div class="settings-description">New containers will have auto-restart enabled automatically</div>
+                    </div>
+                    <div class="settings-value">
+                        <div class="toggle-switch" id="defaultAutoRestart" onclick="toggleSwitch(this)"></div>
+                    </div>
+                </div>
+            </div>
+            <div class="settings-section">
+                <h3 style="margin-bottom: var(--spacing-lg); color: var(--text-primary);">Monitoring Settings</h3>
+                <div class="settings-row">
+                    <div class="settings-label">
+                        <div class="settings-title">Polling Interval</div>
+                        <div class="settings-description">How often to check container states (lower = more responsive, higher = less CPU)</div>
+                    </div>
+                    <div class="settings-value">
+                        <input type="number" class="number-input" id="pollingInterval" min="1" max="300" step="1">
+                        <span style="font-size: 14px; color: var(--text-tertiary);">seconds</span>
+                    </div>
+                </div>
+                <div class="settings-row">
+                    <div class="settings-label">
+                        <div class="settings-title">Connection Timeout</div>
+                        <div class="settings-description">Maximum time to wait for host response</div>
+                    </div>
+                    <div class="settings-value">
+                        <input type="number" class="number-input" id="connectionTimeout" min="5" max="30">
+                        <span style="font-size: 14px; color: var(--text-tertiary);">seconds</span>
+                    </div>
+                </div>
+            </div>
+            <div class="settings-section">
+                <h3 style="margin-bottom: var(--spacing-lg); color: var(--text-primary);">Dashboard Display</h3>
+                <div class="settings-row">
+                    <div class="settings-label">
+                        <div class="settings-title">Show Host Statistics</div>
+                        <div class="settings-description">Display CPU and memory graphs on host widgets</div>
+                    </div>
+                    <div class="settings-value">
+                        <div class="toggle-switch" id="showHostStats" onclick="toggleSwitch(this)"></div>
+                    </div>
+                </div>
+                <div class="settings-row">
+                    <div class="settings-label">
+                        <div class="settings-title">Show Container Statistics</div>
+                        <div class="settings-description">Display statistics for individual containers (CPU, memory, network, disk)</div>
+                    </div>
+                    <div class="settings-value">
+                        <div class="toggle-switch" id="showContainerStats" onclick="toggleSwitch(this)"></div>
+                    </div>
+                </div>
+            </div>
+            <button class="btn btn-primary" style="width: 100%;" onclick="saveGlobalSettings()">
+                Save Settings
+            </button>
+        </div>
+    </div>
+
+    <!-- Notification Settings Modal -->
+    <div class="modal" id="notificationModal">
+        <div class="modal-content" style="max-width: 800px;">
+            <div class="modal-header">
+                <h2 class="modal-title">Notification Settings</h2>
+                <button class="modal-close" onclick="closeModal('notificationModal')">✕</button>
+            </div>
+
+            <!-- Tab Navigation -->
+            <div style="display: flex; gap: var(--spacing-md); margin-bottom: var(--spacing-lg); border-bottom: 1px solid var(--surface-light);">
+                <button id="channelsTab" class="tab-btn active" onclick="switchNotificationTab('channels')" style="padding: var(--spacing-md); background: none; border: none; color: var(--primary); border-bottom: 2px solid var(--primary); cursor: pointer;">Channels</button>
+                <button id="templateTab" class="tab-btn" onclick="switchNotificationTab('template')" style="padding: var(--spacing-md); background: none; border: none; color: var(--text-secondary); cursor: pointer;">Message Template</button>
+                <button id="blackoutTab" class="tab-btn" onclick="switchNotificationTab('blackout')" style="padding: var(--spacing-md); background: none; border: none; color: var(--text-secondary); cursor: pointer;"><span data-lucide="moon"></span> Blackout Windows</button>
+            </div>
+
+            <!-- Channels Tab Content -->
+            <div id="channelsTabContent">
+                <div style="margin-bottom: var(--spacing-lg);">
+                    <button type="button" class="btn btn-secondary" onclick="addNotificationChannel()" style="margin-bottom: var(--spacing-md);">
+                        <span data-lucide="plus"></span> Add Channel
+                    </button>
+                </div>
+                <div id="notificationChannelsList" style="max-height: 400px; overflow-y: auto;">
+                    <!-- Channels will be dynamically inserted here -->
+                </div>
+                <button type="submit" class="btn btn-primary" onclick="saveAllChannels()" style="width: 100%; margin-top: var(--spacing-lg);">
+                    Save All Channels
+                </button>
+            </div>
+
+            <!-- Template Tab Content -->
+            <div id="templateTabContent" style="display: none;">
+                <div class="form-group">
+                    <label class="form-label">Notification Message Template</label>
+                    <textarea id="alertTemplate" class="form-input" rows="10" placeholder="Enter custom template or leave blank for default" style="font-family: 'Courier New', monospace; font-size: 13px;"></textarea>
+                    <small style="color: var(--text-secondary); display: block; margin-top: var(--spacing-sm);">
+                        Use variables like {CONTAINER_NAME}, {HOST_NAME}, {OLD_STATE}, {NEW_STATE}, etc.
+                    </small>
+                </div>
+
+                <div style="margin-top: var(--spacing-lg); padding: var(--spacing-md); background: var(--surface); border-radius: var(--radius-md); border: 1px solid var(--surface-light);">
+                    <h4 style="margin-bottom: var(--spacing-md); color: var(--text-primary);">Available Variables</h4>
+                    <div style="display: grid; grid-template-columns: repeat(auto-fill, minmax(200px, 1fr)); gap: var(--spacing-sm); font-size: 12px;">
+                        <div><code>{CONTAINER_NAME}</code> - Container name</div>
+                        <div><code>{CONTAINER_ID}</code> - Container ID (short)</div>
+                        <div><code>{HOST_NAME}</code> - Host name</div>
+                        <div><code>{HOST_ID}</code> - Host ID</div>
+                        <div><code>{OLD_STATE}</code> - Previous state</div>
+                        <div><code>{NEW_STATE}</code> - New state</div>
+                        <div><code>{IMAGE}</code> - Docker image</div>
+                        <div><code>{TIMESTAMP}</code> - Full timestamp</div>
+                        <div><code>{TIME}</code> - Time only</div>
+                        <div><code>{DATE}</code> - Date only</div>
+                        <div><code>{RULE_NAME}</code> - Alert rule name</div>
+                        <div><code>{EVENT_TYPE}</code> - Docker event type</div>
+                    </div>
+                </div>
+
+                <div style="margin-top: var(--spacing-lg);">
+                    <h4 style="margin-bottom: var(--spacing-sm); color: var(--text-primary);">Template Examples</h4>
+                    <select id="templateExamples" class="form-input" onchange="applyTemplateExample(this.value)" style="margin-bottom: var(--spacing-md);">
+                        <option value="">-- Select an example template --</option>
+                        <option value="default">Default (Detailed)</option>
+                        <option value="simple">Simple</option>
+                        <option value="minimal">Minimal</option>
+                        <option value="emoji">With Emojis</option>
+                    </select>
+                </div>
+
+                <button type="button" class="btn btn-primary" onclick="saveNotificationTemplate()" style="width: 100%; margin-top: var(--spacing-lg);">
+                    Save Template
+                </button>
+            </div>
+
+            <!-- Blackout Tab Content -->
+            <div id="blackoutTabContent" style="display: none;">
+                <div style="margin-bottom: var(--spacing-md); color: var(--text-secondary); font-size: 14px;">
+                    Configure blackout windows when alerts should be suppressed. Times are defined in your local timezone. Alerts will be deferred and checked after each window ends.
+                </div>
+
+                <div id="blackoutWindowsList" style="margin-bottom: var(--spacing-lg);">
+                    <!-- Blackout windows will be rendered here -->
+                </div>
+
+                <button type="button" class="btn btn-secondary" onclick="addBlackoutWindow()" style="margin-bottom: var(--spacing-lg);">
+                    <span data-lucide="plus"></span> Add Blackout Window
+                </button>
+
+                <!-- Current Status -->
+                <div id="blackoutStatus" style="padding: var(--spacing-md); background: var(--surface); border-radius: var(--radius-md); border: 1px solid var(--surface-light); margin-bottom: var(--spacing-lg);">
+                    <!-- Status will be updated here -->
+                </div>
+
+                <!-- Post-Blackout Information -->
+                <div id="postBlackoutInfo" style="padding: var(--spacing-md); background: var(--info-bg); border-radius: var(--radius-md); border: 1px solid var(--info-border);">
+                    <h4 style="margin-bottom: var(--spacing-sm); color: var(--text-primary);">How Blackout Windows Work</h4>
+                    <div style="font-size: 14px; color: var(--text-secondary); line-height: 1.6;">
+                        <p style="margin-bottom: var(--spacing-sm);">During a blackout window:</p>
+                        <ul style="margin-left: var(--spacing-lg); margin-bottom: var(--spacing-sm);">
+                            <li>All alerts are suppressed (not sent)</li>
+                            <li>Container events continue to be monitored</li>
+                            <li>No notifications will be sent to any channel</li>
+                        </ul>
+                        <p style="margin-bottom: var(--spacing-sm);">When the blackout window ends:</p>
+                        <ul style="margin-left: var(--spacing-lg);">
+                            <li>DockMon checks the current state of all containers</li>
+                            <li>Alerts are sent for any containers in problematic states</li>
+                            <li>This ensures you're notified of issues that occurred during maintenance</li>
+                        </ul>
+                        <p style="margin-top: var(--spacing-sm); font-style: italic;">
+                            💡 Tip: Define alert rules that monitor both events AND states for best coverage.
+                        </p>
+                    </div>
+                </div>
+
+                <button type="button" class="btn btn-primary" onclick="saveBlackoutWindows()" style="width: 100%; margin-top: var(--spacing-lg);">
+                    Save Blackout Settings
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <!-- Account Settings Modal -->
+    <div class="modal" id="accountModal">
+        <div class="modal-content" style="max-width: 500px;">
+            <div class="modal-header">
+                <h2>Account Settings</h2>
+                <button class="modal-close" onclick="closeModal('accountModal')">&times;</button>
+            </div>
+            <form onsubmit="saveAccountSettings(event)">
+                <div class="form-group">
+                    <h3 style="margin-bottom: var(--spacing-md); color: var(--text-primary);">Change Username</h3>
+                    <label class="form-label">Current Username</label>
+                    <input type="text" id="currentUsername" class="form-input" readonly style="background: var(--surface-light); cursor: not-allowed;">
+                    <label class="form-label" style="margin-top: var(--spacing-md);">New Username</label>
+                    <input type="text" id="newUsername" class="form-input" placeholder="Enter new username" minlength="3" maxlength="50">
+                    <small style="color: var(--text-secondary);">Leave blank to keep current username</small>
+                </div>
+
+                <div class="form-group">
+                    <h3 style="margin-bottom: var(--spacing-md); color: var(--text-primary);">Change Password</h3>
+                    <label class="form-label">Current Password</label>
+                    <input type="password" id="currentPassword" class="form-input" placeholder="Enter current password" required>
+                    <label class="form-label" style="margin-top: var(--spacing-md);">New Password</label>
+                    <input type="password" id="newPassword" class="form-input" placeholder="Enter new password" minlength="8">
+                    <label class="form-label" style="margin-top: var(--spacing-md);">Confirm New Password</label>
+                    <input type="password" id="confirmPassword" class="form-input" placeholder="Confirm new password">
+                    <small style="color: var(--text-secondary);">Password must be at least 8 characters long</small>
+                </div>
+
+                <div id="accountError" class="alert alert-danger" style="display: none; margin-bottom: var(--spacing-md);"></div>
+                <div id="accountSuccess" class="alert alert-success" style="display: none; margin-bottom: var(--spacing-md);"></div>
+
+                <button type="submit" class="btn btn-primary" style="width: 100%;">
+                    Update Account
+                </button>
+            </form>
+        </div>
+    </div>
+
+    <!-- Container Details Modal -->
+    <div class="modal" id="containerModal">
+        <div class="modal-content resizable" style="width: 900px; height: 820px;">
+            <div class="modal-header" style="cursor: move;">
+                <h2 class="modal-title">Container Details</h2>
+                <button class="modal-close" onclick="closeModal('containerModal')">✕</button>
+            </div>
+            <div class="resize-handle"></div>
+            <div id="containerDetails">
+                <!-- Container info will be populated here -->
+            </div>
+            <div style="margin-top: 20px;">
+                <ul style="display: flex; gap: 10px; list-style: none; border-bottom: 1px solid var(--border); margin-bottom: 20px;">
+                    <li><button class="btn btn-secondary" onclick="showTab('info')" id="tab-info">Info</button></li>
+                    <li><button class="btn btn-secondary" onclick="showTab('stats')" id="tab-stats">Statistics</button></li>
+                    <li><button class="btn btn-secondary" onclick="showTab('logs')" id="tab-logs">Logs</button></li>
+                </ul>
+                
+                <!-- Info Tab -->
+                <div id="info-tab" class="tab-content">
+                    <div id="container-info-content"></div>
+                </div>
+
+                <!-- Statistics Tab -->
+                <div id="stats-tab" class="tab-content" style="display: none;">
+                    <div class="stats-tab-grid" style="display: grid; grid-template-columns: 1fr 1fr; gap: 20px;">
+                        <!-- CPU Usage Chart -->
+                        <div style="background: var(--surface); padding: 20px; border-radius: 8px; border: 1px solid var(--border);">
+                            <h4 style="margin: 0 0 15px 0; color: var(--text-primary); font-size: 16px; font-weight: 600;">
+                                <span data-lucide="cpu" style="width: 16px; height: 16px; display: inline-block; vertical-align: middle;"></span>
+                                CPU Usage
+                            </h4>
+                            <canvas id="container-cpu-chart" style="height: 180px;"></canvas>
+                        </div>
+
+                        <!-- Memory Usage Chart -->
+                        <div style="background: var(--surface); padding: 20px; border-radius: 8px; border: 1px solid var(--border);">
+                            <h4 style="margin: 0 0 15px 0; color: var(--text-primary); font-size: 16px; font-weight: 600;">
+                                <span data-lucide="database" style="width: 16px; height: 16px; display: inline-block; vertical-align: middle;"></span>
+                                Memory Usage
+                            </h4>
+                            <canvas id="container-memory-chart" style="height: 180px;"></canvas>
+                        </div>
+
+                        <!-- Network Activity Chart -->
+                        <div style="background: var(--surface); padding: 20px; border-radius: 8px; border: 1px solid var(--border);">
+                            <h4 style="margin: 0 0 15px 0; color: var(--text-primary); font-size: 16px; font-weight: 600;">
+                                <span data-lucide="network" style="width: 16px; height: 16px; display: inline-block; vertical-align: middle;"></span>
+                                Network Activity
+                            </h4>
+                            <canvas id="container-network-chart" style="height: 180px;"></canvas>
+                        </div>
+
+                        <!-- Disk I/O Chart -->
+                        <div style="background: var(--surface); padding: 20px; border-radius: 8px; border: 1px solid var(--border);">
+                            <h4 style="margin: 0 0 15px 0; color: var(--text-primary); font-size: 16px; font-weight: 600;">
+                                <span data-lucide="hard-drive" style="width: 16px; height: 16px; display: inline-block; vertical-align: middle;"></span>
+                                Disk I/O
+                            </h4>
+                            <canvas id="container-disk-chart" style="height: 180px;"></canvas>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Logs Tab -->
+                <div id="logs-tab" class="tab-content" style="display: none;">
+                    <div style="display: flex; gap: 10px; margin-bottom: 10px; align-items: center; flex-wrap: wrap;">
+                        <button class="btn btn-secondary" onclick="fetchContainerLogs()">Refresh Logs</button>
+                        <label style="display: flex; align-items: center; gap: 5px; cursor: pointer;">
+                            <input type="checkbox" id="autoRefreshLogs" checked onchange="toggleAutoRefresh()" style="cursor: pointer;">
+                            <span>Auto-refresh</span>
+                        </label>
+                        <label style="display: flex; align-items: center; gap: 5px; cursor: pointer;">
+                            <input type="checkbox" id="showTimestamps" onchange="updateLogDisplay()" style="cursor: pointer;">
+                            <span>Show timestamps</span>
+                        </label>
+                        <span style="color: var(--text-secondary);">Lines:</span>
+                        <input type="number" id="logTailCount" value="100" min="1" max="1000" style="width: 80px; padding: 8px;" placeholder="Lines">
+                        <div style="flex: 1; min-width: 200px; position: relative;">
+                            <input type="text" id="logSearchFilter" placeholder="Filter logs..." oninput="updateLogDisplay()"
+                                style="width: 100%; padding: 8px 30px 8px 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--surface); color: var(--text-primary);">
+                            <span id="logMatchCount" style="position: absolute; right: 10px; top: 50%; transform: translateY(-50%); color: var(--text-secondary); font-size: 12px;"></span>
+                        </div>
+                        <button class="btn btn-secondary" onclick="clearLogFilter()" title="Clear filter" style="padding: 8px 12px;">&times;</button>
+                    </div>
+                    <div id="container-logs" style="background: var(--dark); padding: 15px; border-radius: 6px; height: 350px; overflow-y: auto; font-family: 'Monaco', 'Courier New', monospace; font-size: 10px; line-height: 1.4; white-space: pre-wrap; word-break: break-all; resize: vertical; min-height: 200px; max-height: 600px;" onmouseup="saveModalPreferences()">
+                        <div style="color: var(--text-tertiary);">Loading logs...</div>
+                    </div>
+                </div>
+                
+                <!-- Exec functionality removed for security reasons -->
+            </div>
+        </div>
+    </div>
+
+    <!-- Confirmation Dialog Modal -->
+    <div class="modal" id="confirmationModal">
+        <div class="modal-content" style="max-width: 500px;">
+            <div class="modal-header">
+                <h2 class="modal-title" id="confirmationTitle">Confirm Action</h2>
+                <button class="modal-close" onclick="closeConfirmation()">✕</button>
+            </div>
+            <div class="modal-body" style="padding: 20px 0;">
+                <p id="confirmationMessage" style="margin-bottom: 20px; line-height: 1.5;"></p>
+                <div style="display: flex; gap: 10px; justify-content: flex-end;">
+                    <button class="btn btn-secondary" onclick="closeConfirmation()">Cancel</button>
+                    <button class="btn" id="confirmationButton" style="background: var(--danger); border-color: var(--danger);" onclick="confirmAction()">Delete</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Toast Notification -->
+    <div class="toast" id="toast"></div>
+
+    <!-- Mobile Bottom Navigation -->
+    <div class="mobile-bottom-nav">
+        <div class="mobile-nav-item active" data-page="dashboard">
+            <i class="mobile-nav-icon" data-lucide="layout-grid"></i>
+            <span class="mobile-nav-label">Dashboard</span>
+        </div>
+        <div class="mobile-nav-item" data-page="hosts">
+            <i class="mobile-nav-icon" data-lucide="server"></i>
+            <span class="mobile-nav-label">Hosts</span>
+        </div>
+        <div class="mobile-nav-item" data-page="alerts">
+            <i class="mobile-nav-icon" data-lucide="alert-triangle"></i>
+            <span class="mobile-nav-label">Alerts</span>
+        </div>
+        <div class="mobile-nav-item" data-page="events">
+            <i class="mobile-nav-icon" data-lucide="activity"></i>
+            <span class="mobile-nav-label">Events</span>
+        </div>
+        <div class="mobile-nav-item" data-page="more">
+            <i class="mobile-nav-icon" data-lucide="more-horizontal"></i>
+            <span class="mobile-nav-label">More</span>
+            <div class="more-menu">
+                <div class="more-menu-item" onclick="openAccountSettings(); document.querySelector('.more-menu').classList.remove('show');">
+                    <i data-lucide="user"></i>
+                    <span>Account</span>
+                </div>
+                <!-- Logs viewer will be added later, for now this goes to Events -->
+                <!-- <div class="more-menu-item" onclick="switchPage('logs'); document.querySelector('.more-menu').classList.remove('show');">
+                    <i data-lucide="file-text"></i>
+                    <span>Logs</span>
+                </div> -->
+                <div class="more-menu-item" onclick="switchPage('about'); document.querySelector('.more-menu').classList.remove('show');">
+                    <i data-lucide="info"></i>
+                    <span>About</span>
+                </div>
+                <div class="more-menu-item" onclick="logout(); document.querySelector('.more-menu').classList.remove('show');">
+                    <i data-lucide="log-out"></i>
+                    <span>Logout</span>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- GridStack.js Scripts -->
+    <script src="https://cdn.jsdelivr.net/npm/gridstack@12.3.3/dist/gridstack-all.js"></script>
+    <!-- Chart.js -->
+    <script src="https://cdn.jsdelivr.net/npm/chart.js@4.5.0/dist/chart.umd.min.js"></script>
+    <!-- DockMon Logger (must load first) -->
+    <script src="/js/logger.js"></script>
+    <!-- DockMon Core JavaScript -->
+    <script src="/js/core.js"></script>
+    <!-- Metrics JavaScript -->
+    <script src="/js/metrics.js"></script>
+    <!-- Notifications JavaScript (loaded before app.js since app.js depends on it) -->
+    <script src="/js/notifications.js"></script>
+    <!-- Dashboard JavaScript (loaded before app.js since app.js depends on it) -->
+    <script src="/js/dashboard.js"></script>
+    <!-- Alerts JavaScript (loaded before app.js since app.js depends on it) -->
+    <script src="/js/alerts.js"></script>
+    <!-- DockMon Application JavaScript -->
+    <script src="/js/app.js"></script>
+    <!-- Event Log JavaScript -->
+    <script src="/js/events.js"></script>
+    <script src="/js/logs.js"></script>
+</body>
+</html>
diff --git a/dockmon/src/js/alerts.js b/dockmon/src/js/alerts.js
new file mode 100644
index 0000000..550bdef
--- /dev/null
+++ b/dockmon/src/js/alerts.js
@@ -0,0 +1,900 @@
+function createAlertForContainer(containerId) {
+    // Find the container
+    const container = containers.find(c => c.id === containerId);
+    if (container) {
+        // Check if there's an existing alert rule for this container on this specific host
+        const existingRule = alertRules.find(rule => {
+            // Check new container+host pairs format first
+            if (rule.containers && rule.containers.length > 0) {
+                return rule.containers.some(c =>
+                    c.container_name === container.name && c.host_id === container.host_id
+                );
+            }
+            return false;
+        });
+
+        // Close current modal
+        closeModal('containerModal');
+
+        if (existingRule) {
+            // Edit existing rule
+            openAlertRuleModal(container, existingRule);
+        } else {
+            // Create new rule with container pre-selected
+            openAlertRuleModal(container);
+        }
+    }
+}
+
+async function editAlertRule(ruleId) {
+    try {
+        // Find the rule in the current alertRules array
+        const rule = alertRules.find(r => r.id === ruleId);
+        if (!rule) {
+            showToast('❌ Alert rule not found');
+            return;
+        }
+
+        editingAlertRule = rule;
+        openAlertRuleModal(null, rule);
+    } catch (error) {
+        logger.error('Error opening alert rule for editing:', error);
+        showToast('❌ Failed to open alert rule for editing');
+    }
+}
+
+function openGlobalSettings() {
+    document.getElementById('maxRetries').value = globalSettings.max_retries;
+    document.getElementById('retryDelay').value = globalSettings.retry_delay;
+    document.getElementById('pollingInterval').value = globalSettings.polling_interval;
+    document.getElementById('connectionTimeout').value = globalSettings.connection_timeout;
+
+    const defaultToggle = document.getElementById('defaultAutoRestart');
+    if (globalSettings.default_auto_restart) {
+        defaultToggle.classList.add('active');
+    } else {
+        defaultToggle.classList.remove('active');
+    }
+
+    // Dashboard display settings
+    const showHostStatsToggle = document.getElementById('showHostStats');
+    if (globalSettings.show_host_stats !== false) { // Default to true
+        showHostStatsToggle.classList.add('active');
+    } else {
+        showHostStatsToggle.classList.remove('active');
+    }
+
+    const showContainerStatsToggle = document.getElementById('showContainerStats');
+    if (globalSettings.show_container_stats !== false) { // Default to true
+        showContainerStatsToggle.classList.add('active');
+    } else {
+        showContainerStatsToggle.classList.remove('active');
+    }
+
+    document.getElementById('globalSettingsModal').classList.add('active');
+}
+
+function getSecurityStatusBadge(host) {
+    if (!host.url || host.url.includes('unix://')) {
+        return ''; // Local connections don't need security status
+    }
+
+    if (host.security_status === 'secure') {
+        return '<span class="security-status secure">Secure</span>';
+    } else if (host.security_status === 'insecure') {
+        return '<span class="security-status insecure">Insecure</span>';
+    }
+    return ''; // Unknown status - don't show anything
+}
+
+function closeModal(modalId) {
+    if (modalId === 'containerModal') {
+        // Save preferences before closing
+        saveModalPreferences();
+
+        // Clean up resize observer
+        if (window.modalResizeObserver) {
+            window.modalResizeObserver.disconnect();
+            window.modalResizeObserver = null;
+        }
+
+        // Use the cleanup function
+        if (window.cleanupLogStream) {
+            window.cleanupLogStream();
+        }
+        const streamBtn = document.getElementById('streamLogsBtn');
+        if (streamBtn) {
+            streamBtn.textContent = 'Start Live Stream';
+        }
+
+        // Remove keydown event listener if exists
+        if (window.logFilterKeyHandler) {
+            document.removeEventListener('keydown', window.logFilterKeyHandler);
+        }
+
+        // Remove drag event listeners
+        if (window.cleanupModalDragListeners) {
+            window.cleanupModalDragListeners();
+        }
+
+        // Clean up modal charts
+        if (typeof cleanupModalCharts === 'function') {
+            cleanupModalCharts();
+        }
+
+        // Notify backend to stop stats collection for this container
+        if (window.currentContainer && ws && ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({
+                type: 'modal_closed',
+                container_id: window.currentContainer.id,
+                host_id: window.currentContainer.host_id
+            }));
+        }
+
+        // Clear current container
+        window.currentContainer = null;
+    }
+
+    document.getElementById(modalId).classList.remove('active');
+}
+
+// Account Settings Functions
+let currentUserInfo = { username: 'admin' };
+
+async function getCurrentUser() {
+    try {
+        const response = await fetch(`${API_BASE}/api/auth/status`, {
+            credentials: 'include'
+        });
+        if (response.ok) {
+            const data = await response.json();
+            currentUserInfo = data;
+            // Update UI with username
+            const topbarUsername = document.getElementById('topbarUsername');
+            const currentUsernameInput = document.getElementById('currentUsername');
+
+            if (topbarUsername) topbarUsername.textContent = data.username;
+            if (currentUsernameInput) currentUsernameInput.value = data.username;
+        }
+    } catch (error) {
+        logger.error('Error fetching user info:', error);
+    }
+}
+
+function openAccountSettings() {
+    getCurrentUser();
+    document.getElementById('accountModal').classList.add('active');
+
+    // Clear form
+    document.getElementById('newUsername').value = '';
+    document.getElementById('newPassword').value = '';
+    document.getElementById('confirmPassword').value = '';
+    document.getElementById('accountError').style.display = 'none';
+    document.getElementById('accountSuccess').style.display = 'none';
+
+    // Check if we have a temporary password from first login
+    const tempPassword = sessionStorage.getItem('temp_current_password');
+    if (tempPassword) {
+        document.getElementById('currentPassword').value = tempPassword;
+        // Clear it immediately after use for security
+        sessionStorage.removeItem('temp_current_password');
+    } else {
+        document.getElementById('currentPassword').value = '';
+    }
+}
+
+async function saveAccountSettings(event) {
+    event.preventDefault();
+
+    const currentPassword = document.getElementById('currentPassword').value;
+    const newUsername = document.getElementById('newUsername').value.trim();
+    const newPassword = document.getElementById('newPassword').value;
+    const confirmPassword = document.getElementById('confirmPassword').value;
+    const errorDiv = document.getElementById('accountError');
+    const successDiv = document.getElementById('accountSuccess');
+
+    errorDiv.style.display = 'none';
+    successDiv.style.display = 'none';
+
+    // Validate passwords match
+    if (newPassword && newPassword !== confirmPassword) {
+        errorDiv.textContent = 'New passwords do not match';
+        errorDiv.style.display = 'block';
+        return;
+    }
+
+    // Validate password length
+    if (newPassword && newPassword.length < 8) {
+        errorDiv.textContent = 'Password must be at least 8 characters long';
+        errorDiv.style.display = 'block';
+        return;
+    }
+
+    try {
+        // Change username if provided
+        if (newUsername && newUsername !== currentUserInfo.username) {
+            const usernameResponse = await fetch(`${API_BASE}/api/auth/change-username`, {
+                method: 'POST',
+                headers: getAuthHeaders(),
+                credentials: 'include',
+                body: JSON.stringify({
+                    current_password: currentPassword,
+                    new_username: newUsername
+                })
+            });
+
+            if (!usernameResponse.ok) {
+                const error = await usernameResponse.json();
+                throw new Error(error.detail || 'Failed to change username');
+            }
+        }
+
+        // Change password if provided
+        if (newPassword) {
+            const passwordResponse = await fetch(`${API_BASE}/api/auth/change-password`, {
+                method: 'POST',
+                headers: getAuthHeaders(),
+                credentials: 'include',
+                body: JSON.stringify({
+                    current_password: currentPassword,
+                    new_password: newPassword
+                })
+            });
+
+            if (!passwordResponse.ok) {
+                const error = await passwordResponse.json();
+                throw new Error(error.detail || 'Failed to change password');
+            }
+        }
+
+        successDiv.textContent = 'Account updated successfully';
+        successDiv.style.display = 'block';
+
+        // Clear password change requirement
+        sessionStorage.removeItem('must_change_password');
+
+        // Update username displays
+        await getCurrentUser();
+
+        // Clear form
+        setTimeout(() => {
+            closeModal('accountModal');
+        }, 1500);
+
+    } catch (error) {
+        errorDiv.textContent = error.message;
+        errorDiv.style.display = 'block';
+    }
+}
+
+// logout() function removed - using the one from core.js instead
+
+function checkPasswordChangeRequired() {
+    const mustChange = sessionStorage.getItem('must_change_password');
+    if (mustChange === 'true') {
+        // Show password change modal
+        setTimeout(() => {
+            showToast('⚠️ Please change your default password for security');
+            openAccountSettings();
+
+            // Add a notice at the top of the form for first login
+            const errorDiv = document.getElementById('accountError');
+            const successDiv = document.getElementById('accountSuccess');
+            errorDiv.style.display = 'block';
+            errorDiv.style.background = 'rgba(255, 193, 7, 0.1)';
+            errorDiv.style.borderColor = 'rgba(255, 193, 7, 0.3)';
+            errorDiv.style.color = '#ffc107';
+            errorDiv.textContent = '⚠️ First login detected. Please change your default password for security.';
+        }, 1000);
+    }
+}
+
+// Confirmation modal functions
+let confirmationCallback = null;
+
+function showConfirmation(title, message, buttonText, callback) {
+    document.getElementById('confirmationTitle').textContent = title;
+    document.getElementById('confirmationMessage').innerHTML = message;
+    document.getElementById('confirmationButton').textContent = buttonText;
+    confirmationCallback = callback;
+    document.getElementById('confirmationModal').classList.add('active');
+}
+
+function closeConfirmation() {
+    document.getElementById('confirmationModal').classList.remove('active');
+    confirmationCallback = null;
+}
+
+function confirmAction() {
+    if (confirmationCallback) {
+        confirmationCallback();
+    }
+    closeConfirmation();
+}
+
+function refreshContainerModalIfOpen() {
+    const containerModal = document.getElementById('containerModal');
+    if (containerModal && containerModal.classList.contains('active') && window.currentContainer) {
+        // Find the updated container data using the stored container ID
+        const updatedContainer = containers.find(c => c.host_id === window.currentContainer.host_id && c.short_id === window.currentContainer.short_id);
+        if (updatedContainer) {
+            // Remember which tab is currently active
+            let activeTab = 'info';
+            if (document.getElementById('logs-tab').style.display !== 'none') {
+                activeTab = 'logs';
+            } else if (document.getElementById('stats-tab').style.display !== 'none') {
+                activeTab = 'stats';
+            }
+
+            // Only refresh info tab if container state changed (not just stats update)
+            if (activeTab === 'info') {
+                // Check if this is just a stats update (state hasn't changed)
+                const stateChanged = updatedContainer.state !== window.currentContainer.state;
+                if (stateChanged) {
+                    // Re-populate the modal with updated data (but preserve the tab)
+                    showContainerDetails(updatedContainer.host_id, updatedContainer.short_id, activeTab);
+                } else {
+                    // Just update the reference - sparklines will update automatically
+                    window.currentContainer = updatedContainer;
+
+                    // Refresh recent events every 30 seconds without full re-render
+                    if (!window.lastEventsRefresh || (Date.now() - window.lastEventsRefresh) > 30000) {
+                        if (typeof loadContainerRecentEvents === 'function') {
+                            loadContainerRecentEvents(updatedContainer.name, updatedContainer.host_id);
+                            window.lastEventsRefresh = Date.now();
+                        }
+                    }
+                }
+            } else {
+                // Just update the current container reference for stats/logs tabs
+                window.currentContainer = updatedContainer;
+            }
+        }
+    }
+}
+
+// Toggle functions
+function toggleSwitch(element) {
+    element.classList.toggle('active');
+}
+
+async function toggleAutoRestart(hostId, containerId, event) {
+    event.stopPropagation();
+
+    // Find the container to get current state (must match both container ID and host)
+    const container = containers.find(c =>
+        (c.short_id === containerId || c.id === containerId) && c.host_id === hostId
+    );
+    if (!container) {
+        return;
+    }
+
+    const newState = !container.auto_restart;
+
+    // Find the host name
+    const host = hosts.find(h => h.id === hostId);
+    const hostName = host ? host.name : 'Unknown Host';
+
+    try {
+        const response = await fetch(`${API_BASE}/api/containers/${container.short_id}/auto-restart`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                host_id: hostId,
+                container_name: container.name,
+                enabled: newState
+            })
+        });
+
+        if (response.ok) {
+            // Update local state for all matching containers (same name + host)
+            containers.forEach(c => {
+                if (c.host_id === hostId && c.id === container.id) {
+                    c.auto_restart = newState;
+                    c.restart_attempts = 0;
+                }
+            });
+
+            renderHosts();
+            renderDashboardWidgets();
+            initIcons();
+
+            // Update modal content if it's open and showing this container
+            if (window.currentContainer && window.currentContainer.id === container.id && window.currentContainer.host_id === hostId) {
+                // Preserve current tab when updating for auto-restart
+                let activeTab = 'info';
+                if (document.getElementById('logs-tab').style.display !== 'none') {
+                    activeTab = 'logs';
+                }
+                showContainerDetails(container.host_id, container.short_id, activeTab);
+            }
+
+            const status = newState ? 'enabled' : 'disabled';
+            showToast(`🔄 Auto-restart ${status} for ${container.name} on ${hostName}`);
+
+            if (newState && container.state === 'exited') {
+                // Trigger restart attempt
+                restartContainer(hostId, container.id);
+            }
+        } else {
+            showToast('❌ Failed to toggle auto-restart');
+        }
+    } catch (error) {
+        logger.error('Error toggling auto-restart:', error);
+        showToast('❌ Failed to toggle auto-restart');
+    }
+}
+
+// Actions
+async function addHost(event) {
+    event.preventDefault();
+    const formData = new FormData(event.target);
+
+    const hostData = {
+        name: formData.get('hostname'),
+        url: formData.get('hosturl')
+    };
+
+    // Handle certificate data from either file upload or text input
+    const tlsCertificate = await getCertificateData(formData, 'tlscert');
+    const tlsKey = await getCertificateData(formData, 'tlskey');
+    const tlsCa = await getCertificateData(formData, 'tlsca');
+
+    if (tlsCertificate) hostData.tls_cert = tlsCertificate;
+    if (tlsKey) hostData.tls_key = tlsKey;
+    if (tlsCa) hostData.tls_ca = tlsCa;
+
+    const isEditing = window.editingHost !== null;
+    const url = isEditing ? `${API_BASE}/api/hosts/${window.editingHost.id}` : `${API_BASE}/api/hosts`;
+    const method = isEditing ? 'PUT' : 'POST';
+
+    try {
+        const response = await fetch(url, {
+            method: method,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(hostData)
+        });
+        
+        if (response.ok) {
+            const updatedHost = await response.json();
+
+            if (isEditing) {
+                showToast('✅ Host updated successfully!');
+            } else {
+                showToast('✅ Host added successfully!');
+            }
+
+            // Refresh hosts and containers from server to ensure we have complete data
+            await fetchHosts();
+            await fetchContainers();
+
+            // Explicitly refresh the host list on the Host Management page
+            renderHosts();
+            renderHostsPage(); // Make sure the Host Management page is updated too
+            updateStats();
+            updateNavBadges();
+            closeModal('hostModal');
+            event.target.reset();
+            window.editingHost = null;
+        } else {
+            const action = isEditing ? 'update' : 'add';
+            try {
+                const errorData = await response.json();
+
+                // Handle Pydantic validation errors (array format)
+                if (errorData.detail && Array.isArray(errorData.detail)) {
+                    const messages = errorData.detail.map(err => {
+                        // Root validators have __root__ as location
+                        if (err.loc && err.loc.includes('__root__')) {
+                            return err.msg.replace('Value error, ', '');
+                        }
+                        // Field-specific errors
+                        const field = err.loc ? err.loc[err.loc.length - 1] : 'field';
+                        const fieldName = field === 'tls_ca' ? 'CA Certificate' :
+                                         field === 'tls_cert' ? 'Client Certificate' :
+                                         field === 'tls_key' ? 'Client Private Key' : field;
+                        return `${fieldName}: ${err.msg.replace('Value error, ', '')}`;
+                    });
+                    showToast(`❌ Failed to ${action} host:\n${messages.join('\n')}`);
+                }
+                // Handle simple error messages (string format)
+                else if (errorData.detail && typeof errorData.detail === 'string') {
+                    showToast(`❌ Failed to ${action} host: ${errorData.detail}`);
+                }
+                else {
+                    showToast(`❌ Failed to ${action} host`);
+                }
+            } catch (parseError) {
+                // If JSON parsing fails, show raw text
+                const errorText = await response.text();
+                showToast(`❌ Failed to ${action} host: ${errorText}`);
+            }
+        }
+    } catch (error) {
+        const action = isEditing ? 'update' : 'add';
+        logger.error(`Error ${action}ing host:`, error);
+        showToast(`❌ Failed to ${action} host`);
+    }
+}
+
+async function createAlertRule(event) {
+    event.preventDefault();
+
+    const states = [];
+    const channels = [];
+    let containerPattern = '';
+    let hostId = null;
+    let containerHostPairs = [];
+
+    // Determine container selection
+    // Get selected containers with their host IDs
+    const allCheckboxes = document.querySelectorAll('#containerSelectionCheckboxes input[type="checkbox"]');
+    const checkedCheckboxes = document.querySelectorAll('#containerSelectionCheckboxes input[type="checkbox"]:checked');
+
+    // If all checkboxes are checked, treat it as "monitor all containers"
+    if (allCheckboxes.length > 0 && allCheckboxes.length === checkedCheckboxes.length) {
+        containerPattern = '.*';
+        hostId = null;
+        // Don't use container+host pairs for "all containers"
+        containerHostPairs = []; // Clear any previously selected containers
+    } else {
+        // Get selected containers with their host IDs
+        checkedCheckboxes.forEach(cb => {
+            if (cb.dataset.hostId && cb.value) {
+                containerHostPairs.push({
+                    host_id: cb.dataset.hostId,
+                    container_name: cb.value
+                });
+            }
+        });
+
+        if (containerHostPairs.length === 0) {
+            showToast('❌ Please select at least one container');
+            return;
+        }
+
+        // For the new system, we don't need to build patterns
+        // The backend will handle the container+host pairs directly
+        containerPattern = null; // Will be set to ".*" by backend as default
+    }
+
+    // Get selected events, states, and channels
+    const events = [];
+    event.target.querySelectorAll('input[type="checkbox"]:checked').forEach(cb => {
+        if (cb.name === 'channels') {
+            channels.push(parseInt(cb.value));
+        } else if (cb.dataset.event) {
+            events.push(cb.dataset.event);
+        } else if (cb.dataset.state) {
+            states.push(cb.dataset.state);
+        }
+    });
+
+    const ruleName = document.getElementById('alertRuleName').value;
+    const cooldownMinutes = parseInt(document.getElementById('cooldownMinutes').value) || 15;
+
+    // Validate that at least one trigger is selected
+    if (events.length === 0 && states.length === 0) {
+        showToast('❌ Please select at least one Docker event or state to monitor');
+        return;
+    }
+
+    if (channels.length === 0) {
+        showToast('❌ Please select at least one notification channel');
+        return;
+    }
+
+    const ruleData = {
+        name: ruleName,
+        containers: containerHostPairs.length > 0 ? containerHostPairs : null,
+        trigger_events: events.length > 0 ? events : [],
+        trigger_states: states.length > 0 ? states : [],
+        notification_channels: channels,
+        cooldown_minutes: cooldownMinutes,
+        enabled: true
+    };
+
+    const isEditing = editingAlertRule !== null;
+    const url = isEditing ? `${API_BASE}/api/alerts/${editingAlertRule.id}` : `${API_BASE}/api/alerts`;
+    const method = isEditing ? 'PUT' : 'POST';
+    
+    try {
+        const response = await fetch(url, {
+            method: method,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(ruleData)
+        });
+        
+        if (response.ok) {
+            const rule = await response.json();
+
+            if (isEditing) {
+                showToast('✅ Alert rule updated successfully!');
+                editingAlertRule = null;
+            } else {
+                showToast('✅ Alert rule created successfully!');
+            }
+
+            // Fetch fresh data from server to ensure UI shows correct information
+            await fetchAlertRules();
+            renderAlertRules();
+            updateStats();
+            updateNavBadges();
+            closeModal('alertRuleModal');
+        } else {
+            const errorData = await response.json().catch(() => ({ detail: 'Unknown error' }));
+            logger.error(`Alert ${isEditing ? 'update' : 'creation'} failed:`, errorData);
+            const errorMessage = typeof errorData.detail === 'string'
+                ? errorData.detail
+                : JSON.stringify(errorData.detail) || response.statusText;
+            showToast(`❌ Failed to ${isEditing ? 'update' : 'create'} alert: ${errorMessage}`);
+        }
+    } catch (error) {
+        logger.error(`Error ${editingAlertRule ? 'updating' : 'creating'} alert rule:`, error);
+        showToast(`❌ Failed to ${editingAlertRule ? 'update' : 'create'} alert rule`);
+    }
+}
+
+async function checkDependentAlerts(channelId) {
+    try {
+        const response = await fetch(`${API_BASE}/api/notifications/channels/${channelId}/dependent-alerts`, {
+            credentials: 'include'
+        });
+        const data = await response.json();
+        return data.alerts || [];
+    } catch (error) {
+        logger.error('Error checking dependent alerts:', error);
+        return [];
+    }
+}
+
+// Blackout Windows Management
+function renderBlackoutWindows() {
+    const container = document.getElementById('blackoutWindowsList');
+    if (!container) return;
+
+    if (!globalSettings.blackout_windows || globalSettings.blackout_windows.length === 0) {
+        container.innerHTML = '<div style="padding: var(--spacing-md); color: var(--text-secondary); text-align: center;">No blackout windows configured</div>';
+        return;
+    }
+
+    container.innerHTML = globalSettings.blackout_windows.map((window, index) => `
+        <div style="padding: var(--spacing-md); margin-bottom: var(--spacing-md); background: var(--surface); border: 1px solid var(--surface-light); border-radius: var(--radius-md);">
+            <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: var(--spacing-sm);">
+                <input type="text" placeholder="Window name (e.g., Nightly Maintenance)"
+                       value="${escapeHtml(window.name || '')}"
+                       onchange="updateBlackoutWindow(${index}, 'name', this.value)"
+                       style="background: transparent; border: none; color: var(--text-primary); font-size: 14px; flex: 1;">
+                <button type="button" class="btn-icon" onclick="removeBlackoutWindow(${index})">
+                    <i data-lucide="trash-2"></i>
+                </button>
+            </div>
+            <div style="display: grid; grid-template-columns: 1fr 1fr auto; gap: var(--spacing-sm); align-items: center;">
+                <div>
+                    <label style="font-size: 12px; color: var(--text-secondary);">Start Time</label>
+                    <input type="time" class="form-input" value="${window.start || '02:00'}"
+                           onchange="updateBlackoutWindow(${index}, 'start', this.value)">
+                </div>
+                <div>
+                    <label style="font-size: 12px; color: var(--text-secondary);">End Time</label>
+                    <input type="time" class="form-input" value="${window.end || '04:00'}"
+                           onchange="updateBlackoutWindow(${index}, 'end', this.value)">
+                </div>
+                <div style="padding-top: 18px;">
+                    <label class="toggle-label">
+                        <input type="checkbox" ${window.enabled !== false ? 'checked' : ''}
+                               onchange="updateBlackoutWindow(${index}, 'enabled', this.checked)">
+                        <span>Enabled</span>
+                    </label>
+                </div>
+            </div>
+            <div style="margin-top: var(--spacing-sm);">
+                <label style="font-size: 12px; color: var(--text-secondary); display: block; margin-bottom: var(--spacing-xs);">Active Days</label>
+                <div style="display: flex; gap: var(--spacing-xs); flex-wrap: wrap;">
+                    ${['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'].map((day, dayIndex) => `
+                        <label class="day-checkbox" style="display: flex; align-items: center; gap: 4px; padding: 4px 8px; background: ${window.days && window.days.includes(dayIndex) ? 'var(--primary)' : 'var(--surface-light)'}; border-radius: var(--radius-sm); cursor: pointer;">
+                            <input type="checkbox" ${window.days && window.days.includes(dayIndex) ? 'checked' : ''}
+                                   onchange="toggleBlackoutDay(${index}, ${dayIndex}, this.checked)"
+                                   style="display: none;">
+                            <span style="font-size: 12px; color: ${window.days && window.days.includes(dayIndex) ? 'white' : 'var(--text-secondary)'};">${day}</span>
+                        </label>
+                    `).join('')}
+                </div>
+            </div>
+        </div>
+    `).join('');
+    initIcons();
+}
+
+function addBlackoutWindow() {
+    if (!globalSettings.blackout_windows) {
+        globalSettings.blackout_windows = [];
+    }
+    // Find the next available window number
+    const existingNumbers = globalSettings.blackout_windows
+        .map(w => w.name.match(/Window (\d+)/))
+        .filter(m => m)
+        .map(m => parseInt(m[1]));
+    const nextNumber = existingNumbers.length > 0 ? Math.max(...existingNumbers) + 1 : 1;
+
+    globalSettings.blackout_windows.push({
+        name: `Window ${nextNumber}`,
+        start: '02:00',
+        end: '04:00',
+        days: [0, 1, 2, 3, 4, 5, 6], // All days by default
+        enabled: true
+    });
+    renderBlackoutWindows();
+}
+
+function removeBlackoutWindow(index) {
+    globalSettings.blackout_windows.splice(index, 1);
+    renderBlackoutWindows();
+}
+
+function updateBlackoutWindow(index, field, value) {
+    if (globalSettings.blackout_windows && globalSettings.blackout_windows[index]) {
+        globalSettings.blackout_windows[index][field] = value;
+    }
+}
+
+function toggleBlackoutDay(windowIndex, dayIndex, checked) {
+    if (!globalSettings.blackout_windows[windowIndex].days) {
+        globalSettings.blackout_windows[windowIndex].days = [];
+    }
+
+    const days = globalSettings.blackout_windows[windowIndex].days;
+    if (checked && !days.includes(dayIndex)) {
+        days.push(dayIndex);
+    } else if (!checked) {
+        const idx = days.indexOf(dayIndex);
+        if (idx > -1) days.splice(idx, 1);
+    }
+
+    renderBlackoutWindows();
+}
+
+async function saveBlackoutWindows() {
+    try {
+        // Add timezone offset (in minutes, negative for timezones ahead of UTC)
+        globalSettings.timezone_offset = -new Date().getTimezoneOffset();
+
+        const response = await fetch(`${API_BASE}/api/settings`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(globalSettings)
+        });
+
+        if (response.ok) {
+            showToast('✅ Blackout windows saved successfully!');
+            await updateBlackoutStatus();
+        }
+    } catch (error) {
+        logger.error('Error saving blackout windows:', error);
+        showToast('❌ Failed to save blackout windows');
+    }
+}
+
+async function updateBlackoutStatus() {
+    try {
+        const response = await fetch(`${API_BASE}/api/blackout/status`, {
+            credentials: 'include'
+        });
+        const status = await response.json();
+
+        const statusDiv = document.getElementById('blackoutStatus');
+        if (statusDiv) {
+            if (status.is_blackout) {
+                statusDiv.innerHTML = `
+                    <div style="display: flex; align-items: center; gap: var(--spacing-sm);">
+                        <i data-lucide="moon" style="width:20px;height:20px;color:var(--warning);"></i>
+                        <div>
+                            <div style="color: var(--warning); font-weight: bold;">Currently in Blackout Window</div>
+                            <div style="color: var(--text-secondary); font-size: 12px;">${status.current_window}</div>
+                        </div>
+                    </div>
+                `;
+                initIcons();
+            } else {
+                statusDiv.innerHTML = `
+                    <div style="display: flex; align-items: center; gap: var(--spacing-sm);">
+                        <i data-lucide="sun" style="width:20px;height:20px;color:var(--success);"></i>
+                        <div>
+                            <div style="color: var(--text-primary);">No active blackout window</div>
+                            <div style="color: var(--text-secondary); font-size: 12px;">Alerts are being sent normally</div>
+                        </div>
+                    </div>
+                `;
+                initIcons();
+            }
+
+            // Update dashboard indicator
+            const dashboardIndicator = document.getElementById('quietHoursIndicator');
+            if (dashboardIndicator) {
+                if (status.is_blackout) {
+                    dashboardIndicator.style.display = 'flex';
+                    dashboardIndicator.innerHTML = `
+                        <i data-lucide="moon"></i>
+                        <span>In Blackout Window</span>
+                    `;
+                    initIcons();
+                } else {
+                    dashboardIndicator.style.display = 'none';
+                }
+            }
+        }
+    } catch (error) {
+        logger.error('Error fetching blackout status:', error);
+    }
+}
+
+async function saveGlobalSettings() {
+    globalSettings.max_retries = parseInt(document.getElementById('maxRetries').value);
+    globalSettings.retry_delay = parseInt(document.getElementById('retryDelay').value);
+    globalSettings.polling_interval = parseInt(document.getElementById('pollingInterval').value);
+    globalSettings.connection_timeout = parseInt(document.getElementById('connectionTimeout').value);
+    globalSettings.default_auto_restart = document.getElementById('defaultAutoRestart').classList.contains('active');
+    globalSettings.show_host_stats = document.getElementById('showHostStats').classList.contains('active');
+    globalSettings.show_container_stats = document.getElementById('showContainerStats').classList.contains('active');
+
+    // Include blackout windows in the save
+
+    try {
+        const response = await fetch(`${API_BASE}/api/settings`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(globalSettings)
+        });
+
+        if (response.ok) {
+            showToast('✅ Settings saved successfully!');
+            closeModal('globalSettingsModal');
+            // Re-render dashboard to apply show_host_stats and show_container_stats changes
+            if (typeof renderHosts === 'function') {
+                renderHosts();
+            }
+        }
+    } catch (error) {
+        logger.error('Error saving settings:', error);
+        showToast('❌ Failed to save settings');
+    }
+}
+
+async function deleteAlertRule(ruleId) {
+    const rule = alertRules.find(r => r.id === ruleId);
+    const ruleName = rule ? rule.name : 'Unknown Rule';
+
+    const message = `Are you sure you want to delete the alert rule <strong>"${escapeHtml(ruleName)}"</strong>?<br><br>
+        This will permanently remove the alert rule and you will no longer receive notifications for this container.<br><br>
+        <strong>This action cannot be undone.</strong>`;
+
+    showConfirmation('Delete Alert Rule', message, 'Delete Rule', async () => {
+        try {
+            const response = await fetch(`${API_BASE}/api/alerts/${ruleId}`, {
+                method: 'DELETE'
+            });
+
+            if (response.ok) {
+                showToast('Alert rule deleted');
+                // Fetch fresh data from server to ensure UI is up to date
+                await fetchAlertRules();
+                renderAlertRules();
+                updateStats();
+                updateNavBadges();
+            }
+        } catch (error) {
+            logger.error('Error deleting alert rule:', error);
+            showToast('❌ Failed to delete alert rule');
+        }
+    });
+}
diff --git a/dockmon/src/js/app.js b/dockmon/src/js/app.js
new file mode 100644
index 0000000..3833cab
--- /dev/null
+++ b/dockmon/src/js/app.js
@@ -0,0 +1,2211 @@
+async function init() {
+            logger.debug('Starting initialization...');
+
+            // Check authentication first
+            const isAuthenticated = await checkAuthentication();
+            if (!isAuthenticated) {
+                return; // Stop initialization if not authenticated
+            }
+
+
+            // First establish WebSocket connection with a small delay
+            connectWebSocket();
+
+            // Set up cleanup function for modal close
+            window.cleanupLogStream = function() {
+                stopAutoRefresh();
+            };
+
+            // Give WebSocket a moment to connect, then fetch data as fallback
+            await new Promise(resolve => setTimeout(resolve, 1000));
+
+            // Fetch initial data with fallback handling
+            logger.debug('Fetching initial data...');
+            const results = await Promise.allSettled([
+                fetchHosts(),
+                fetchContainers(),
+                fetchSettings(),
+                loadNotificationChannels(),
+                fetchAlertRules()
+            ]);
+
+            // Check results but don't fail initialization
+            results.forEach((result, index) => {
+                const names = ['hosts', 'containers', 'settings', 'notificationChannels', 'alertRules'];
+                if (result.status === 'rejected') {
+                    logger.warn(`Failed to fetch ${names[index]}:`, result.reason);
+                } else {
+                    logger.debug(`Successfully fetched ${names[index]}`);
+                }
+            });
+
+            // Save timezone offset to database on initial load (silent, no toast)
+            try {
+                await fetch(`${API_BASE}/api/settings`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    credentials: 'include',
+                    body: JSON.stringify(globalSettings)
+                });
+            } catch (error) {
+                logger.error('Failed to save timezone offset:', error);
+            }
+
+            logger.debug('Rendering initial UI...');
+            renderAll();
+
+            // Update quiet hours indicator on dashboard
+            updateBlackoutStatus();
+
+            // Initialize dashboard if we're on the dashboard page
+            // This handles the case when fetch completes before WebSocket
+            if (currentPage === 'dashboard' && grid === null && hosts.length > 0) {
+                logger.debug('Initializing dashboard after fetch data load...');
+                // Small delay to ensure DOM is ready, but data is already loaded
+                setTimeout(() => {
+                    if (grid === null) {
+                        initDashboard();
+                    }
+                }, 100);
+            }
+
+            logger.debug('Initialization completed successfully');
+        }
+
+        function renderAll() {
+            renderHosts();
+            renderAlertRules();
+            updateStats();
+            updateNavBadges();
+        }
+
+        // Page switching
+        function switchPage(page, event) {
+            // Update active nav item
+            document.querySelectorAll('.nav-item').forEach(item => {
+                item.classList.remove('active');
+            });
+            if (event && event.currentTarget) {
+                event.currentTarget.classList.add('active');
+            }
+
+            // Hide all pages
+            document.querySelectorAll('.page-section').forEach(section => {
+                section.classList.remove('active');
+            });
+
+            // Show selected page
+            const pageElement = document.getElementById(`${page}-page`);
+            if (!pageElement) {
+                logger.error(`Page element not found: ${page}-page`);
+                showToast(`Page "${page}" not yet available`);
+                return;
+            }
+            pageElement.classList.add('active');
+            currentPage = page;
+
+            // Show/hide dashboard-specific controls
+            const searchContainer = document.getElementById('dashboardSearchContainer');
+            const sortSelect = document.getElementById('containerSort');
+
+            if (page === 'dashboard') {
+                // Show search/sort controls
+                if (searchContainer) searchContainer.style.display = '';
+                if (sortSelect) sortSelect.style.display = '';
+
+                if (grid === null) {
+                    // Wait for hosts data before initializing dashboard
+                    if (hosts.length === 0) {
+                        logger.debug('Waiting for hosts data before initializing dashboard...');
+                        let checkData = null;
+                        let timeoutId = null;
+
+                        checkData = setInterval(() => {
+                            if (hosts.length > 0) {
+                                clearInterval(checkData);
+                                if (timeoutId) clearTimeout(timeoutId);
+                                setTimeout(() => initDashboard(), 100);
+                            }
+                        }, 100);
+
+                        // Timeout after 5 seconds and initialize anyway
+                        timeoutId = setTimeout(() => {
+                            if (checkData) clearInterval(checkData);
+                            if (grid === null) {
+                                logger.debug('Initializing dashboard after timeout');
+                                initDashboard();
+                            }
+                        }, 5000);
+                    } else {
+                        setTimeout(() => initDashboard(), 100); // Delay to ensure DOM is ready
+                    }
+                } else {
+                    renderDashboardWidgets(); // Refresh existing widgets
+                }
+            } else {
+                // Hide search/sort controls on other pages
+                if (searchContainer) searchContainer.style.display = 'none';
+                if (sortSelect) sortSelect.style.display = 'none';
+            }
+
+            // Update page title
+            const titles = {
+                'dashboard': 'Dashboard',
+                'hosts': 'Host Management',
+                'alerts': 'Alert Rules',
+                'logs': 'Events',
+                'about': 'About'
+            };
+            document.getElementById('pageTitle').textContent = titles[page] || 'Dashboard';
+            
+            // Render page-specific content
+            if (page === 'hosts') {
+                renderHostsPage();
+            } else if (page === 'alerts') {
+                renderAlertsPage();
+            }
+        }
+
+        // Render functions
+        function renderHosts() {
+            // If on dashboard page, update widgets
+            if (currentPage === 'dashboard') {
+                renderDashboardWidgets();
+                return;
+            }
+
+            const hostsGrid = document.getElementById('hostsGrid');
+            if (!hostsGrid) return;
+            hostsGrid.innerHTML = '';
+
+            // Group containers by host
+            const containersByHost = {};
+            hosts.forEach(host => {
+                containersByHost[host.id] = [];
+            });
+            
+            containers.forEach(container => {
+                if (containersByHost[container.host_id]) {
+                    containersByHost[container.host_id].push(container);
+                }
+            });
+            
+            hosts.forEach(host => {
+                const hostCard = document.createElement('div');
+                hostCard.className = 'host-card';
+                
+                const hostContainers = (containersByHost[host.id] || []).sort((a, b) => a.name.localeCompare(b.name));
+                const containersList = hostContainers.map(container => `
+                    <div class="container-item" data-status="${escapeHtml(container.state)}">
+                        <div class="container-info" onclick="showContainerDetails('${escapeHtml(container.host_id)}', '${escapeHtml(container.short_id)}')">
+                            <div class="container-icon container-${escapeHtml(container.state)}">
+                                ${getContainerIcon(container.state)}
+                            </div>
+                            <div class="container-details">
+                                <div class="container-name">${escapeHtml(container.name)}</div>
+                                <div class="container-id">${escapeHtml(container.short_id)}</div>
+                            </div>
+                        </div>
+                        <div class="container-actions">
+                            <div class="auto-restart-toggle ${container.auto_restart ? 'enabled' : ''}"
+                                 onclick="event.stopPropagation()">
+                                <span>🔄 Auto</span>
+                                <div class="toggle-switch ${container.auto_restart ? 'active' : ''}"
+                                     onclick="toggleAutoRestart('${escapeHtml(container.host_id)}', '${escapeHtml(container.short_id)}', event)"></div>
+                            </div>
+                            <span class="container-state ${getStateClass(container.state)}">
+                                ${escapeHtml(container.state)}
+                            </span>
+                        </div>
+                    </div>
+                `).join('');
+                
+                hostCard.innerHTML = `
+                    <div class="host-header">
+                        <div class="host-name">
+                            <span>🖥️</span> ${escapeHtml(host.name)}
+                            ${getSecurityStatusBadge(host)}
+                        </div>
+                        <span class="host-status status-${host.status}">${host.status}</span>
+                    </div>
+                    <div class="container-list">
+                        ${containersList || '<div style="padding: 12px; color: var(--text-tertiary); text-align: center;">No containers</div>'}
+                    </div>
+                `;
+                
+                hostsGrid.appendChild(hostCard);
+            });
+        }
+
+        function renderHostsPage() {
+            const hostsList = document.getElementById('hostsList');
+            hostsList.innerHTML = hosts.map(host => {
+                const hostContainers = containers.filter(c => c.host_id === host.id);
+                return `
+                    <div class="list-card">
+                        <div class="list-card-info">
+                            <div class="list-card-title">${escapeHtml(host.name)} ${getSecurityStatusBadge(host)}</div>
+                            <div class="list-card-details">${escapeHtml(host.url)} • ${hostContainers.length} containers</div>
+                            <div class="list-card-details" style="margin-top: 4px;">
+                                Status: <span class="status-${host.status}">${host.status}</span>
+                                ${host.error ? `• Error: ${escapeHtml(host.error)}` : ''}
+                            </div>
+                        </div>
+                        <div class="list-card-actions">
+                            <button class="btn-icon" onclick="editHost('${host.id}')" title="Edit Host"><i data-lucide="edit"></i></button>
+                            <button class="btn-icon" onclick="deleteHost('${host.id}')" title="Delete Host"><i data-lucide="trash-2"></i></button>
+                        </div>
+                    </div>
+                `;
+            }).join('');
+            initIcons();
+        }
+
+        function renderAlertsPage() {
+            renderAlertRules();
+        }
+
+        function renderAlertRules() {
+            try {
+                const alertRulesList = document.getElementById('alertRulesList');
+                if (!alertRulesList) return;
+
+                alertRulesList.innerHTML = '';
+
+                if (!alertRules || !Array.isArray(alertRules)) {
+                    logger.warn('alertRules is not an array:', alertRules);
+                    return;
+                }
+
+                alertRules.forEach(rule => {
+                const ruleCard = document.createElement('div');
+                ruleCard.className = 'list-card';
+
+                // Map channel IDs to channel names
+                const channelBadges = (rule.notification_channels || []).map(channelId => {
+                    const channel = notificationChannels.find(ch => ch.id === channelId);
+                    const channelName = channel ? channel.name : `Channel ${channelId}`;
+                    return `<span class="channel-badge">${channelName}</span>`;
+                }).join('');
+
+                // Display container information
+                let containerInfo = '';
+                if (rule.containers && rule.containers.length > 0) {
+                    // Group containers by name to count hosts per container
+                    const containerHostCount = {};
+                    rule.containers.forEach(c => {
+                        if (!containerHostCount[c.container_name]) {
+                            containerHostCount[c.container_name] = new Set();
+                        }
+                        containerHostCount[c.container_name].add(c.host_id);
+                    });
+
+                    // Build display string showing container names with host counts
+                    const containerParts = Object.entries(containerHostCount).map(([name, hosts]) => {
+                        if (hosts.size > 1) {
+                            return `${name} (${hosts.size} hosts)`;
+                        }
+                        return name;
+                    });
+
+                    containerInfo = containerParts.join(', ');
+                } else {
+                    containerInfo = 'All containers';
+                }
+
+                // Display trigger information
+                let triggerInfo = [];
+                if (rule.trigger_states && rule.trigger_states.length > 0) {
+                    triggerInfo.push(`States: ${rule.trigger_states.join(', ')}`);
+                }
+                if (rule.trigger_events && rule.trigger_events.length > 0) {
+                    triggerInfo.push(`Events: ${rule.trigger_events.join(', ')}`);
+                }
+                const triggerText = triggerInfo.length > 0 ? triggerInfo.join(' | ') : 'No triggers';
+
+                // Check if rule has orphaned containers
+                const isOrphaned = rule.is_orphaned || false;
+                const orphanedContainers = rule.orphaned_containers || [];
+                let orphanWarning = '';
+                if (isOrphaned && orphanedContainers.length > 0) {
+                    const orphanNames = orphanedContainers.map(c => `${escapeHtml(c.container_name)} (${escapeHtml(c.host_name)})`).join(', ');
+                    orphanWarning = `
+                        <div class="alert-warning" style="margin-top: 8px; padding: 8px; background: var(--warning); color: var(--dark); border-radius: 4px; font-size: 12px;">
+                            <i data-lucide="alert-triangle" style="width:14px;height:14px;vertical-align:middle;"></i>
+                            <strong>Warning:</strong> Container(s) not found: ${orphanNames}
+                        </div>
+                    `;
+                }
+
+                ruleCard.innerHTML = `
+                    <div class="list-card-info">
+                        <div class="list-card-title">
+                            ${rule.name}
+                            ${isOrphaned ? '<span style="margin-left: 8px; padding: 2px 6px; background: var(--warning); color: var(--dark); border-radius: 3px; font-size: 11px; font-weight: bold;">⚠ BROKEN</span>' : ''}
+                        </div>
+                        <div class="list-card-details">Containers: ${containerInfo} | ${triggerText}</div>
+                        <div class="alert-channels">${channelBadges}</div>
+                        ${orphanWarning}
+                    </div>
+                    <div class="list-card-actions">
+                        <button class="btn-icon" onclick="editAlertRule('${rule.id}')" title="Edit Alert Rule">
+                            <i data-lucide="edit"></i>
+                        </button>
+                        <button class="btn-icon" onclick="deleteAlertRule('${rule.id}')" title="Delete Alert Rule">
+                            <i data-lucide="trash-2"></i>
+                        </button>
+                    </div>
+                `;
+                
+                alertRulesList.appendChild(ruleCard);
+                });
+            } catch (error) {
+                logger.error('Error rendering alert rules:', error);
+            }
+            initIcons();
+        }
+
+        // Update functions
+        function updateStats() {
+            // Stats are now handled by dashboard widgets
+            // Only update if we're not on the dashboard page (for backward compatibility)
+            if (currentPage !== 'dashboard') {
+                const totalHostsEl = document.getElementById('totalHosts');
+                const totalContainersEl = document.getElementById('totalContainers');
+                const runningContainersEl = document.getElementById('runningContainers');
+                const alertRulesEl = document.getElementById('alertRules');
+
+                if (totalHostsEl) totalHostsEl.textContent = hosts.length;
+                if (totalContainersEl) totalContainersEl.textContent = containers.length;
+                if (runningContainersEl) runningContainersEl.textContent = containers.filter(c => c.state === 'running').length;
+                if (alertRulesEl) alertRulesEl.textContent = alertRules.length;
+            }
+        }
+
+        function updateNavBadges() {
+            // Navigation badges removed - stats are shown in dashboard widget instead
+        }
+
+        // Helper functions
+        function getContainerIcon(state) {
+            switch(state) {
+                case 'running': return '▶';
+                case 'exited': return '■';
+                case 'paused': return '⏸';
+                default: return '?';
+            }
+        }
+
+        function getStateClass(state) {
+            switch(state) {
+                case 'running': return 'status-online';
+                case 'exited': return 'status-offline';
+                case 'paused': return 'channel-pushover';
+                default: return '';
+            }
+        }
+
+        // Modal functions
+        function openHostModal() {
+            // Reset form for adding new host
+            const modalTitle = document.querySelector('#hostModal .modal-title');
+            const submitButton = document.querySelector('#hostModal button[type="submit"]');
+
+            modalTitle.textContent = 'Add Docker Host';
+            submitButton.textContent = 'Add Host';
+
+            // Clear the form
+            document.querySelector('input[name="hostname"]').value = '';
+            document.querySelector('input[name="hosturl"]').value = '';
+
+            // Clear editing state
+            window.editingHost = null;
+
+            // Hide security warning and certificates
+            checkHostSecurity('');
+
+            document.getElementById('hostModal').classList.add('active');
+            // Certificate paste mode is already visible
+        }
+
+        function checkHostSecurity(url) {
+            const securityWarning = document.getElementById('security-warning');
+            const tlsCertificates = document.getElementById('tls-certificates');
+
+            // Show warning and certificate fields for TCP connections
+            if (url && url.toLowerCase().startsWith('tcp://')) {
+                // Check if we're editing an existing secure host
+                const isEditingSecureHost = window.editingHost && window.editingHost.security_status === 'secure';
+
+                if (isEditingSecureHost) {
+                    // Host is already configured as secure, no warning needed
+                    securityWarning.style.display = 'none';
+                } else {
+                    // New host or insecure host, show warning
+                    securityWarning.style.display = 'flex';
+                }
+
+                // Always show certificate fields for TCP connections
+                tlsCertificates.style.display = 'block';
+            } else {
+                securityWarning.style.display = 'none';
+                tlsCertificates.style.display = 'none';
+            }
+        }
+
+
+        async function getCertificateData(formData, certType) {
+            // Get from text input (copy/paste mode only)
+            const textData = formData.get(`${certType}-text`);
+            if (textData && textData.trim()) {
+                return textData.trim();
+            }
+            return null;
+        }
+
+        function toggleAllContainers(checkbox) {
+            const containerCheckboxes = document.querySelectorAll('#containerSelectionCheckboxes input[type="checkbox"]');
+
+            // When "Monitor All" is checked, check all individual containers
+            // When unchecked, uncheck all individual containers
+            // This allows users to select all then uncheck the ones they don't want
+            containerCheckboxes.forEach(cb => cb.checked = checkbox.checked);
+        }
+
+        function populateContainerCheckboxes() {
+            const container = document.getElementById('containerSelectionCheckboxes');
+            container.innerHTML = '';
+
+            // Group containers by host
+            const containersByHost = {};
+            containers.forEach(cont => {
+                const hostName = cont.host_name || 'Unknown Host';
+                if (!containersByHost[hostName]) {
+                    containersByHost[hostName] = [];
+                }
+                containersByHost[hostName].push(cont);
+            });
+
+            // Create checkboxes grouped by host
+            Object.keys(containersByHost).sort().forEach(hostName => {
+                // Host header
+                const hostDiv = document.createElement('div');
+                hostDiv.style.marginBottom = '15px';
+
+                const hostHeader = document.createElement('div');
+                hostHeader.style.fontWeight = 'bold';
+                hostHeader.style.marginBottom = '8px';
+                hostHeader.style.color = 'var(--primary)';
+                hostHeader.textContent = hostName;
+                hostDiv.appendChild(hostHeader);
+
+                // Container checkboxes for this host
+                const containersDiv = document.createElement('div');
+                containersDiv.style.paddingLeft = '20px';
+
+                containersByHost[hostName].sort((a, b) => a.name.localeCompare(b.name)).forEach(cont => {
+                    const label = document.createElement('label');
+                    label.className = 'checkbox-item';
+                    label.style.display = 'flex';
+                    label.style.alignItems = 'center';
+                    label.style.gap = '8px';
+                    label.style.marginBottom = '5px';
+
+                    const checkbox = document.createElement('input');
+                    checkbox.type = 'checkbox';
+                    checkbox.value = cont.name;
+                    checkbox.dataset.hostId = cont.host_id;
+                    checkbox.dataset.containerId = cont.id;
+
+                    const stateIndicator = document.createElement('span');
+                    stateIndicator.style.display = 'inline-block';
+                    stateIndicator.style.width = '8px';
+                    stateIndicator.style.height = '8px';
+                    stateIndicator.style.borderRadius = '50%';
+                    stateIndicator.style.backgroundColor = cont.state === 'running' ? '#00c48c' : '#ff647c';
+
+                    const text = document.createElement('span');
+                    text.textContent = cont.name;
+
+                    label.appendChild(checkbox);
+                    label.appendChild(stateIndicator);
+                    label.appendChild(text);
+                    containersDiv.appendChild(label);
+                });
+
+                hostDiv.appendChild(containersDiv);
+                container.appendChild(hostDiv);
+            });
+
+            // If no containers, show message
+            if (Object.keys(containersByHost).length === 0) {
+                container.innerHTML = '<p style="color: var(--text-tertiary); text-align: center;">No containers available</p>';
+            }
+        }
+
+        function openAlertRuleModal(preselectedContainer = null, editRule = null) {
+            // Update modal title and button text based on mode
+            const modalTitle = document.querySelector('#alertRuleModal .modal-title');
+            const submitButton = document.querySelector('#alertRuleModal button[type="submit"]');
+
+            if (editRule) {
+                modalTitle.textContent = 'Edit Alert Rule';
+                submitButton.textContent = 'Update Alert Rule';
+                // Store the rule being edited
+                editingAlertRule = editRule;
+                // Populate form with existing rule data
+                document.getElementById('alertRuleName').value = editRule.name || '';
+
+                // We'll populate other fields after the form is built
+                setTimeout(() => {
+                    // Select trigger states - handled individually below for better control
+
+                    // Select notification channels
+                    if (editRule.notification_channels) {
+                        editRule.notification_channels.forEach(channelId => {
+                            const checkbox = document.querySelector(`input[value="${channelId}"]`);
+                            if (checkbox) checkbox.checked = true;
+                        });
+                    }
+
+                    // Set cooldown
+                    const cooldownInput = document.getElementById('cooldownMinutes');
+                    if (cooldownInput && editRule.cooldown_minutes) {
+                        cooldownInput.value = editRule.cooldown_minutes;
+                    }
+                }, 100);
+            } else {
+                modalTitle.textContent = 'Create Alert Rule';
+                submitButton.textContent = 'Create Alert Rule';
+                // Clear the form completely
+                document.getElementById('alertRuleName').value = '';
+                editingAlertRule = null;
+
+                // Clear all checkboxes (events, states, containers, channels)
+                document.querySelectorAll('#alertRuleModal input[type="checkbox"]').forEach(cb => cb.checked = false);
+
+                // Reset container selection visibility (in case it was hidden from editing an "all containers" rule)
+                document.getElementById('containerSelectionCheckboxes').style.display = 'block';
+
+                // Set default selections for new alerts
+                setTimeout(() => {
+                    // Default events: OOM, Die (non-zero), Health: Unhealthy
+                    const defaultEvents = ['oom', 'die-nonzero', 'health_status:unhealthy'];
+                    defaultEvents.forEach(event => {
+                        const checkbox = document.querySelector(`input[type="checkbox"][data-event="${event}"]`);
+                        if (checkbox) checkbox.checked = true;
+                    });
+
+                    // Default states: Exited, Dead
+                    const defaultStates = ['exited', 'dead'];
+                    defaultStates.forEach(state => {
+                        const checkbox = document.querySelector(`input[type="checkbox"][data-state="${state}"]`);
+                        if (checkbox) checkbox.checked = true;
+                    });
+                }, 50);
+            }
+
+            // Populate container checkboxes
+            populateContainerCheckboxes();
+
+            // If editing a rule, restore the selected containers
+            if (editRule) {
+                // First, check if the rule has the new container+host pairs format
+                if (editRule.containers && editRule.containers.length > 0) {
+                    // New format: use specific container+host pairs
+                    document.getElementById('selectAllContainers').checked = false;
+                    document.getElementById('containerSelectionCheckboxes').style.display = 'block';
+                    document.querySelectorAll('#containerSelectionCheckboxes input[type="checkbox"]').forEach(cb => {
+                        cb.checked = false; // Clear all first
+                    });
+
+                    editRule.containers.forEach(containerPair => {
+                        document.querySelectorAll('#containerSelectionCheckboxes input[type="checkbox"]').forEach(cb => {
+                            if (cb.value === containerPair.container_name &&
+                                cb.dataset.hostId === containerPair.host_id) {
+                                cb.checked = true;
+                            }
+                        });
+                    });
+                } else {
+                    // Empty containers array means "all containers"
+                    document.getElementById('selectAllContainers').checked = true;
+                    // Check all individual checkboxes to show "all selected" state
+                    document.querySelectorAll('#containerSelectionCheckboxes input[type="checkbox"]').forEach(cb => {
+                        cb.checked = true;
+                    });
+                }
+            }
+
+            // Pre-select container if one was specified (must match both container name AND host)
+            if (preselectedContainer && !editRule) {
+                document.querySelectorAll('#containerSelectionCheckboxes input[type="checkbox"]').forEach(cb => {
+                    if (cb.value === preselectedContainer.name && cb.dataset.hostId === preselectedContainer.host_id) {
+                        cb.checked = true;
+                    }
+                });
+            }
+
+            // Populate notification channels
+            populateNotificationChannels();
+
+            // If editing, populate form fields
+            if (editRule) {
+                // Clear and set trigger checkboxes immediately (no setTimeout needed here)
+                // Clear only trigger state and event checkboxes first (not container or notification checkboxes)
+                document.querySelectorAll('#alertRuleModal input[type="checkbox"][data-state]').forEach(cb => cb.checked = false);
+                document.querySelectorAll('#alertRuleModal input[type="checkbox"][data-event]').forEach(cb => cb.checked = false);
+
+                // Check appropriate boxes based on trigger events
+                if (editRule.trigger_events) {
+                    editRule.trigger_events.forEach(event => {
+                        const checkbox = document.querySelector(`input[type="checkbox"][data-event="${event}"]`);
+                        if (checkbox) checkbox.checked = true;
+                    });
+                }
+
+                // Check appropriate boxes based on trigger states
+                if (editRule.trigger_states) {
+                    editRule.trigger_states.forEach(state => {
+                        const checkbox = document.querySelector(`input[type="checkbox"][data-state="${state}"]`);
+                        if (checkbox) checkbox.checked = true;
+                    });
+                }
+
+                // Set notification channels - with small delay to ensure they're loaded
+                setTimeout(() => {
+                    if (editRule.notification_channels) {
+                        editRule.notification_channels.forEach(channelId => {
+                            const channelCheckbox = document.querySelector(`input[type="checkbox"][data-channel-id="${channelId}"]`);
+                            if (channelCheckbox) channelCheckbox.checked = true;
+                        });
+                    }
+                }, 100); // Small delay to ensure notification channels are loaded
+            }
+
+            document.getElementById('alertRuleModal').classList.add('active');
+        }
+
+
+
+        async function deleteHost(hostId) {
+            const host = hosts.find(h => h.id === hostId);
+            const hostName = host ? host.name : 'Unknown Host';
+
+            const message = `Are you sure you want to delete the host <strong>"${hostName}"</strong>?<br><br>
+                This will:<br>
+                • Remove the host and all its containers<br>
+                • Remove this host's containers from alert rules<br>
+                • Delete alerts that only monitor this host's containers<br>
+                • Stop all monitoring for this host<br><br>
+                <strong>This action cannot be undone.</strong>`;
+
+            showConfirmation('Delete Host', message, 'Delete Host', async () => {
+                try {
+                    const response = await fetch(`${API_BASE}/api/hosts/${hostId}`, {
+                        method: 'DELETE'
+                    });
+
+                    if (response.ok) {
+                        showToast('Host removed');
+                        // Fetch fresh data from server
+                        await fetchHosts();
+                        await fetchContainers();
+                        await fetchAlertRules();
+                        renderHostsPage();
+                        renderHosts();
+                        updateStats();
+                        updateNavBadges();
+                    }
+                } catch (error) {
+                    logger.error('Error deleting host:', error);
+                    showToast('❌ Failed to delete host');
+                }
+            });
+        }
+
+        function editHost(hostId) {
+            // Find the host to edit
+            const host = hosts.find(h => h.id === hostId);
+            if (!host) {
+                showToast('❌ Host not found');
+                return;
+            }
+
+            // Populate the form with existing host data
+            document.querySelector('input[name="hostname"]').value = host.name;
+            document.querySelector('input[name="hosturl"]').value = host.url;
+
+            // Set up the modal for editing
+            const modalTitle = document.querySelector('#hostModal .modal-title');
+            const submitButton = document.querySelector('#hostModal button[type="submit"]');
+
+            modalTitle.textContent = 'Edit Docker Host';
+            submitButton.textContent = 'Update Host';
+
+            // Store the host being edited
+            window.editingHost = host;
+
+            // Check security and show certificate fields if needed
+            checkHostSecurity(host.url);
+
+            // Show the modal
+            document.getElementById('hostModal').classList.add('active');
+        }
+
+        async function refreshAll() {
+            showToast('🔄 Refreshing...');
+            await Promise.all([
+                fetchHosts(),
+                fetchContainers(),
+                fetchAlertRules()
+            ]);
+            renderHosts();
+
+            // Refresh logs dropdown if on logs page
+            if (currentPage === 'logs' && typeof populateContainerList === 'function') {
+                populateContainerList();
+            }
+        }
+
+        async function showContainerDetails(hostId, containerId, preserveTab = null) {
+            const container = containers.find(c => c.host_id === hostId && c.short_id === containerId);
+            if (container) {
+                // Only reset logs if we're switching to a different container
+                if (!window.currentContainer || window.currentContainer.host_id !== container.host_id || window.currentContainer.short_id !== container.short_id) {
+                    // Stop any existing log polling when switching containers
+                    stopAutoRefresh();
+
+                    // Clear logs from previous container
+                    const logsDiv = document.getElementById('container-logs');
+                    if (logsDiv) {
+                        logsDiv.innerHTML = '<div style="color: var(--text-tertiary);">Loading logs...</div>';
+                    }
+                    // Reset log state and filter
+                    lastLogTimestamp = null;
+                    accumulatedLogs = [];
+                    const filterInput = document.getElementById('logSearchFilter');
+                    if (filterInput) {
+                        filterInput.value = '';
+                    }
+                    const matchCount = document.getElementById('logMatchCount');
+                    if (matchCount) {
+                        matchCount.textContent = '';
+                    }
+                }
+
+                // Store current container info globally for modal functions
+                window.currentContainer = container;
+
+                // Check if there's an alert rule for this container on this specific host
+                const hasAlert = alertRules.some(rule => {
+                    // Check new container+host pairs format first
+                    if (rule.containers && rule.containers.length > 0) {
+                        return rule.containers.some(c =>
+                            c.container_name === container.name && c.host_id === container.host_id
+                        );
+                    }
+                    return false;
+                });
+                
+                // Populate container details
+                const detailsHtml = `
+                    <div style="display: grid; grid-template-columns: 1fr 1fr; gap: 15px; margin-bottom: 20px;">
+                        <div>
+                            <strong>Name:</strong> ${escapeHtml(container.name)}<br>
+                            <strong>ID:</strong> ${escapeHtml(container.short_id)}<br>
+                            <strong>Image:</strong> ${escapeHtml(container.image)}<br>
+                        </div>
+                        <div>
+                            <strong>State:</strong> <span class="${getStateClass(container.state)}">${container.state}</span><br>
+                            <strong>Host:</strong> ${escapeHtml(container.host_name)}<br>
+                            <strong>Created:</strong> ${new Date(container.created).toLocaleString()}<br>
+                        </div>
+                    </div>
+                    <div class="container-actions" style="display: flex; gap: 10px; flex-wrap: wrap;" id="container-actions-${container.short_id}">
+                        ${container.state === 'running' ? `
+                            <button class="btn btn-danger" id="container-state-btn-${container.short_id}" onclick="stopContainer('${container.host_id}', '${container.id}')">
+                                <i data-lucide="square"></i> Stop Container
+                            </button>
+                        ` : `
+                            <button class="btn btn-primary" id="container-state-btn-${container.short_id}" onclick="startContainer('${container.host_id}', '${container.id}')">
+                                <i data-lucide="play"></i> Start Container
+                            </button>
+                        `}
+                        <button class="btn btn-secondary" onclick="restartContainer('${container.host_id}', '${container.id}')">
+                            <i data-lucide="rotate-cw"></i> Restart Container
+                        </button>
+                        <button class="btn btn-secondary" onclick="createAlertForContainer('${container.id}')">
+                            <i data-lucide="zap"></i> ${hasAlert ? 'Edit Alert' : 'Create Alert'}
+                        </button>
+                        <div class="auto-restart-toggle ${container.auto_restart ? 'enabled' : ''}"
+                             onclick="toggleAutoRestart('${container.host_id}', '${container.id}', event)">
+                            <span><i data-lucide="rotate-cw" style="width:14px;height:14px;"></i> Auto-restart: ${container.auto_restart ? 'ON' : 'OFF'}</span>
+                        </div>
+                    </div>
+                    ${container.state === 'running' ? `
+                    <div class="container-stats-sparklines" style="display: grid; grid-template-columns: repeat(4, 1fr); gap: 15px; margin-top: 20px;">
+                        <div>
+                            <div style="font-size: 11px; color: var(--text-tertiary); margin-bottom: 5px;">CPU</div>
+                            <canvas id="info-cpu-sparkline" width="60" height="30"></canvas>
+                            <div style="font-size: 12px; font-weight: 600; margin-top: 5px;" id="info-cpu-value">0%</div>
+                        </div>
+                        <div>
+                            <div style="font-size: 11px; color: var(--text-tertiary); margin-bottom: 5px;">Memory</div>
+                            <canvas id="info-memory-sparkline" width="60" height="30"></canvas>
+                            <div style="font-size: 12px; font-weight: 600; margin-top: 5px;" id="info-memory-value">0 B</div>
+                        </div>
+                        <div>
+                            <div style="font-size: 11px; color: var(--text-tertiary); margin-bottom: 5px;">Network</div>
+                            <canvas id="info-network-sparkline" width="60" height="30"></canvas>
+                            <div style="font-size: 12px; font-weight: 600; margin-top: 5px;" id="info-network-value">0 B/s</div>
+                        </div>
+                        <div>
+                            <div style="font-size: 11px; color: var(--text-tertiary); margin-bottom: 5px;">Disk I/O</div>
+                            <canvas id="info-disk-sparkline" width="60" height="30"></canvas>
+                            <div style="font-size: 12px; font-weight: 600; margin-top: 5px;" id="info-disk-value">0 B/s</div>
+                        </div>
+                    </div>
+                    ` : ''}
+                    <div id="container-recent-events" style="margin-top: 20px;">
+                        <div style="color: var(--text-tertiary); font-size: 14px;">Loading recent events...</div>
+                    </div>
+                `;
+
+                document.getElementById('container-info-content').innerHTML = detailsHtml;
+
+                // Load recent events for this container
+                loadContainerRecentEvents(container.name, container.host_id);
+
+                // Initialize Lucide icons after content is added
+                initIcons();
+
+                // Initialize both sparklines and stats charts if container is running
+                // A single master update loop will update both continuously
+                if (container.state === 'running') {
+                    initializeInfoSparklines();
+                    initializeContainerStatsCharts();
+                    // Start the master update loop after a delay to avoid initial spike
+                    setTimeout(updateContainerStats, 2000);
+
+                    // Notify backend to start stats collection for this container (even if global stats are disabled)
+                    if (ws && ws.readyState === WebSocket.OPEN) {
+                        ws.send(JSON.stringify({
+                            type: 'modal_opened',
+                            container_id: container.id,
+                            host_id: container.host_id
+                        }));
+                    }
+                }
+
+                // Show modal
+                const modal = document.getElementById('containerModal');
+                modal.classList.add('active');
+
+                // Load saved preferences or reset modal position
+                const modalContent = modal.querySelector('.modal-content');
+                if (modalContent) {
+                    const savedPrefs = await loadModalPreferences();
+                    if (!savedPrefs) {
+                        // No saved preferences, use defaults
+                        modalContent.style.width = '900px';
+                        modalContent.style.height = '820px';
+                        modalContent.style.transform = 'translate(0, 0)';
+                    }
+                }
+
+                // Make modal draggable
+                makeModalDraggable('containerModal');
+
+                // Add resize observer to adjust logs height and save preferences when modal is resized
+                const resizeObserver = new ResizeObserver(entries => {
+                    for (let entry of entries) {
+                        if (entry.target.classList.contains('modal-content')) {
+                            adjustLogsHeight();
+                            // Save size after resize (debounced)
+                            clearTimeout(window.resizeSaveTimeout);
+                            window.resizeSaveTimeout = setTimeout(saveModalPreferences, 500);
+                        }
+                    }
+                });
+                resizeObserver.observe(modalContent);
+
+                // Store observer for cleanup
+                if (!window.modalResizeObserver) {
+                    window.modalResizeObserver = resizeObserver;
+                } else {
+                    // Disconnect previous observer if it exists
+                    window.modalResizeObserver.disconnect();
+                    window.modalResizeObserver = resizeObserver;
+                }
+
+                // Show the appropriate tab
+                if (preserveTab) {
+                    // Preserve the current tab selection
+                    showTab(preserveTab);
+                } else {
+                    // Show info tab by default for new modal opens
+                    showTab('info');
+                }
+            }
+        }
+
+        // Container Modal Functions
+        function showTab(tab) {
+            // Hide all tabs
+            document.querySelectorAll('.tab-content').forEach(content => {
+                content.style.display = 'none';
+            });
+
+            // Remove active class from all tab buttons
+            document.querySelectorAll('[id^="tab-"]').forEach(btn => {
+                btn.classList.remove('btn-primary');
+                btn.classList.add('btn-secondary');
+            });
+
+            // Show selected tab
+            document.getElementById(`${tab}-tab`).style.display = 'block';
+            document.getElementById(`tab-${tab}`).classList.remove('btn-secondary');
+            document.getElementById(`tab-${tab}`).classList.add('btn-primary');
+
+            // Charts are already initialized and updating via master loop - no action needed
+
+            // Adjust logs height when switching to logs tab
+            if (tab === 'logs') {
+                // Check for saved logs height preference
+                const saved = localStorage.getItem('containerModalPrefs');
+                if (saved) {
+                    try {
+                        const prefs = JSON.parse(saved);
+                        const logsDiv = document.getElementById('container-logs');
+                        if (prefs.logsHeight && logsDiv) {
+                            logsDiv.style.height = prefs.logsHeight;
+                        } else {
+                            adjustLogsHeight();
+                        }
+                    } catch (e) {
+                        adjustLogsHeight();
+                    }
+                } else {
+                    adjustLogsHeight();
+                }
+            }
+
+            // Auto-fetch logs when logs tab is opened
+            if (tab === 'logs' && window.currentContainer) {
+                fetchContainerLogs();
+                // Start auto-refresh if checkbox is checked
+                const autoRefresh = document.getElementById('autoRefreshLogs');
+                if (autoRefresh && autoRefresh.checked && !logPollInterval) {
+                    startAutoRefresh();
+                }
+
+                // Add keyboard shortcut for filter (Ctrl/Cmd + F)
+                if (!window.logFilterKeyHandler) {
+                    window.logFilterKeyHandler = function(e) {
+                        const logsTabVisible = document.getElementById('logs-tab').style.display !== 'none';
+                        const modalActive = document.getElementById('containerModal').classList.contains('active');
+
+                        if (modalActive && logsTabVisible && (e.ctrlKey || e.metaKey) && e.key === 'f') {
+                            e.preventDefault();
+                            const filterInput = document.getElementById('logSearchFilter');
+                            if (filterInput) {
+                                filterInput.focus();
+                                filterInput.select();
+                            }
+                        }
+                    };
+                    document.addEventListener('keydown', window.logFilterKeyHandler);
+                }
+            } else if (tab !== 'logs') {
+                // Stop auto-refresh when leaving logs tab
+                stopAutoRefresh();
+
+                // Remove keydown event listener
+                if (window.logFilterKeyHandler) {
+                    document.removeEventListener('keydown', window.logFilterKeyHandler);
+                }
+            }
+            
+            // Clear log stream if switching away from logs
+            if (tab !== 'logs' && window.logStreamWs) {
+                window.logStreamWs.close();
+                window.logStreamWs = null;
+                document.getElementById('streamLogsBtn').textContent = 'Start Live Stream';
+            }
+        }
+
+        // Container Statistics Charts
+        let containerStatsCharts = {};
+        let containerStatsPrevValues = null; // For rate calculation
+        let containerStatsFirstUpdate = true; // Flag to skip first rate calculation
+
+        function initializeContainerStatsCharts() {
+            if (!window.currentContainer) return;
+
+            // Destroy existing charts if they exist
+            Object.values(containerStatsCharts).forEach(chart => {
+                if (chart) chart.destroy();
+            });
+            containerStatsCharts = {};
+
+            // Reset first update flag
+            containerStatsFirstUpdate = true;
+
+            // Initialize previous values for rate calculation - will be set on first update
+            containerStatsPrevValues = null;
+
+            // Create CPU chart
+            const cpuCanvas = document.getElementById('container-cpu-chart');
+            if (cpuCanvas) {
+                containerStatsCharts.cpu = new Chart(cpuCanvas.getContext('2d'), {
+                    type: 'line',
+                    data: {
+                        labels: [],
+                        datasets: [{
+                            label: 'CPU %',
+                            data: [],
+                            borderColor: '#3b82f6',
+                            backgroundColor: 'rgba(59, 130, 246, 0.1)',
+                            borderWidth: 2,
+                            fill: true,
+                            tension: 0.4
+                        }]
+                    },
+                    options: {
+                        responsive: true,
+                        maintainAspectRatio: true,
+                        plugins: {
+                            legend: { display: false },
+                            tooltip: {
+                                enabled: true,
+                                callbacks: {
+                                    label: (context) => {
+                                        return `CPU: ${context.parsed.y.toFixed(1)}%`;
+                                    }
+                                }
+                            }
+                        },
+                        scales: {
+                            x: { display: false },
+                            y: {
+                                beginAtZero: true,
+                                max: 100,
+                                ticks: { callback: value => value + '%' }
+                            }
+                        },
+                        animation: { duration: 300 }
+                    }
+                });
+            }
+
+            // Create Memory chart
+            const memoryCanvas = document.getElementById('container-memory-chart');
+            if (memoryCanvas) {
+                containerStatsCharts.memory = new Chart(memoryCanvas.getContext('2d'), {
+                    type: 'line',
+                    data: {
+                        labels: [],
+                        datasets: [{
+                            label: 'Memory (MiB)',
+                            data: [],
+                            borderColor: '#10b981',
+                            backgroundColor: 'rgba(16, 185, 129, 0.1)',
+                            borderWidth: 2,
+                            fill: true,
+                            tension: 0.4
+                        }]
+                    },
+                    options: {
+                        responsive: true,
+                        maintainAspectRatio: true,
+                        plugins: {
+                            legend: { display: false },
+                            tooltip: {
+                                enabled: true,
+                                callbacks: {
+                                    label: (context) => {
+                                        return `Memory: ${context.parsed.y.toFixed(1)} MiB`;
+                                    }
+                                }
+                            }
+                        },
+                        scales: {
+                            x: { display: false },
+                            y: {
+                                beginAtZero: true,
+                                ticks: { callback: value => (value / 1024 / 1024).toFixed(0) + ' MiB' }
+                            }
+                        },
+                        animation: { duration: 300 }
+                    }
+                });
+            }
+
+            // Create Network chart (dual line: Tx and Rx)
+            const networkCanvas = document.getElementById('container-network-chart');
+            if (networkCanvas) {
+                containerStatsCharts.network = new Chart(networkCanvas.getContext('2d'), {
+                    type: 'line',
+                    data: {
+                        labels: [],
+                        datasets: [
+                            {
+                                label: 'TX (sent)',
+                                data: [],
+                                borderColor: '#06b6d4',
+                                backgroundColor: 'transparent',
+                                borderWidth: 2,
+                                tension: 0.4
+                            },
+                            {
+                                label: 'RX (received)',
+                                data: [],
+                                borderColor: '#a855f7',
+                                backgroundColor: 'transparent',
+                                borderWidth: 2,
+                                tension: 0.4
+                            }
+                        ]
+                    },
+                    options: {
+                        responsive: true,
+                        maintainAspectRatio: true,
+                        plugins: {
+                            legend: { display: true, position: 'top' },
+                            tooltip: {
+                                enabled: true,
+                                callbacks: {
+                                    label: (context) => {
+                                        return `${context.dataset.label}: ${formatBytes(context.parsed.y)}/s`;
+                                    }
+                                }
+                            }
+                        },
+                        scales: {
+                            x: { display: false },
+                            y: {
+                                beginAtZero: true,
+                                ticks: {
+                                    callback: function(value) {
+                                        if (typeof value !== 'number' || !isFinite(value)) return '0 B/s';
+                                        return formatBytes(value) + '/s';
+                                    }
+                                }
+                            }
+                        },
+                        animation: { duration: 300 }
+                    }
+                });
+            }
+
+            // Create Disk I/O chart (dual line: Read and Write)
+            const diskCanvas = document.getElementById('container-disk-chart');
+            if (diskCanvas) {
+                containerStatsCharts.disk = new Chart(diskCanvas.getContext('2d'), {
+                    type: 'line',
+                    data: {
+                        labels: [],
+                        datasets: [
+                            {
+                                label: 'Read',
+                                data: [],
+                                borderColor: '#f59e0b',
+                                backgroundColor: 'transparent',
+                                borderWidth: 2,
+                                tension: 0.4
+                            },
+                            {
+                                label: 'Write',
+                                data: [],
+                                borderColor: '#ef4444',
+                                backgroundColor: 'transparent',
+                                borderWidth: 2,
+                                tension: 0.4
+                            }
+                        ]
+                    },
+                    options: {
+                        responsive: true,
+                        maintainAspectRatio: true,
+                        plugins: {
+                            legend: { display: true, position: 'top' },
+                            tooltip: {
+                                enabled: true,
+                                callbacks: {
+                                    label: (context) => {
+                                        return `${context.dataset.label}: ${formatBytes(context.parsed.y)}/s`;
+                                    }
+                                }
+                            }
+                        },
+                        scales: {
+                            x: { display: false },
+                            y: {
+                                beginAtZero: true,
+                                ticks: {
+                                    callback: function(value) {
+                                        if (typeof value !== 'number' || !isFinite(value)) return '0 B/s';
+                                        return formatBytes(value) + '/s';
+                                    }
+                                }
+                            }
+                        },
+                        animation: { duration: 300 }
+                    }
+                });
+            }
+
+            // Don't start the loop here - it will be started by the master update loop
+        }
+
+        // Update container stats charts with latest data
+        function updateContainerStatsCharts(container, now) {
+            if (!containerStatsCharts.cpu) return;
+
+            // Update CPU chart
+            if (containerStatsCharts.cpu) {
+                const cpuData = containerStatsCharts.cpu.data;
+                cpuData.labels.push(now);
+                cpuData.datasets[0].data.push(container.cpu_percent || 0);
+                while (cpuData.labels.length > 60) {
+                    cpuData.labels.shift();
+                    cpuData.datasets[0].data.shift();
+                }
+                containerStatsCharts.cpu.update('none');
+            }
+
+            // Update Memory chart
+            if (containerStatsCharts.memory) {
+                const memData = containerStatsCharts.memory.data;
+                memData.labels.push(now);
+                memData.datasets[0].data.push(container.memory_usage || 0);
+                while (memData.labels.length > 60) {
+                    memData.labels.shift();
+                    memData.datasets[0].data.shift();
+                }
+                containerStatsCharts.memory.update('none');
+            }
+
+            // Initialize or update network/disk stats with rate calculation
+            const currentTx = container.network_tx || 0;
+            const currentRx = container.network_rx || 0;
+            const currentRead = container.disk_read || 0;
+            const currentWrite = container.disk_write || 0;
+            const currentTime = Date.now();
+
+            // On first update, just initialize previous values without calculating rates
+            if (containerStatsFirstUpdate) {
+                containerStatsPrevValues = {
+                    networkTx: currentTx,
+                    networkRx: currentRx,
+                    diskRead: currentRead,
+                    diskWrite: currentWrite,
+                    timestamp: currentTime
+                };
+                containerStatsFirstUpdate = false;
+            } else if (containerStatsPrevValues) {
+                // Calculate time delta
+                const timeDelta = (currentTime - containerStatsPrevValues.timestamp) / 1000; // seconds
+
+                // Handle clock adjustments (NTP, DST, manual changes)
+                if (timeDelta < 0 || timeDelta > 300) {
+                    // Clock moved backwards or jumped forward >5 minutes - reset and skip
+                    containerStatsPrevValues.networkTx = currentTx;
+                    containerStatsPrevValues.networkRx = currentRx;
+                    containerStatsPrevValues.diskRead = currentRead;
+                    containerStatsPrevValues.diskWrite = currentWrite;
+                    containerStatsPrevValues.timestamp = currentTime;
+                    return;
+                }
+
+                // Protect against very small time delta (identical timestamps)
+                if (timeDelta < 0.1) {
+                    return; // Skip this update
+                }
+
+                // Only update if enough time has passed (minimum 1 second)
+                if (timeDelta >= 1) {
+                    // Update Network chart
+                    if (containerStatsCharts.network) {
+                        const txRate = Math.max(0, (currentTx - containerStatsPrevValues.networkTx) / timeDelta);
+                        const rxRate = Math.max(0, (currentRx - containerStatsPrevValues.networkRx) / timeDelta);
+
+                        const netData = containerStatsCharts.network.data;
+                        netData.labels.push(now);
+                        netData.datasets[0].data.push(txRate);
+                        netData.datasets[1].data.push(rxRate);
+                        while (netData.labels.length > 60) {
+                            netData.labels.shift();
+                            netData.datasets[0].data.shift();
+                            netData.datasets[1].data.shift();
+                        }
+                        containerStatsCharts.network.update('none');
+                    }
+
+                    // Update Disk chart
+                    if (containerStatsCharts.disk) {
+                        const readRate = Math.max(0, (currentRead - containerStatsPrevValues.diskRead) / timeDelta);
+                        const writeRate = Math.max(0, (currentWrite - containerStatsPrevValues.diskWrite) / timeDelta);
+
+                        const diskData = containerStatsCharts.disk.data;
+                        diskData.labels.push(now);
+                        diskData.datasets[0].data.push(readRate);
+                        diskData.datasets[1].data.push(writeRate);
+                        while (diskData.labels.length > 60) {
+                            diskData.labels.shift();
+                            diskData.datasets[0].data.shift();
+                            diskData.datasets[1].data.shift();
+                        }
+                        containerStatsCharts.disk.update('none');
+                    }
+
+                    // Update previous values
+                    containerStatsPrevValues.networkTx = currentTx;
+                    containerStatsPrevValues.networkRx = currentRx;
+                    containerStatsPrevValues.diskRead = currentRead;
+                    containerStatsPrevValues.diskWrite = currentWrite;
+                    containerStatsPrevValues.timestamp = currentTime;
+                }
+            }
+        }
+
+        // Info tab sparklines
+        let infoSparklineCharts = {};
+        let infoSparklineFirstUpdate = true; // Flag to skip first rate calculation
+
+        function initializeInfoSparklines() {
+            if (!window.currentContainer) return;
+
+            // Destroy existing sparklines
+            Object.values(infoSparklineCharts).forEach(chart => {
+                if (chart) chart.destroy();
+            });
+            infoSparklineCharts = {};
+
+            // Reset first update flag
+            infoSparklineFirstUpdate = true;
+
+            // Common sparkline options (minimal style, no axes)
+            const sparklineOptions = {
+                responsive: false,
+                maintainAspectRatio: false,
+                plugins: {
+                    legend: { display: false },
+                    tooltip: { enabled: false }
+                },
+                scales: {
+                    x: { display: false },
+                    y: { display: false }
+                },
+                animation: { duration: 0 },
+                elements: {
+                    point: { radius: 0 },
+                    line: { borderWidth: 1.5 }
+                }
+            };
+
+            // CPU sparkline
+            const cpuCanvas = document.getElementById('info-cpu-sparkline');
+            if (cpuCanvas) {
+                infoSparklineCharts.cpu = new Chart(cpuCanvas.getContext('2d'), {
+                    type: 'line',
+                    data: {
+                        labels: new Array(20).fill(''),
+                        datasets: [{
+                            data: new Array(20).fill(0),
+                            borderColor: '#3b82f6',
+                            backgroundColor: 'rgba(59, 130, 246, 0.2)',
+                            fill: true,
+                            tension: 0.4
+                        }]
+                    },
+                    options: {...sparklineOptions, scales: {...sparklineOptions.scales, y: {display: false, min: 0, max: 100}}}
+                });
+            }
+
+            // Memory sparkline
+            const memoryCanvas = document.getElementById('info-memory-sparkline');
+            if (memoryCanvas) {
+                infoSparklineCharts.memory = new Chart(memoryCanvas.getContext('2d'), {
+                    type: 'line',
+                    data: {
+                        labels: new Array(20).fill(''),
+                        datasets: [{
+                            data: new Array(20).fill(0),
+                            borderColor: '#10b981',
+                            backgroundColor: 'rgba(16, 185, 129, 0.2)',
+                            fill: true,
+                            tension: 0.4
+                        }]
+                    },
+                    options: {...sparklineOptions, scales: {...sparklineOptions.scales, y: {display: false, beginAtZero: true}}}
+                });
+            }
+
+            // Network sparkline (combined TX+RX) - purple to match host widget
+            const networkCanvas = document.getElementById('info-network-sparkline');
+            if (networkCanvas) {
+                infoSparklineCharts.network = new Chart(networkCanvas.getContext('2d'), {
+                    type: 'line',
+                    data: {
+                        labels: new Array(20).fill(''),
+                        datasets: [{
+                            data: new Array(20).fill(0),
+                            borderColor: '#a855f7',
+                            backgroundColor: 'rgba(168, 85, 247, 0.2)',
+                            fill: true,
+                            tension: 0.4
+                        }]
+                    },
+                    options: {...sparklineOptions, scales: {...sparklineOptions.scales, y: {display: false, beginAtZero: true}}}
+                });
+            }
+
+            // Disk I/O sparkline (combined read+write)
+            const diskCanvas = document.getElementById('info-disk-sparkline');
+            if (diskCanvas) {
+                infoSparklineCharts.disk = new Chart(diskCanvas.getContext('2d'), {
+                    type: 'line',
+                    data: {
+                        labels: new Array(20).fill(''),
+                        datasets: [{
+                            data: new Array(20).fill(0),
+                            borderColor: '#f59e0b',
+                            backgroundColor: 'rgba(245, 158, 11, 0.2)',
+                            fill: true,
+                            tension: 0.4
+                        }]
+                    },
+                    options: {...sparklineOptions, scales: {...sparklineOptions.scales, y: {display: false, beginAtZero: true}}}
+                });
+            }
+
+            // Initialize previous values - will be set on first update
+            window.infoSparklinePrevValues = null;
+
+            // Don't start the loop here - it will be started by the master update loop
+        }
+
+        function updateInfoSparklines(container) {
+            if (!infoSparklineCharts.cpu) return;
+
+            // Update CPU sparkline and value
+            if (infoSparklineCharts.cpu) {
+                const cpuValue = container.cpu_percent || 0;
+                const cpuData = infoSparklineCharts.cpu.data.datasets[0].data;
+                cpuData.push(cpuValue);
+                if (cpuData.length > 20) cpuData.shift();
+                infoSparklineCharts.cpu.update('none');
+
+                const cpuValueEl = document.getElementById('info-cpu-value');
+                if (cpuValueEl) cpuValueEl.textContent = `${cpuValue.toFixed(1)}%`;
+            }
+
+            // Update Memory sparkline and value (show bytes, not percentage)
+            if (infoSparklineCharts.memory) {
+                const memoryBytes = container.memory_usage || 0;
+                const memData = infoSparklineCharts.memory.data.datasets[0].data;
+                memData.push(memoryBytes);
+                if (memData.length > 20) memData.shift();
+                infoSparklineCharts.memory.update('none');
+
+                const memValueEl = document.getElementById('info-memory-value');
+                if (memValueEl) memValueEl.textContent = formatBytes(memoryBytes);
+            }
+
+            // Initialize or calculate rates - do both network and disk in one pass
+            const currentTx = container.network_tx || 0;
+            const currentRx = container.network_rx || 0;
+            const currentRead = container.disk_read || 0;
+            const currentWrite = container.disk_write || 0;
+            const now = Date.now();
+
+            // On first update, just initialize previous values without calculating rates
+            if (infoSparklineFirstUpdate) {
+                window.infoSparklinePrevValues = {
+                    networkTx: currentTx,
+                    networkRx: currentRx,
+                    diskRead: currentRead,
+                    diskWrite: currentWrite,
+                    timestamp: now
+                };
+                infoSparklineFirstUpdate = false;
+            } else if (window.infoSparklinePrevValues) {
+                const timeDelta = (now - window.infoSparklinePrevValues.timestamp) / 1000; // seconds
+
+                // Handle clock adjustments (NTP, DST, manual changes)
+                if (timeDelta < 0 || timeDelta > 300) {
+                    // Clock moved backwards or jumped forward >5 minutes - reset and skip
+                    window.infoSparklinePrevValues.networkTx = currentTx;
+                    window.infoSparklinePrevValues.networkRx = currentRx;
+                    window.infoSparklinePrevValues.diskRead = currentRead;
+                    window.infoSparklinePrevValues.diskWrite = currentWrite;
+                    window.infoSparklinePrevValues.timestamp = now;
+                    return;
+                }
+
+                // Protect against very small time delta
+                if (timeDelta < 0.1) {
+                    return;
+                }
+
+                // Only update if enough time has passed (minimum 1 second)
+                if (timeDelta >= 1) {
+                    // Calculate network rate (TX + RX combined)
+                    if (infoSparklineCharts.network) {
+                        const txRate = (currentTx - window.infoSparklinePrevValues.networkTx) / timeDelta;
+                        const rxRate = (currentRx - window.infoSparklinePrevValues.networkRx) / timeDelta;
+                        const totalNetworkRate = Math.max(0, txRate + rxRate); // Combined rate
+
+                        const netData = infoSparklineCharts.network.data.datasets[0].data;
+                        netData.push(totalNetworkRate);
+                        if (netData.length > 20) netData.shift();
+                        infoSparklineCharts.network.update('none');
+
+                        const netValueEl = document.getElementById('info-network-value');
+                        if (netValueEl) netValueEl.textContent = formatBytes(totalNetworkRate) + '/s';
+                    }
+
+                    // Calculate disk I/O rate (read + write combined)
+                    if (infoSparklineCharts.disk) {
+                        const readRate = (currentRead - window.infoSparklinePrevValues.diskRead) / timeDelta;
+                        const writeRate = (currentWrite - window.infoSparklinePrevValues.diskWrite) / timeDelta;
+                        const totalDiskRate = Math.max(0, readRate + writeRate); // Combined rate
+
+                        const diskData = infoSparklineCharts.disk.data.datasets[0].data;
+                        diskData.push(totalDiskRate);
+                        if (diskData.length > 20) diskData.shift();
+                        infoSparklineCharts.disk.update('none');
+
+                        const diskValueEl = document.getElementById('info-disk-value');
+                        if (diskValueEl) diskValueEl.textContent = formatBytes(totalDiskRate) + '/s';
+                    }
+
+                    // Update previous values and timestamp
+                    window.infoSparklinePrevValues.networkTx = currentTx;
+                    window.infoSparklinePrevValues.networkRx = currentRx;
+                    window.infoSparklinePrevValues.diskRead = currentRead;
+                    window.infoSparklinePrevValues.diskWrite = currentWrite;
+                    window.infoSparklinePrevValues.timestamp = now;
+                }
+            }
+        }
+
+        // Clean up modal charts when modal closes
+        function cleanupModalCharts() {
+            // Destroy all Stats tab charts
+            if (containerStatsCharts.cpu) {
+                containerStatsCharts.cpu.destroy();
+            }
+            if (containerStatsCharts.memory) {
+                containerStatsCharts.memory.destroy();
+            }
+            if (containerStatsCharts.network) {
+                containerStatsCharts.network.destroy();
+            }
+            if (containerStatsCharts.disk) {
+                containerStatsCharts.disk.destroy();
+            }
+            containerStatsCharts = {};
+
+            // Destroy all Info tab sparklines
+            if (infoSparklineCharts.cpu) {
+                infoSparklineCharts.cpu.destroy();
+            }
+            if (infoSparklineCharts.memory) {
+                infoSparklineCharts.memory.destroy();
+            }
+            if (infoSparklineCharts.network) {
+                infoSparklineCharts.network.destroy();
+            }
+            if (infoSparklineCharts.disk) {
+                infoSparklineCharts.disk.destroy();
+            }
+            infoSparklineCharts = {};
+        }
+
+        // Make cleanup function globally available
+        window.cleanupModalCharts = cleanupModalCharts;
+
+        // Master update loop - updates both sparklines and charts
+        function updateContainerStats() {
+            if (!window.currentContainer) return;
+
+            // Find the current container to get latest stats
+            const container = containers.find(c =>
+                c.host_id === window.currentContainer.host_id &&
+                c.id === window.currentContainer.id
+            );
+
+            if (!container) {
+                // Container disappeared - clear tracking to prevent infinite loop
+                window.currentContainer = null;
+                return;
+            }
+
+            const now = new Date().toLocaleTimeString();
+
+            // Update Info tab sparklines
+            updateInfoSparklines(container);
+
+            // Update Stats tab charts
+            updateContainerStatsCharts(container, now);
+
+            // Schedule next update if modal is still open
+            if (window.currentContainer) {
+                setTimeout(updateContainerStats, 2000);
+            }
+        }
+
+        async function fetchContainerLogs(incremental = false) {
+            if (!window.currentContainer) return;
+
+            const tailCount = document.getElementById('logTailCount').value || 100;
+            const logsDiv = document.getElementById('container-logs');
+
+            // Only show loading on first fetch
+            if (!incremental || !accumulatedLogs.length) {
+                logsDiv.innerHTML = '<div style="color: var(--text-secondary);">Loading logs...</div>';
+                lastLogTimestamp = null;
+                accumulatedLogs = [];
+            }
+
+            try {
+                // Build URL with optional since parameter for incremental updates
+                let url = `${API_BASE}/api/hosts/${window.currentContainer.host_id}/containers/${window.currentContainer.id}/logs?tail=${tailCount}`;
+                if (incremental && lastLogTimestamp) {
+                    url += `&since=${encodeURIComponent(lastLogTimestamp)}`;
+                }
+
+                // Increase timeout for large log fetches
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), 30000); // 30 second timeout
+
+                const response = await fetch(url, { signal: controller.signal });
+
+                clearTimeout(timeoutId);
+
+                if (response.ok) {
+                    const data = await response.json();
+
+                    // Update timestamp for next incremental fetch
+                    if (data.last_timestamp) {
+                        lastLogTimestamp = data.last_timestamp;
+                    }
+
+                    if (data.logs && Array.isArray(data.logs)) {
+                        // Always replace logs for simplicity and to avoid duplicates
+                        // Auto-refresh will just keep fetching the latest N logs
+                        // API returns array of {timestamp, log} objects
+                        accumulatedLogs = data.logs
+                            .filter(entry => entry && entry.log && entry.log.trim())
+                            .map(entry => entry.log);
+
+                        if (accumulatedLogs.length === 0) {
+                            logsDiv.innerHTML = '<div style="color: var(--text-tertiary); padding: 20px; text-align: center;">No logs available</div>';
+                        } else {
+                            updateLogDisplay();
+                            // Auto-scroll to bottom only if no filter is active
+                            const filterText = document.getElementById('logSearchFilter')?.value || '';
+                            if (!filterText) {
+                                logsDiv.scrollTop = logsDiv.scrollHeight;
+                            }
+                        }
+                    } else {
+                        logsDiv.innerHTML = '<div style="color: var(--text-tertiary);">No logs available</div>';
+                    }
+                } else {
+                    logsDiv.innerHTML = '<div style="color: var(--danger);">Failed to fetch logs</div>';
+                    stopAutoRefresh();
+                }
+            } catch (error) {
+                logger.error('Error fetching logs:', error);
+                if (error.name === 'AbortError') {
+                    logsDiv.innerHTML = '<div style="color: var(--danger);">Log fetch timeout - try reducing the log count</div>';
+                } else {
+                    logsDiv.innerHTML = '<div style="color: var(--danger);">Error loading logs</div>';
+                }
+                stopAutoRefresh();
+            }
+        }
+
+        // Portainer-style HTTP polling for logs (more reliable than WebSocket)
+        let logPollInterval = null;
+        let lastLogTimestamp = null;
+        let accumulatedLogs = [];
+
+        function toggleAutoRefresh() {
+            const checkbox = document.getElementById('autoRefreshLogs');
+            if (checkbox.checked) {
+                startAutoRefresh();
+            } else {
+                stopAutoRefresh();
+            }
+        }
+
+        function startAutoRefresh() {
+            if (logPollInterval || !window.currentContainer) return;
+
+            // Poll every 2 seconds
+            logPollInterval = setInterval(() => {
+                // Don't use incremental updates - just refresh with the same tail count
+                // This avoids duplicate/accumulation issues
+                fetchContainerLogs(false);
+            }, 2000);
+        }
+
+        function stopAutoRefresh() {
+            if (logPollInterval) {
+                clearInterval(logPollInterval);
+                logPollInterval = null;
+            }
+        }
+
+        function updateLogDisplay() {
+            const logsDiv = document.getElementById('container-logs');
+            if (!logsDiv || !accumulatedLogs.length) {
+                const matchCount = document.getElementById('logMatchCount');
+                if (matchCount) matchCount.textContent = '';
+                return;
+            }
+
+            const showTimestamps = document.getElementById('showTimestamps').checked;
+            const filterText = document.getElementById('logSearchFilter')?.value.toLowerCase() || '';
+            let displayLogs = accumulatedLogs;
+
+            // Remove timestamps if needed
+            if (!showTimestamps) {
+                displayLogs = displayLogs.map(line => {
+                    // Match various timestamp formats at the beginning of the line
+                    return line.replace(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?\s*/, '');
+                });
+            }
+
+            // Apply filter
+            let filteredLogs = displayLogs;
+            let matchCount = 0;
+            if (filterText) {
+                filteredLogs = displayLogs.filter(line => {
+                    const matches = line.toLowerCase().includes(filterText);
+                    if (matches) matchCount++;
+                    return matches;
+                });
+            } else {
+                matchCount = displayLogs.length;
+            }
+
+            // Update match count - only show when filtering
+            const matchCountElem = document.getElementById('logMatchCount');
+            if (matchCountElem) {
+                if (filterText) {
+                    matchCountElem.textContent = `${matchCount} matches`;
+                } else {
+                    matchCountElem.textContent = ''; // Don't show count when not filtering
+                }
+            }
+
+            // Display logs with optional highlighting
+            if (filterText && filteredLogs.length > 0) {
+                // Escape special regex characters in search text
+                const escapedFilter = filterText.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                const regex = new RegExp(`(${escapedFilter})`, 'gi');
+
+                const highlightedLogs = filteredLogs.map(line => {
+                    // HTML escape the line first
+                    const escaped = line.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+                    // Then add highlighting using callback to prevent HTML re-injection
+                    return escaped.replace(regex, (match) => {
+                        return `<mark style="background: #ffeb3b; color: #000; padding: 2px;">${match}</mark>`;
+                    });
+                });
+                logsDiv.innerHTML = highlightedLogs.join('\n') || '<div style="color: var(--text-tertiary);">No matching logs found</div>';
+            } else if (filterText && filteredLogs.length === 0) {
+                logsDiv.innerHTML = '<div style="color: var(--text-tertiary);">No logs match the filter</div>';
+            } else {
+                // HTML escape for safety
+                const escapedLogs = filteredLogs.map(line =>
+                    line.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+                );
+                logsDiv.innerHTML = escapedLogs.join('\n') || '<div style="color: var(--text-tertiary);">No logs available</div>';
+            }
+
+            // Keep scroll at bottom if we were already at bottom
+            if (logsDiv.scrollHeight - logsDiv.scrollTop <= logsDiv.clientHeight + 50) {
+                logsDiv.scrollTop = logsDiv.scrollHeight;
+            }
+        }
+
+        function clearLogFilter() {
+            const filterInput = document.getElementById('logSearchFilter');
+            if (filterInput) {
+                filterInput.value = '';
+                updateLogDisplay();
+                filterInput.focus();
+            }
+        }
+
+        function adjustLogsHeight() {
+            const modal = document.querySelector('#containerModal .modal-content');
+            const logsDiv = document.getElementById('container-logs');
+            const logsTab = document.getElementById('logs-tab');
+
+            if (modal && logsDiv && logsTab && logsTab.style.display !== 'none') {
+                // Calculate available height for logs
+                const modalHeight = modal.offsetHeight;
+                const headerHeight = modal.querySelector('.modal-header').offsetHeight || 60;
+                const tabsHeight = 120; // Approximate height of tabs and controls
+                const padding = 120; // Extra padding
+
+                const availableHeight = modalHeight - headerHeight - tabsHeight - padding;
+                if (availableHeight > 200) {
+                    logsDiv.style.height = `${Math.min(availableHeight, 600)}px`;
+                }
+            }
+        }
+
+        async function restartContainer(hostId, containerId) {
+            try {
+                const response = await fetch(`${API_BASE}/api/hosts/${hostId}/containers/${containerId}/restart`, {
+                    method: 'POST'
+                });
+                
+                if (response.ok) {
+                    showToast('🔄 Container restarting...');
+                } else {
+                    showToast('❌ Failed to restart container');
+                }
+            } catch (error) {
+                logger.error('Error restarting container:', error);
+                showToast('❌ Failed to restart container');
+            }
+        }
+
+        async function startContainer(hostId, containerId) {
+            // Find container to update UI immediately
+            const container = containers.find(c => c.id === containerId);
+            if (container) {
+                // Update button immediately to show transitional state
+                const btn = document.getElementById(`container-state-btn-${container.short_id}`);
+                if (btn) {
+                    btn.innerHTML = '<i data-lucide="rotate-cw"></i> Starting...';
+                    btn.className = 'btn';
+                    btn.style.backgroundColor = '#90ee90';
+                    btn.style.color = '#333';
+                    btn.disabled = true;
+                    initIcons();
+                }
+            }
+
+            try {
+                const response = await fetch(`${API_BASE}/api/hosts/${hostId}/containers/${containerId}/start`, {
+                    method: 'POST'
+                });
+
+                if (response.ok) {
+                    showToast('▶️ Container starting...');
+                } else {
+                    showToast('❌ Failed to start container');
+                    // Revert button state on failure
+                    if (container) {
+                        const btn = document.getElementById(`container-state-btn-${container.short_id}`);
+                        if (btn) {
+                            btn.innerHTML = '<i data-lucide="play"></i> Start Container';
+                            btn.className = 'btn btn-primary';
+                            btn.style.backgroundColor = '';
+                            btn.style.color = '';
+                            btn.disabled = false;
+                        }
+                    }
+                }
+            } catch (error) {
+                logger.error('Error starting container:', error);
+                showToast('❌ Failed to start container');
+                // Revert button state on error
+                if (container) {
+                    const btn = document.getElementById(`container-state-btn-${container.short_id}`);
+                    if (btn) {
+                        btn.innerHTML = '<i data-lucide="play"></i> Start Container';
+                        btn.className = 'btn btn-primary';
+                        btn.style.backgroundColor = '';
+                        btn.style.color = '';
+                        btn.disabled = false;
+                        initIcons();
+                    }
+                }
+            }
+        }
+
+        async function loadContainerRecentEvents(containerName, hostId) {
+            try {
+                // Fetch last 13 events for this container
+                const response = await fetch(`${API_BASE}/api/events?limit=13&container_name=${encodeURIComponent(containerName)}&host_id=${hostId}&hours=168`);
+                const data = await response.json();
+
+                const eventsDiv = document.getElementById('container-recent-events');
+                if (!eventsDiv) return;
+
+                if (!data.events || data.events.length === 0) {
+                    eventsDiv.innerHTML = `
+                        <div style="border-top: 1px solid var(--border); padding-top: 15px; margin-top: 15px;">
+                            <strong style="color: var(--text-primary); font-size: 14px;">Recent Events</strong>
+                            <div style="color: var(--text-tertiary); font-size: 13px; margin-top: 8px;">No recent events</div>
+                        </div>
+                    `;
+                    return;
+                }
+
+                // Build events list
+                let eventsHtml = `
+                    <div style="border-top: 1px solid var(--border); padding-top: 15px; margin-top: 15px;">
+                        <strong style="color: var(--text-primary); font-size: 14px; margin-bottom: 10px; display: block;">Recent Events</strong>
+                        <div style="display: flex; flex-direction: column; gap: 4px;">
+                `;
+
+                data.events.forEach(event => {
+                    // Ensure timestamp is treated as UTC if no timezone info
+                    let timestampStr = event.timestamp;
+                    if (!timestampStr.includes('+') && !timestampStr.endsWith('Z')) {
+                        timestampStr += 'Z';  // Treat as UTC
+                    }
+                    const timestamp = new Date(timestampStr).toLocaleString('en-US', {
+                        month: '2-digit',
+                        day: '2-digit',
+                        year: 'numeric',
+                        hour: '2-digit',
+                        minute: '2-digit',
+                        second: '2-digit',
+                        hour12: true
+                    });
+
+                    // Get severity color
+                    let severityColor = 'var(--primary)';
+                    if (event.severity === 'critical') severityColor = '#DC2626';
+                    else if (event.severity === 'error') severityColor = 'var(--danger)';
+                    else if (event.severity === 'warning') severityColor = 'var(--warning)';
+
+                    // Build event message
+                    let eventText = event.title || event.message;
+                    if (event.message && event.message !== event.title) {
+                        const stateChangeMatch = event.message.match(/state changed from (\w+) to (\w+)/i);
+                        if (stateChangeMatch) {
+                            const fromState = stateChangeMatch[1];
+                            const toState = stateChangeMatch[2];
+                            const userAction = event.message.includes('(user action)') ? ' <span style="color: var(--text-secondary);">(user action)</span>' : '';
+
+                            // Get state colors
+                            const getStateColor = (state) => {
+                                switch(state.toLowerCase()) {
+                                    case 'running': return '#10B981';
+                                    case 'exited': return '#EF4444';
+                                    case 'stopped': return '#F59E0B';
+                                    case 'paused': return '#F59E0B';
+                                    case 'restarting': return '#3B82F6';
+                                    case 'dead': return '#DC2626';
+                                    default: return 'var(--text-tertiary)';
+                                }
+                            };
+
+                            eventText = `State changed from <span style="color: ${getStateColor(fromState)}; font-weight: 500;">${fromState}</span> to <span style="color: ${getStateColor(toState)}; font-weight: 500;">${toState}</span>${userAction}`;
+                        }
+                    }
+
+                    eventsHtml += `
+                        <div style="display: flex; align-items: flex-start; gap: 10px; font-size: 13px;">
+                            <span style="color: var(--text-tertiary); flex-shrink: 0; font-size: 12px;">${timestamp}</span>
+                            <span style="color: ${severityColor}; flex-shrink: 0; min-width: 80px; font-size: 12px;">level=${event.severity}</span>
+                            <span style="color: var(--text-primary); flex: 1;">${eventText}</span>
+                        </div>
+                    `;
+                });
+
+                eventsHtml += `
+                        </div>
+                    </div>
+                `;
+
+                eventsDiv.innerHTML = eventsHtml;
+            } catch (error) {
+                logger.error('Error loading container events:', error);
+                const eventsDiv = document.getElementById('container-recent-events');
+                if (eventsDiv) {
+                    eventsDiv.innerHTML = `
+                        <div style="border-top: 1px solid var(--border); padding-top: 15px; margin-top: 15px;">
+                            <strong style="color: var(--text-primary); font-size: 14px;">Recent Events</strong>
+                            <div style="color: var(--danger); font-size: 13px; margin-top: 8px;">Failed to load events</div>
+                        </div>
+                    `;
+                }
+            }
+        }
+
+        async function stopContainer(hostId, containerId) {
+            // Find container to update UI immediately
+            const container = containers.find(c => c.id === containerId);
+            if (container) {
+                // Update button immediately to show transitional state
+                const btn = document.getElementById(`container-state-btn-${container.short_id}`);
+                if (btn) {
+                    btn.innerHTML = '<i data-lucide="rotate-cw"></i> Stopping...';
+                    btn.className = 'btn';
+                    btn.style.backgroundColor = '#ffa500';
+                    btn.style.color = '#fff';
+                    btn.disabled = true;
+                    initIcons();
+                }
+            }
+
+            try {
+                const response = await fetch(`${API_BASE}/api/hosts/${hostId}/containers/${containerId}/stop`, {
+                    method: 'POST'
+                });
+
+                if (response.ok) {
+                    showToast('⏹️ Container stopping...');
+                } else {
+                    showToast('❌ Failed to stop container');
+                    // Revert button state on failure
+                    if (container) {
+                        const btn = document.getElementById(`container-state-btn-${container.short_id}`);
+                        if (btn) {
+                            btn.innerHTML = '<i data-lucide="square"></i> Stop Container';
+                            btn.className = 'btn btn-danger';
+                            btn.style.backgroundColor = '';
+                            btn.style.color = '';
+                            btn.disabled = false;
+                        }
+                    }
+                }
+            } catch (error) {
+                logger.error('Error stopping container:', error);
+                showToast('❌ Failed to stop container');
+                // Revert button state on error
+                if (container) {
+                    const btn = document.getElementById(`container-state-btn-${container.short_id}`);
+                    if (btn) {
+                        btn.innerHTML = '<i data-lucide="square"></i> Stop Container';
+                        btn.className = 'btn btn-danger';
+                        btn.style.backgroundColor = '';
+                        btn.style.color = '';
+                        btn.disabled = false;
+                        initIcons();
+                    }
+                }
+            }
+        }
+
+        function showToast(message) {
+            const toast = document.getElementById('toast');
+            toast.textContent = message;
+            toast.classList.add('show');
+            setTimeout(() => {
+                toast.classList.remove('show');
+            }, 3000);
+        }
+
+
+
+        // Initialize on load
+        window.addEventListener('DOMContentLoaded', async () => {
+            try {
+                // Initialize Lucide icons in static HTML
+                initIcons();
+
+                await init();
+                // Check if password change is required
+                checkPasswordChangeRequired();
+                // Get current user info
+                await getCurrentUser();
+                // Dashboard will be initialized when WebSocket data arrives
+                // or when user navigates to dashboard page
+            } catch (error) {
+                logger.error('Failed to initialize application:', error);
+                // Don't show error toast - WebSocket will handle data delivery
+            }
+        });
+
+        // Mobile Bottom Navigation
+        document.addEventListener('DOMContentLoaded', function() {
+            const mobileNavItems = document.querySelectorAll('.mobile-nav-item');
+            const moreMenu = document.querySelector('.more-menu');
+            const moreNavItem = document.querySelector('.mobile-nav-item[data-page="more"]');
+
+            // Handle navigation clicks
+            mobileNavItems.forEach(item => {
+                item.addEventListener('click', function(e) {
+                    const page = this.dataset.page;
+
+                    if (page === 'more') {
+                        // Toggle more menu
+                        e.stopPropagation();
+                        moreMenu.classList.toggle('show');
+                        return;
+                    }
+
+                    // Handle regular navigation
+                    if (page) {
+                        switchPage(page);
+                    }
+
+                    // Update active state
+                    mobileNavItems.forEach(nav => nav.classList.remove('active'));
+                    this.classList.add('active');
+
+                    // Hide more menu if open
+                    moreMenu.classList.remove('show');
+                });
+            });
+
+            // Handle more menu clicks
+            document.querySelectorAll('.more-menu-item').forEach(item => {
+                item.addEventListener('click', function(e) {
+                    const page = this.dataset.page;
+                    if (page) {
+                        setActivePage(page);
+                        moreMenu.classList.remove('show');
+
+                        // Update active state for the more button
+                        mobileNavItems.forEach(nav => nav.classList.remove('active'));
+                        moreNavItem.classList.add('active');
+                    }
+                });
+            });
+
+            // Close more menu when clicking outside
+            document.addEventListener('click', function(e) {
+                if (!moreNavItem.contains(e.target)) {
+                    moreMenu.classList.remove('show');
+                }
+            });
+
+            // Map mobile nav pages to existing navigation
+            function setActivePage(page) {
+                // Use the existing navigation system
+                const navItem = document.querySelector(`.nav-item[data-page="${page}"]`);
+                if (navItem) {
+                    navItem.click();
+                } else {
+                    // Fallback for pages that might not have nav items
+                    switch(page) {
+                        case 'dashboard':
+                            showSection('dashboard');
+                            break;
+                        case 'hosts':
+                            showSection('hosts');
+                            break;
+                        case 'alerts':
+                            showSection('alerts');
+                            break;
+                        case 'settings':
+                            showSection('settings');
+                            break;
+                        case 'notifications':
+                            showSection('notifications');
+                            break;
+                        case 'account':
+                            showSection('account');
+                            break;
+                    }
+                }
+            }
+        });
diff --git a/dockmon/src/js/core.js b/dockmon/src/js/core.js
new file mode 100644
index 0000000..12cfe9f
--- /dev/null
+++ b/dockmon/src/js/core.js
@@ -0,0 +1,640 @@
+        logger.debug('DockMon JavaScript loaded');
+
+        // Security: HTML escaping function to prevent XSS
+        function escapeHtml(unsafe) {
+            if (unsafe === null || unsafe === undefined) return '';
+            return String(unsafe)
+                .replace(/&/g, "&amp;")
+                .replace(/</g, "&lt;")
+                .replace(/>/g, "&gt;")
+                .replace(/"/g, "&quot;")
+                .replace(/'/g, "&#039;");
+        }
+
+        // Make escapeHtml globally available
+        window.escapeHtml = escapeHtml;
+
+        // Global state
+        let currentPage = 'dashboard';
+        let globalSettings = {
+            maxRetries: 3,
+            retryDelay: 30,
+            defaultAutoRestart: false,
+            pollingInterval: 2,
+            connectionTimeout: 10,
+            blackout_windows: []
+        };
+
+        let hosts = [];
+        let containers = [];
+        let alertRules = [];
+
+        // Make hosts and containers globally accessible for other modules (like logs.js)
+        window.hosts = hosts;
+        window.containers = containers;
+        let ws = null;
+
+        // Auto-restart notification batching
+        let restartNotificationBatch = [];
+        let restartNotificationTimer = null;
+        let editingAlertRule = null; // Track which rule is being edited
+        let reconnectAttempts = 0;
+        let isConnecting = false; // Prevent multiple simultaneous connections
+        const MAX_RECONNECT_ATTEMPTS = 10;
+
+        // API Base URL - backend always runs on port 8080
+        const API_BASE = '';  // Use same origin - nginx will proxy /api/* to backend
+        const WS_URL = `${window.location.protocol === 'https:' ? 'wss:' : 'ws:'}//${window.location.host}/ws`;
+
+        // Note: escapeHtml is defined at the top of this file and made globally available
+
+        // Lucide icon helper function
+        function icon(name, size = 16, className = '') {
+            return `<i data-lucide="${name}" class="lucide-icon ${className}" style="width:${size}px;height:${size}px;"></i>`;
+        }
+
+        // Initialize Lucide icons after DOM updates
+        function initIcons() {
+            if (typeof lucide !== 'undefined') {
+                lucide.createIcons();
+            }
+        }
+
+        // Get authentication headers for API requests
+        function getAuthHeaders() {
+            const headers = {
+                'Content-Type': 'application/json'
+            };
+            // Using session cookies for authentication
+            return headers;
+        }
+
+
+        // Initialize WebSocket connection
+        function connectWebSocket() {
+            // Prevent multiple simultaneous connection attempts
+            if (isConnecting) {
+                logger.debug('Connection attempt already in progress, skipping...');
+                return;
+            }
+
+            // Set flag immediately to prevent race condition
+            isConnecting = true;
+
+            // Close existing connection if any
+            if (ws && ws.readyState !== WebSocket.CLOSED) {
+                ws.close();
+            }
+
+            logger.debug('Connecting to WebSocket:', WS_URL);
+
+            ws = new WebSocket(WS_URL);
+
+            ws.onopen = function() {
+                logger.debug('WebSocket connected');
+                showToast('✅ Connected to backend');
+                reconnectAttempts = 0;
+                isConnecting = false;
+            };
+
+            ws.onmessage = function(event) {
+                try {
+                    const message = JSON.parse(event.data);
+                    handleWebSocketMessage(message);
+                } catch (error) {
+                    logger.error('Error handling WebSocket message:', error);
+                }
+            };
+            
+            ws.onerror = function(error) {
+                logger.error('WebSocket error:', error);
+                showToast('⚠️ Connection error');
+                isConnecting = false; // Reset flag on error
+            };
+
+            ws.onclose = function() {
+                logger.debug('WebSocket disconnected');
+                showToast('🔌 Disconnected - attempting to reconnect...');
+                isConnecting = false; // Reset flag on close
+                attemptReconnect();
+            };
+        }
+
+        // Handle batched restart notifications
+        function handleRestartNotificationBatch() {
+            if (restartNotificationBatch.length === 0) return;
+
+            if (restartNotificationBatch.length === 1) {
+                showToast(`✅ Successfully restarted ${restartNotificationBatch[0]}`);
+            } else {
+                const containerNames = restartNotificationBatch.slice(0, 3).join(', ');
+                const remaining = Math.max(0, restartNotificationBatch.length - 3);
+                const message = remaining > 0
+                    ? `✅ Successfully restarted ${containerNames} and ${remaining} more`
+                    : `✅ Successfully restarted ${containerNames}`;
+                showToast(message);
+            }
+
+            // Clear the batch
+            restartNotificationBatch = [];
+            restartNotificationTimer = null;
+        }
+
+        // Handle incoming WebSocket messages
+        function handleWebSocketMessage(message) {
+            switch(message.type) {
+                case 'initial_state':
+                    hosts = message.data.hosts || [];
+                    window.hosts = hosts; // Keep window.hosts in sync
+                    containers = message.data.containers || [];
+                    window.containers = containers; // Keep window.containers in sync
+                    globalSettings = message.data.settings || globalSettings;
+                    alertRules = message.data.alerts || [];
+
+                    renderAll();
+
+                    // Initialize dashboard if we're on that page and grid doesn't exist yet
+                    if (currentPage === 'dashboard' && grid === null) {
+                        // Small delay to ensure renderAll() completes
+                        setTimeout(() => {
+                            if (grid === null) {  // Double check grid wasn't already initialized
+                                initDashboard();
+                            }
+                        }, 100);
+                    }
+                    break;
+
+                case 'containers_update':
+                    containers = message.data.containers || [];
+                    window.containers = containers; // Keep window.containers in sync
+                    hosts = message.data.hosts || [];
+                    window.hosts = hosts; // Keep window.hosts in sync
+                    renderAll();
+
+                    // Update host metrics charts
+                    if (message.data.host_metrics && typeof updateHostMetrics === 'function') {
+                        for (const [hostId, metrics] of Object.entries(message.data.host_metrics)) {
+                            updateHostMetrics(hostId, metrics);
+                        }
+                    }
+
+                    // Update container metrics sparklines
+                    if (typeof updateContainerSparklines === 'function') {
+                        for (const container of containers) {
+                            updateContainerSparklines(container.host_id, container.short_id, container);
+                        }
+                    }
+
+                    // Refresh container modal if open
+                    refreshContainerModalIfOpen();
+
+                    // Refresh logs dropdown if on logs page
+                    if (currentPage === 'logs' && typeof populateContainerList === 'function') {
+                        populateContainerList();
+                    }
+                    break;
+                    
+                case 'host_added':
+                    fetchHosts();
+                    fetchContainers(); // Fetch containers to show new host's containers
+                    showToast('✅ Host added successfully');
+                    break;
+
+                case 'host_removed':
+                    fetchHosts();
+                    fetchContainers(); // Refresh to remove containers from deleted host
+                    showToast('🗑️ Host removed successfully');
+                    break;
+
+                case 'auto_restart_success':
+                    // Add to batch instead of showing immediate toast
+                    restartNotificationBatch.push(message.data.container_name);
+
+                    // Clear any existing timer and set a new one
+                    if (restartNotificationTimer) {
+                        clearTimeout(restartNotificationTimer);
+                    }
+
+                    // Show batched notification after 2 seconds of no new restarts
+                    restartNotificationTimer = setTimeout(handleRestartNotificationBatch, 2000);
+                    break;
+                    
+                case 'auto_restart_failed':
+                    showToast(`❌ Failed to restart ${message.data.container_name} after ${message.data.attempts} attempts`);
+                    break;
+                    
+                case 'container_restarted':
+                    showToast(`🔄 Container restarted`);
+                    break;
+
+                case 'docker_event':
+                    // Handle Docker events (container start/stop/restart, etc.)
+                    // These are real-time events from Docker daemon - no action needed
+                    break;
+
+                case 'blackout_status_changed':
+                    // Update blackout status display if modal is open
+                    updateBlackoutStatus();
+                    break;
+
+                default:
+                    logger.debug('Unknown message type:', message.type);
+            }
+
+            // Call any registered custom message handlers
+            if (window.wsMessageHandlers && Array.isArray(window.wsMessageHandlers)) {
+                window.wsMessageHandlers.forEach(handler => {
+                    try {
+                        handler(message);
+                    } catch (error) {
+                        logger.error('Error in custom WebSocket handler:', error);
+                    }
+                });
+            }
+        }
+
+        // Core handler stays internal - extensions should use window.wsMessageHandlers array
+
+        // Attempt to reconnect to WebSocket
+        function attemptReconnect() {
+            if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+                showToast('❌ Could not reconnect to backend');
+
+                // Add persistent warning banner
+                let banner = document.getElementById('connection-lost-banner');
+                if (!banner) {
+                    banner = document.createElement('div');
+                    banner.id = 'connection-lost-banner';
+                    banner.style.cssText = 'position: fixed; top: 0; left: 0; right: 0; background: #dc2626; color: white; padding: 12px; text-align: center; z-index: 10000; font-weight: 600; box-shadow: 0 2px 8px rgba(0,0,0,0.3);';
+                    banner.innerHTML = '⚠️ Connection to backend lost. Data may be outdated. <button onclick="location.reload()" style="margin-left: 16px; padding: 6px 16px; background: white; color: #dc2626; border: none; border-radius: 4px; cursor: pointer; font-weight: 600;">Reload Page</button>';
+                    document.body.prepend(banner);
+                }
+                return;
+            }
+
+            // Use exponential backoff: 2s, 4s, 8s, 16s, then 30s
+            const delay = Math.min(2000 * Math.pow(2, reconnectAttempts), 30000);
+
+            logger.debug(`Will attempt reconnect in ${delay}ms (attempt ${reconnectAttempts + 1}/${MAX_RECONNECT_ATTEMPTS})`);
+
+            setTimeout(() => {
+                reconnectAttempts++;
+                logger.debug(`Reconnect attempt ${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS}`);
+                connectWebSocket();
+            }, delay);
+        }
+
+        // API Functions
+        async function fetchHosts() {
+            try {
+                const response = await fetch(`${API_BASE}/api/hosts`, {
+                    headers: getAuthHeaders(),
+                    credentials: 'include'
+                });
+                if (response.ok) {
+                    hosts = await response.json();
+                    window.hosts = hosts; // Keep window.hosts in sync
+                    logger.debug('Fetched hosts:', hosts.length);
+                } else {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+            } catch (error) {
+                logger.error('Error fetching hosts:', error);
+                // Don't show toast during initial load, WebSocket will handle it
+                if (hosts.length === 0) {
+                    logger.debug('Will wait for WebSocket data...');
+                } else {
+                    showToast('❌ Failed to fetch hosts');
+                }
+            }
+        }
+
+        async function fetchContainers() {
+            try {
+                const response = await fetch(`${API_BASE}/api/containers`, {
+                    headers: getAuthHeaders(),
+                    credentials: 'include'
+                });
+                if (response.ok) {
+                    containers = await response.json();
+                    window.containers = containers; // Keep window.containers in sync
+                    logger.debug('Fetched containers:', containers.length);
+                } else {
+                    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+                }
+            } catch (error) {
+                logger.error('Error fetching containers:', error);
+                // Don't show toast during initial load, WebSocket will handle it
+                if (containers.length === 0) {
+                    logger.debug('Will wait for WebSocket data...');
+                } else {
+                    showToast('❌ Failed to fetch containers');
+                }
+            }
+        }
+
+        async function fetchSettings() {
+            try {
+                const response = await fetch(`${API_BASE}/api/settings`, {
+                    credentials: 'include'
+                });
+                globalSettings = await response.json();
+
+                // Always update timezone offset from browser
+                globalSettings.timezone_offset = -new Date().getTimezoneOffset();
+            } catch (error) {
+                logger.error('Error fetching settings:', error);
+            }
+        }
+
+        async function fetchAlertRules() {
+            try {
+                const response = await fetch(`${API_BASE}/api/alerts`, {
+                    credentials: 'include'
+                });
+                if (response.ok) {
+                    alertRules = await response.json() || [];
+                    renderAlertRules();
+                    updateNavBadges();
+                } else {
+                    logger.warn('Failed to fetch alert rules:', response.status);
+                    alertRules = [];
+                }
+            } catch (error) {
+                logger.error('Error fetching alert rules:', error);
+                alertRules = [];
+            }
+        }
+
+        // Check authentication status
+        async function checkAuthentication() {
+            logger.debug('Checking authentication status...');
+            try {
+                const response = await fetch(`${API_BASE}/api/auth/status`, {
+                    credentials: 'include'
+                });
+
+                logger.debug('Auth response status:', response.status);
+
+                if (response.ok) {
+                    const data = await response.json();
+                    logger.debug('Auth data:', data);
+
+                    if (!data.authenticated) {
+                        logger.debug('Not authenticated, redirecting to login');
+                        // Redirect to login page
+                        window.location.href = '/login.html';
+                        return false;
+                    }
+
+                    // Store user info
+                    if (data.username) {
+                        currentUserInfo.username = data.username;
+                    }
+
+                    // Check if password change is required (from backend)
+                    if (data.must_change_password || data.is_first_login) {
+                        sessionStorage.setItem('must_change_password', 'true');
+                    }
+
+                    logger.debug('Authentication successful');
+                    return true;
+                } else {
+                    logger.debug('Auth check returned non-OK status:', response.status);
+                }
+            } catch (error) {
+                logger.error('Auth check error:', error);
+            }
+
+            logger.debug('Auth check failed, redirecting to login');
+            // If auth check fails, redirect to login
+            window.location.href = '/login.html';
+            return false;
+        }
+
+        // Logout function
+        async function logout() {
+            try {
+                const response = await fetch(`${API_BASE}/api/auth/logout`, {
+                    method: 'POST',
+                    credentials: 'include'
+                });
+
+                if (response.ok) {
+                    window.location.href = '/login.html';
+                } else {
+                    logger.error('Logout failed');
+                }
+            } catch (error) {
+                logger.error('Logout error:', error);
+                // Force redirect even if logout request fails
+                window.location.href = '/login.html';
+            }
+        }
+
+        // Save modal preferences to localStorage
+        async function saveModalPreferences() {
+            const modal = document.querySelector('#containerModal .modal-content');
+            if (modal) {
+                // Check if mobile view
+                const isMobile = window.innerWidth < 768;
+                if (isMobile) {
+                    return; // Don't save preferences on mobile
+                }
+
+                const preferences = {
+                    width: modal.style.width,
+                    height: modal.style.height,
+                    transform: modal.style.transform,
+                    logsHeight: document.getElementById('container-logs')?.style.height
+                };
+
+                try {
+                    const response = await fetch(`${API_BASE}/api/user/modal-preferences`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({ preferences: JSON.stringify(preferences) })
+                    });
+                    if (!response.ok) {
+                        console.error('Failed to save modal preferences');
+                    }
+                } catch (e) {
+                    console.error('Failed to save modal preferences:', e);
+                }
+            }
+        }
+
+        // Load modal preferences from database
+        async function loadModalPreferences() {
+            try {
+                const response = await fetch(`${API_BASE}/api/user/modal-preferences`);
+                if (response.ok) {
+                    const data = await response.json();
+                    if (data.preferences) {
+                        const prefs = JSON.parse(data.preferences);
+
+                        // Check if mobile view - don't apply saved preferences on mobile
+                        const isMobile = window.innerWidth < 768;
+                        if (isMobile) {
+                            return null;
+                        }
+
+                        const modal = document.querySelector('#containerModal .modal-content');
+                        if (modal) {
+                            if (prefs.width) modal.style.width = prefs.width;
+                            if (prefs.height) modal.style.height = prefs.height;
+                            // Reset transform on load (center the modal)
+                            modal.style.transform = 'translate(0, 0)';
+                        }
+                        // Restore logs height will be done when logs tab is shown
+                        return prefs;
+                    }
+                }
+            } catch (e) {
+                console.error('Failed to load modal preferences:', e);
+            }
+            return null;
+        }
+
+        // Make modal draggable
+        function makeModalDraggable(modalId) {
+            const modal = document.getElementById(modalId);
+            const modalContent = modal.querySelector('.modal-content');
+            const header = modalContent.querySelector('.modal-header');
+
+            let isDragging = false;
+            let currentX;
+            let currentY;
+            let initialX;
+            let initialY;
+            let xOffset = 0;
+            let yOffset = 0;
+
+            function dragStart(e) {
+                if (e.target.classList.contains('modal-close')) return;
+
+                initialX = e.clientX - xOffset;
+                initialY = e.clientY - yOffset;
+
+                if (e.target === header || header.contains(e.target)) {
+                    isDragging = true;
+                }
+            }
+
+            function drag(e) {
+                if (isDragging) {
+                    e.preventDefault();
+                    currentX = e.clientX - initialX;
+                    currentY = e.clientY - initialY;
+
+                    xOffset = currentX;
+                    yOffset = currentY;
+
+                    modalContent.style.transform = `translate(${currentX}px, ${currentY}px)`;
+                }
+            }
+
+            function dragEnd(e) {
+                initialX = currentX;
+                initialY = currentY;
+                isDragging = false;
+                // Save position after dragging
+                saveModalPreferences();
+            }
+
+            // Add event listeners
+            header.addEventListener('mousedown', dragStart);
+            document.addEventListener('mousemove', drag);
+            document.addEventListener('mouseup', dragEnd);
+
+            // Store cleanup function for later removal
+            window.cleanupModalDragListeners = function() {
+                header.removeEventListener('mousedown', dragStart);
+                document.removeEventListener('mousemove', drag);
+                document.removeEventListener('mouseup', dragEnd);
+            };
+        }
+
+        // ========================================
+        // Chart.js Helper Functions
+        // ========================================
+
+        /**
+         * Create a sparkline chart (small, minimal chart for trends)
+         * @param {HTMLCanvasElement} canvas - Canvas element to render chart
+         * @param {string} color - Line color
+         * @param {number} maxDataPoints - Maximum number of data points to show
+         * @returns {Chart} Chart.js instance
+         */
+        function createSparkline(canvas, color, maxDataPoints = 60) {
+            const ctx = canvas.getContext('2d');
+
+            return new Chart(ctx, {
+                type: 'line',
+                data: {
+                    labels: new Array(maxDataPoints).fill(''),
+                    datasets: [{
+                        data: new Array(maxDataPoints).fill(0),
+                        borderColor: color,
+                        backgroundColor: 'transparent',
+                        borderWidth: 1.5,
+                        pointRadius: 0,
+                        pointHoverRadius: 0,
+                        tension: 0.4,
+                        fill: false
+                    }]
+                },
+                options: {
+                    responsive: false,
+                    maintainAspectRatio: false,
+                    plugins: {
+                        legend: { display: false },
+                        tooltip: { enabled: false }
+                    },
+                    scales: {
+                        x: { display: false },
+                        y: {
+                            display: false,
+                            min: 0,
+                            max: 100
+                        }
+                    },
+                    animation: {
+                        duration: 0
+                    },
+                    interaction: {
+                        mode: 'index',
+                        intersect: false
+                    }
+                }
+            });
+        }
+
+        /**
+         * Update sparkline chart with new data point
+         * @param {Chart} chart - Chart.js instance
+         * @param {number} newValue - New data value
+         */
+        function updateSparkline(chart, newValue) {
+            const data = chart.data.datasets[0].data;
+            data.shift();
+            data.push(newValue);
+            chart.update('none'); // Update without animation
+        }
+
+        /**
+         * Format bytes to human-readable format
+         * @param {number} bytes - Number of bytes
+         * @returns {string} Formatted string (e.g., "1.2 MB/s")
+         */
+        function formatBytes(bytes) {
+            if (!bytes || bytes === 0) return '0 B';
+            if (typeof bytes !== 'number' || !isFinite(bytes) || bytes < 0) return '0 B';
+            const k = 1024;
+            const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+            const i = Math.max(0, Math.floor(Math.log(bytes) / Math.log(k)));
+            return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[Math.min(i, sizes.length - 1)];
+        }
+
+        // Initialize
+        
\ No newline at end of file
diff --git a/dockmon/src/js/dashboard.js b/dockmon/src/js/dashboard.js
new file mode 100644
index 0000000..fecff60
--- /dev/null
+++ b/dockmon/src/js/dashboard.js
@@ -0,0 +1,837 @@
+// GridStack Dashboard
+let grid = null;
+let dashboardLocked = false;
+
+async function initDashboard() {
+    logger.debug('initDashboard called');
+
+    // Initialize search and sort filters
+    initializeContainerFilters();
+
+    // Show search/sort controls on dashboard
+    const searchContainer = document.getElementById('dashboardSearchContainer');
+    const sortSelect = document.getElementById('containerSort');
+    if (searchContainer) searchContainer.style.display = '';
+    if (sortSelect) sortSelect.style.display = '';
+
+    // Check if dashboard grid container exists
+    const dashboardGridElement = document.getElementById('dashboard-grid');
+    if (!dashboardGridElement) {
+        logger.error('Dashboard grid element not found!');
+        return;
+    }
+
+    // Destroy existing GridStack instance if it exists
+    if (grid) {
+        grid.destroy(false); // false = don't remove DOM elements
+        grid = null;
+        logger.debug('Destroyed existing GridStack instance');
+    }
+
+    // Initialize GridStack with better flexibility
+    try {
+        grid = GridStack.init({
+            column: 48,      // 48 columns for maximum flexibility
+            cellHeight: 20,  // Smaller cells for finer vertical control
+            margin: 4,       // Keep margins at 4px
+            animate: true,
+            float: true,     // Allow floating for desktop editing
+            draggable: {
+                handle: '.widget-header'
+            },
+            resizable: {
+                handles: 'e, se, s, sw, w'
+            }
+        }, '#dashboard-grid');
+
+        logger.debug('GridStack initialized successfully');
+
+        // Load saved layout from API or use default
+        try {
+            const response = await fetch('/api/user/dashboard-layout', {
+                method: 'GET',
+                credentials: 'include'
+            });
+
+            if (response.ok) {
+                const data = await response.json();
+                if (data.layout) {
+                    try {
+                        const parsedLayout = JSON.parse(data.layout);
+                        logger.debug('Loading saved dashboard layout from API - widgets:', parsedLayout.map(w => w.id));
+                        loadDashboardLayout(parsedLayout);
+                    } catch (parseError) {
+                        logger.error('Failed to parse dashboard layout JSON:', parseError);
+                        showToast('⚠️ Dashboard layout corrupted - using default', 'error');
+                        createDefaultDashboard();
+                    }
+                } else {
+                    logger.debug('No saved layout in API - creating default dashboard layout');
+                    createDefaultDashboard();
+                }
+            } else {
+                logger.error('Failed to load dashboard layout from API:', response.status);
+                showToast('⚠️ Failed to load dashboard layout - using default', 'error');
+                createDefaultDashboard();
+            }
+        } catch (error) {
+            logger.error('Error loading dashboard layout:', error);
+            showToast('⚠️ Failed to load dashboard layout - using default', 'error');
+            createDefaultDashboard();
+        }
+
+        // Auto-save layout on any change
+        grid.on('change', (event, items) => {
+            saveDashboardLayout();
+        });
+
+        logger.debug('Dashboard initialization completed');
+
+        // Now that grid exists, populate the widgets with data
+        logger.debug('Rendering dashboard widgets after grid initialization...');
+        renderDashboardWidgets();
+    } catch (error) {
+        logger.error('Failed to initialize dashboard:', error);
+    }
+}
+
+function createDefaultDashboard() {
+    // Stats Widget - taller to ensure content fits
+    const statsWidget = createWidget('stats', 'Statistics', '<span data-lucide="bar-chart-3"></span>', {
+        x: 0, y: 0, w: 48, h: 9,
+        minW: 48, minH: 9, maxH: 9, maxW: 48,
+        noResize: true,
+        noMove: true
+    });
+
+    // Create individual widgets for each host
+    createHostWidgets();
+
+    // Use setTimeout to ensure widgets are fully created before rendering
+    setTimeout(() => renderDashboardWidgets(), 50);
+}
+
+function createHostWidgets() {
+    // Layout is loaded from API on startup, no need to check localStorage
+    const layoutMap = {};
+
+    // Get current host widget IDs
+    const currentHostWidgetIds = hosts.map(host => `host-${host.id}`);
+
+    // Remove host widgets that no longer exist OR duplicates
+    const existingHostWidgets = grid.getGridItems().filter(item => {
+        const widgetId = item.getAttribute('data-widget-id');
+        return widgetId && widgetId.startsWith('host-');
+    });
+    logger.debug(`Checking for widgets to remove. Current: ${existingHostWidgets.length}, Expected: ${currentHostWidgetIds.length}`);
+
+    // Track which widget IDs we've seen to detect duplicates
+    const seenWidgetIds = new Set();
+
+    existingHostWidgets.forEach(widget => {
+        const widgetId = widget.getAttribute('data-widget-id');
+
+        // Remove if widget ID is not in current host list
+        if (!currentHostWidgetIds.includes(widgetId)) {
+            logger.debug(`Removing widget ${widgetId} - not in current host list`);
+            // Extract host ID from widget ID (format: "host-{hostId}")
+            const hostId = widgetId.replace('host-', '');
+            // Clean up metrics before removing widget
+            if (typeof removeHostMetrics === 'function') {
+                removeHostMetrics(hostId);
+            }
+            grid.removeWidget(widget);
+        }
+        // Remove if this is a duplicate (we've seen this ID before)
+        else if (seenWidgetIds.has(widgetId)) {
+            logger.debug(`Removing duplicate widget ${widgetId}`);
+            // Extract host ID from widget ID (format: "host-{hostId}")
+            const hostId = widgetId.replace('host-', '');
+            // Clean up metrics before removing widget
+            if (typeof removeHostMetrics === 'function') {
+                removeHostMetrics(hostId);
+            }
+            grid.removeWidget(widget);
+        } else {
+            seenWidgetIds.add(widgetId);
+        }
+    });
+
+    // Create a widget for each host with dynamic sizing and smart positioning
+    let currentY = 10; // Start below stats widget (stats h=9, +1 for spacing)
+    let leftColumnY = 10;
+    let rightColumnY = 10;
+
+    // FIRST: Scan ALL existing widgets to find the actual bottom of each column
+    // This ensures new widgets are placed at the bottom regardless of host creation order
+    const allExistingWidgets = grid.getGridItems();
+    allExistingWidgets.forEach(widget => {
+        const widgetId = widget.getAttribute('data-widget-id');
+        // Only process host widgets, not stats widget
+        if (!widgetId || !widgetId.startsWith('host-')) {
+            return;
+        }
+
+        // Use GridStack node data instead of attributes
+        const gridData = widget.gridstackNode;
+        if (!gridData) {
+            return;
+        }
+
+        const existingX = gridData.x;
+        const existingY = gridData.y;
+        const existingH = gridData.h;
+
+        if (existingX === 0) {
+            // Left column
+            leftColumnY = Math.max(leftColumnY, existingY + existingH);
+        } else {
+            // Right column
+            rightColumnY = Math.max(rightColumnY, existingY + existingH);
+        }
+    });
+
+    hosts.forEach((host, index) => {
+        const widgetId = `host-${host.id}`;
+
+        // Check if widget already exists
+        const existingWidget = document.querySelector(`[data-widget-id="${widgetId}"]`);
+        if (existingWidget) {
+            return; // Skip silently - widget already exists
+        }
+        logger.debug(`Creating new widget ${widgetId}`);
+
+        const hostContainers = containers.filter(c => c.host_id === host.id);
+
+        // Calculate height based on container count (adjusted for cellHeight=20)
+        const containerRows = Math.max(1, hostContainers.length);
+        const headerHeight = 4; // Widget header (doubled for smaller cells)
+        const containerHeight = 3.6; // Each container row height (doubled)
+        const dynamicHeight = headerHeight + containerRows * containerHeight + 1.2; // Add padding
+        const widgetHeight = Math.max(12, Math.ceil(dynamicHeight)); // Minimum height of 12
+
+        // Check if there's a saved position for this widget
+        let x, y, w, h;
+        if (layoutMap[widgetId]) {
+            // Use saved position and size
+            x = layoutMap[widgetId].x;
+            y = layoutMap[widgetId].y;
+            w = layoutMap[widgetId].w;
+            h = layoutMap[widgetId].h;
+            logger.debug(`Restoring widget ${widgetId} from saved layout: x=${x}, y=${y}, w=${w}, h=${h}`);
+        } else {
+            // Smart column placement - use the shorter column
+            if (leftColumnY <= rightColumnY) {
+                // Place in left column
+                x = 0;
+                y = leftColumnY;
+                leftColumnY = y + widgetHeight; // Update tracker
+            } else {
+                // Place in right column
+                x = 24;
+                y = rightColumnY;
+                rightColumnY = y + widgetHeight; // Update tracker
+            }
+            w = 24;
+            h = widgetHeight;
+        }
+
+        const widget = createWidget(widgetId, host.name, '<span data-lucide="server"></span>', {
+            x: x,
+            y: y,
+            w: w,
+            h: h,
+            minW: 3, minH: 3
+        });
+    });
+}
+
+function createWidget(id, title, icon, gridOptions) {
+    // Create DOM element instead of HTML string (GridStack v12+ requirement)
+    const widgetEl = document.createElement('div');
+    widgetEl.className = 'grid-stack-item';
+    widgetEl.setAttribute('data-widget-id', id);
+
+    widgetEl.innerHTML = `
+        <div class="grid-stack-item-content">
+            <div class="widget-header">
+                <div class="widget-title">
+                    <span>${icon}</span>
+                    <span>${title}</span>
+                </div>
+            </div>
+            <div class="widget-body" id="widget-${id}">
+                <!-- Content will be rendered here -->
+            </div>
+        </div>
+    `;
+
+    // GridStack v12+ API - use makeWidget with options
+    grid.makeWidget(widgetEl, {
+        x: gridOptions.x,
+        y: gridOptions.y,
+        w: gridOptions.w,
+        h: gridOptions.h,
+        minW: gridOptions.minW || 2,
+        minH: gridOptions.minH || 2,
+        maxH: gridOptions.maxH || undefined
+    });
+
+    initIcons();
+    return document.querySelector(`[data-widget-id="${id}"]`);
+}
+
+function renderDashboardWidgets() {
+    logger.debug('renderDashboardWidgets called - hosts:', hosts.length, 'grid:', !!grid);
+
+    // Check if we need to create/remove host widgets (hosts added or removed)
+    if (grid) {
+        const existingHostWidgets = grid.getGridItems().filter(item =>
+            item.getAttribute('data-widget-id')?.startsWith('host-')
+        );
+
+        // Call createHostWidgets if host count changed OR if we have hosts but no widgets
+        if (existingHostWidgets.length !== hosts.length || (hosts.length > 0 && existingHostWidgets.length === 0)) {
+            createHostWidgets();
+        }
+    }
+
+    // Render stats widget - only update values, not rebuild HTML
+    const statsWidget = document.getElementById('widget-stats');
+    if (statsWidget) {
+        // Check if stats grid exists, create if not
+        let statsGrid = statsWidget.querySelector('.stats-grid');
+        if (!statsGrid) {
+            statsWidget.innerHTML = `
+                <div class="stats-grid">
+                    <div class="stat-card">
+                        <div class="stat-label">Total Hosts</div>
+                        <div class="stat-value" data-stat="hosts">0</div>
+                    </div>
+                    <div class="stat-card">
+                        <div class="stat-label">Total Containers</div>
+                        <div class="stat-value" data-stat="containers">0</div>
+                    </div>
+                    <div class="stat-card">
+                        <div class="stat-label">Running</div>
+                        <div class="stat-value" data-stat="running">0</div>
+                    </div>
+                    <div class="stat-card">
+                        <div class="stat-label">Alert Rules</div>
+                        <div class="stat-value" data-stat="alerts">0</div>
+                    </div>
+                </div>
+            `;
+            statsGrid = statsWidget.querySelector('.stats-grid');
+        }
+
+        // Update only the values
+        const hostsValue = statsWidget.querySelector('[data-stat="hosts"]');
+        const containersValue = statsWidget.querySelector('[data-stat="containers"]');
+        const runningValue = statsWidget.querySelector('[data-stat="running"]');
+        const alertsValue = statsWidget.querySelector('[data-stat="alerts"]');
+
+        if (hostsValue) hostsValue.textContent = hosts.length;
+        if (containersValue) containersValue.textContent = containers.length;
+        if (runningValue) runningValue.textContent = containers.filter(c => c.state === 'running').length;
+        if (alertsValue) alertsValue.textContent = alertRules.length;
+    }
+
+    // Render individual host widgets
+    hosts.forEach(host => {
+        const hostWidget = document.getElementById(`widget-host-${host.id}`);
+        if (hostWidget) {
+            // Get containers for this host
+            let hostContainers = containers.filter(c => c.host_id === host.id);
+
+            // Apply global search filter
+            hostContainers = filterContainers(hostContainers);
+
+            // Apply global sort
+            hostContainers = sortContainers(hostContainers);
+            const maxContainersToShow = hostContainers.length; // Show all containers now that widgets are dynamically sized
+
+            // Check if container order or state has changed to avoid unnecessary re-renders
+            const containerStateKey = hostContainers.map(c => `${c.short_id}:${c.auto_restart}:${c.state}`).join(',');
+            const previousStateKey = hostWidget.dataset.containerState;
+
+            const showContainerStats = globalSettings.show_container_stats !== false; // Default to true
+            const containersList = hostContainers.slice(0, maxContainersToShow).map(container => `
+                <div class="container-item" data-status="${container.state}">
+                    <div class="container-info" onclick="showContainerDetails('${container.host_id}', '${container.short_id}')">
+                        <div class="container-icon container-${container.state}">
+                            ${getContainerIcon(container.state)}
+                        </div>
+                        <div class="container-details">
+                            <div class="container-name"><span class="container-status-dot status-${container.state}"></span> ${escapeHtml(container.name)}</div>
+                            <div class="container-id">${escapeHtml(container.short_id)}</div>
+                        </div>
+                    </div>
+                    <div class="container-stats">
+                        ${showContainerStats && container.state === 'running' ? `
+                        <div class="container-stats-charts">
+                            <canvas id="container-cpu-${container.host_id}-${container.short_id}" width="35" height="12"></canvas>
+                            <canvas id="container-ram-${container.host_id}-${container.short_id}" width="35" height="12"></canvas>
+                            <canvas id="container-net-${container.host_id}-${container.short_id}" width="35" height="12"></canvas>
+                        </div>
+                        <div class="container-stats-values">
+                            <div>CPU ${container.cpu_percent ? container.cpu_percent.toFixed(1) : '0'}%</div>
+                            <div>RAM ${container.memory_usage ? formatBytes(container.memory_usage) : '0 B'}</div>
+                            <div id="container-net-value-${container.host_id}-${container.short_id}">NET 0 B/s</div>
+                        </div>
+                        ` : ''}
+                    </div>
+                    <div class="container-actions">
+                        <div class="auto-restart-toggle ${container.auto_restart ? 'enabled' : ''}">
+                            <i data-lucide="rotate-cw" style="width:14px;height:14px;"></i>
+                            <div class="toggle-switch ${container.auto_restart ? 'active' : ''}"
+                                 onclick="toggleAutoRestart('${container.host_id}', '${container.short_id}', event)"></div>
+                        </div>
+                        <span class="container-state ${getStateClass(container.state)}">
+                            ${container.state}
+                        </span>
+                    </div>
+                </div>
+            `).join('');
+
+            const moreCount = hostContainers.length > maxContainersToShow ? hostContainers.length - maxContainersToShow : 0;
+
+            // Update widget title with status badge and metrics
+            const widgetHeader = hostWidget.closest('.grid-stack-item').querySelector('.widget-header');
+            if (widgetHeader) {
+                const showMetrics = globalSettings.show_host_stats !== false; // Default to true
+                const metricsExist = widgetHeader.querySelector('.host-metrics');
+
+                // If metrics visibility changed, rebuild the entire header
+                if ((showMetrics && !metricsExist) || (!showMetrics && metricsExist)) {
+                    // If hiding metrics, clean up Chart.js instances first
+                    if (!showMetrics && metricsExist) {
+                        if (typeof removeHostMetrics === 'function') {
+                            removeHostMetrics(host.id);
+                        }
+                    }
+
+                    widgetHeader.innerHTML = `
+                        <div class="widget-title">
+                            <span><i data-lucide="server" style="width:16px;height:16px;"></i></span>
+                            <span><span class="host-status-dot status-${host.status}" title="${host.status}"></span> ${host.name}</span>
+                        </div>
+                        ${showMetrics ? `
+                        <div class="host-metrics">
+                            <div class="metric-sparkline">
+                                <canvas id="cpu-chart-${host.id}" width="60" height="20"></canvas>
+                                <div class="metric-label">CPU: <span id="cpu-value-${host.id}">0%</span></div>
+                            </div>
+                            <div class="metric-sparkline">
+                                <canvas id="ram-chart-${host.id}" width="60" height="20"></canvas>
+                                <div class="metric-label">RAM: <span id="ram-value-${host.id}">0%</span></div>
+                            </div>
+                            <div class="metric-sparkline">
+                                <canvas id="net-chart-${host.id}" width="60" height="20"></canvas>
+                                <div class="metric-label">NET: <span id="net-value-${host.id}">0 B/s</span></div>
+                            </div>
+                        </div>
+                        ` : ''}
+                    `;
+
+                    // Create charts after DOM is updated (only if showing metrics)
+                    if (showMetrics) {
+                        createHostMetricsCharts(host.id);
+                    }
+                } else if (metricsExist) {
+                    // Metrics already exist and should stay - just update the title/status
+                    const titleElement = widgetHeader.querySelector('.widget-title');
+                    if (titleElement) {
+                        titleElement.innerHTML = `
+                            <span><i data-lucide="server" style="width:16px;height:16px;"></i></span>
+                            <span><span class="host-status-dot status-${host.status}" title="${host.status}"></span> ${host.name}</span>
+                        `;
+                    }
+                }
+            }
+
+            // Check if container stats visibility changed (independently of container state)
+            const previousShowStats = hostWidget.dataset.showContainerStats !== 'false';
+            const statsVisibilityChanged = previousShowStats !== showContainerStats;
+
+            // Only update if the container state has changed, stats visibility changed, or it's the first render
+            if (containerStateKey !== previousStateKey || statsVisibilityChanged) {
+                hostWidget.dataset.containerState = containerStateKey;
+
+                // Check if we're hiding container stats - cleanup charts for all containers on this host
+                if (previousShowStats && !showContainerStats) {
+                    // Clean up all container charts for this host
+                    hostContainers.forEach(container => {
+                        if (typeof removeContainerMetrics === 'function') {
+                            removeContainerMetrics(container.host_id, container.short_id);
+                        }
+                    });
+                }
+                hostWidget.dataset.showContainerStats = showContainerStats;
+
+                hostWidget.innerHTML = `
+                    <div class="container-list">
+                        ${containersList || '<div style="padding: 12px; color: var(--text-tertiary); text-align: center;">No containers</div>'}
+                        ${moreCount > 0 ? `<div style="padding: 8px 12px; font-size: 12px; color: var(--text-tertiary); text-align: center; border-top: 1px solid var(--border);">+${moreCount} more containers</div>` : ''}
+                    </div>
+                `;
+
+                // Create sparklines for running containers
+                if (showContainerStats) {
+                    hostContainers.slice(0, maxContainersToShow).forEach(container => {
+                        if (container.state === 'running') {
+                            createContainerSparklines(container.host_id, container.short_id);
+                            // Update sparklines with current data
+                            updateContainerSparklines(container.host_id, container.short_id, container);
+                        }
+                    });
+                }
+            } else {
+                // Just update the sparkline data without re-rendering
+                if (showContainerStats) {
+                    hostContainers.slice(0, maxContainersToShow).forEach(container => {
+                        if (container.state === 'running') {
+                            updateContainerSparklines(container.host_id, container.short_id, container);
+                        }
+                    });
+                }
+            }
+        }
+    });
+}
+
+function saveDashboardLayoutManual() {
+    saveDashboardLayout();
+    showToast('✅ Dashboard layout saved');
+}
+
+function removeWidget(id) {
+    const widget = document.querySelector(`[data-widget-id="${id}"]`);
+    if (widget) {
+        grid.removeWidget(widget);
+    }
+}
+
+async function saveDashboardLayout() {
+    const layout = grid.save(false);
+    const gridItems = grid.getGridItems();
+
+    // Create a map of grid items by their grid position to ensure correct mapping
+    const layoutWithIds = [];
+
+    for (const gridItem of gridItems) {
+        const widgetId = gridItem.getAttribute('data-widget-id');
+        const gridData = gridItem.gridstackNode;
+
+        if (widgetId && gridData) {
+            layoutWithIds.push({
+                id: widgetId,
+                x: gridData.x,
+                y: gridData.y,
+                w: gridData.w,
+                h: gridData.h
+            });
+        }
+    }
+
+    // Ensure stats widget is always in the saved layout
+    const hasStatsWidget = layoutWithIds.some(item => item.id === 'stats');
+    if (!hasStatsWidget) {
+        logger.debug('Adding missing stats widget to saved layout');
+        layoutWithIds.unshift({
+            id: 'stats',
+            x: 0,
+            y: 0,
+            w: 48,
+            h: 9
+        });
+    }
+
+    logger.debug('Saving layout:', layoutWithIds.map(w => `${w.id} (${w.x},${w.y}) h=${w.h}`));
+
+    // Save to API
+    try {
+        const response = await fetch('/api/user/dashboard-layout', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            credentials: 'include',
+            body: JSON.stringify({ layout: JSON.stringify(layoutWithIds) })
+        });
+
+        if (!response.ok) {
+            logger.error('Failed to save dashboard layout to API:', response.status);
+            showToast('⚠️ Failed to save dashboard layout', 'error');
+        }
+    } catch (error) {
+        logger.error('Error saving dashboard layout:', error);
+        showToast('⚠️ Failed to save dashboard layout', 'error');
+    }
+}
+
+function loadDashboardLayout(layout) {
+    // Remove duplicate stats widgets from saved layout (keep only the first one)
+    const seenIds = new Set();
+    const dedupedLayout = layout.filter(item => {
+        if (item.id === 'stats' && seenIds.has('stats')) {
+            logger.debug('Removing duplicate stats widget from saved layout');
+            return false;
+        }
+        seenIds.add(item.id);
+        return true;
+    });
+
+    // Ensure stats widget is always present first
+    const hasStatsWidget = dedupedLayout.some(item => item.id === 'stats');
+    if (!hasStatsWidget) {
+        logger.debug('Stats widget missing from layout - adding it back');
+        createWidget('stats', 'Statistics', '<span data-lucide="bar-chart-3"></span>', {
+            x: 0, y: 0, w: 48, h: 9,
+            minW: 48, minH: 9, maxH: 9, maxW: 48,
+            noResize: true,
+            noMove: true
+        });
+    }
+
+    // Sort layout for proper reading order (left-to-right, top-to-bottom)
+    // This ensures mobile displays hosts in the same priority order as desktop
+    const sortedLayout = [...dedupedLayout].sort((a, b) => {
+        // Stats widget always first
+        if (a.id === 'stats') return -1;
+        if (b.id === 'stats') return 1;
+
+        // Sort by Y position first (row), then X position (column)
+        if (Math.abs(a.y - b.y) < 5) {  // Same row (within 5 units)
+            return a.x - b.x;  // Left to right
+        }
+        return a.y - b.y;  // Top to bottom
+    });
+
+    sortedLayout.forEach(item => {
+        const widgetConfig = getWidgetConfig(item.id);
+        if (widgetConfig) {
+            // Special handling for stats widget to ensure proper positioning
+            if (item.id === 'stats') {
+                createWidget(widgetConfig.id, widgetConfig.title, widgetConfig.icon, {
+                    x: 0, y: 0, w: 48, h: 9,
+                    minW: 48, minH: 9, maxH: 9, maxW: 48,
+                    noResize: true,
+                    noMove: true
+                });
+            } else {
+                createWidget(widgetConfig.id, widgetConfig.title, widgetConfig.icon, {
+                    x: item.x,
+                    y: item.y,
+                    w: item.w,
+                    h: item.h,
+                    minW: widgetConfig.minW,
+                    minH: widgetConfig.minH,
+                    maxH: widgetConfig.maxH
+                });
+            }
+        } else {
+            logger.debug(`Skipping widget ${item.id} - config not available yet (hosts data may not be loaded)`);
+        }
+    });
+}
+
+function getWidgetConfig(id) {
+    const configs = {
+        'stats': { id: 'stats', title: 'Statistics', icon: '<span data-lucide="bar-chart-3"></span>', minW: 48, minH: 9, maxH: 9, maxW: 48, noResize: true, noMove: true }
+    };
+
+    // Dynamic configs for host widgets
+    if (id.startsWith('host-')) {
+        const hostId = id.replace('host-', '');
+        const host = hosts.find(h => h.id === hostId);
+        if (host) {
+            return { id: id, title: host.name, icon: '<i data-lucide="monitor" style="width:16px;height:16px;"></i>', minW: 3, minH: 3 };
+        }
+    }
+
+    return configs[id];
+}
+
+async function resetDashboardLayout() {
+    // Reload the saved layout from API, or use default if none exists
+    try {
+        const response = await fetch('/api/user/dashboard-layout', {
+            method: 'GET',
+            credentials: 'include'
+        });
+
+        if (response.ok) {
+            const data = await response.json();
+            if (data.layout) {
+                // Revert to last saved layout
+                grid.removeAll();
+                loadDashboardLayout(JSON.parse(data.layout));
+                showToast('🔄 Dashboard layout reset to last saved state');
+            } else {
+                // No saved layout, use default
+                grid.removeAll();
+                createDefaultDashboard();
+                showToast('🔄 Dashboard layout reset to default');
+            }
+        } else {
+            logger.error('Failed to load dashboard layout from API:', response.status);
+            showToast('⚠️ Failed to load dashboard layout', 'error');
+        }
+    } catch (error) {
+        logger.error('Error loading dashboard layout:', error);
+        showToast('⚠️ Failed to load dashboard layout', 'error');
+    }
+}
+
+// ============================================================================
+// Container Search and Sorting
+// ============================================================================
+
+// Global filter state
+let containerSearchTerm = '';
+let containerSortOption = 'name-asc';
+
+// Initialize search/sort from localStorage (search) and database (sort)
+async function initializeContainerFilters() {
+    // Search: from localStorage (session-specific)
+    const savedSearch = localStorage.getItem('dockmon_container_search') || '';
+    containerSearchTerm = savedSearch;
+
+    const searchInput = document.getElementById('containerSearch');
+    if (searchInput) searchInput.value = savedSearch;
+
+    // Sort: from database (cross-browser preference)
+    try {
+        const response = await fetch(`${API_BASE}/api/user/container-sort-order`, {
+            credentials: 'include'
+        });
+        if (response.ok) {
+            const data = await response.json();
+            containerSortOption = data.sort_order || 'name-asc';
+        } else {
+            containerSortOption = 'name-asc'; // Fallback
+        }
+    } catch (error) {
+        logger.error('Error loading container sort preference:', error);
+        containerSortOption = 'name-asc'; // Fallback
+    }
+
+    const sortSelect = document.getElementById('containerSort');
+    if (sortSelect) sortSelect.value = containerSortOption;
+}
+
+// Apply search and sort filters to containers
+async function applyContainerFilters() {
+    const searchInput = document.getElementById('containerSearch');
+    const sortSelect = document.getElementById('containerSort');
+
+    // Update search term (localStorage)
+    if (searchInput) {
+        containerSearchTerm = searchInput.value;
+        localStorage.setItem('dockmon_container_search', containerSearchTerm);
+    }
+
+    // Update sort option (database)
+    if (sortSelect && sortSelect.value !== containerSortOption) {
+        const newSortOption = sortSelect.value;
+
+        try {
+            const response = await fetch(`${API_BASE}/api/user/container-sort-order`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({ sort_order: newSortOption })
+            });
+
+            if (response.ok) {
+                containerSortOption = newSortOption;
+            } else {
+                logger.error('Failed to save container sort preference');
+                // Revert dropdown to previous value
+                sortSelect.value = containerSortOption;
+                showToast('⚠️ Failed to save sort preference', 'error');
+                return;
+            }
+        } catch (error) {
+            logger.error('Error saving container sort preference:', error);
+            // Revert dropdown to previous value
+            sortSelect.value = containerSortOption;
+            showToast('⚠️ Failed to save sort preference', 'error');
+            return;
+        }
+    }
+
+    // Re-render dashboard with filters applied
+    renderDashboardWidgets();
+}
+
+// Filter containers by search term (supports regex)
+function filterContainers(containersList) {
+    if (!containerSearchTerm || containerSearchTerm.trim() === '') {
+        return containersList;
+    }
+
+    const searchTerm = containerSearchTerm.trim();
+
+    // Try to use as regex first, fall back to plain string search
+    try {
+        const regex = new RegExp(searchTerm, 'i');
+        return containersList.filter(c =>
+            regex.test(c.name) || regex.test(c.image)
+        );
+    } catch (e) {
+        // Invalid regex, use plain string search
+        const lowerSearch = searchTerm.toLowerCase();
+        return containersList.filter(c =>
+            c.name.toLowerCase().includes(lowerSearch) ||
+            c.image.toLowerCase().includes(lowerSearch)
+        );
+    }
+}
+
+// Sort containers based on selected option
+function sortContainers(containersList) {
+    const sorted = [...containersList]; // Create copy to avoid mutating original
+
+    switch (containerSortOption) {
+        case 'name-asc':
+            return sorted.sort((a, b) => a.name.localeCompare(b.name));
+
+        case 'name-desc':
+            return sorted.sort((a, b) => b.name.localeCompare(a.name));
+
+        case 'status':
+            // Running > paused > created > restarting > exited > dead
+            const statusPriority = {
+                'running': 1,
+                'paused': 2,
+                'created': 3,
+                'restarting': 4,
+                'exited': 5,
+                'dead': 6
+            };
+            return sorted.sort((a, b) => {
+                const priorityA = statusPriority[a.state] || 99;
+                const priorityB = statusPriority[b.state] || 99;
+                if (priorityA !== priorityB) {
+                    return priorityA - priorityB;
+                }
+                // Same status, sort by name
+                return a.name.localeCompare(b.name);
+            });
+
+        case 'memory-desc':
+            return sorted.sort((a, b) => (b.memory_usage || 0) - (a.memory_usage || 0));
+
+        case 'memory-asc':
+            return sorted.sort((a, b) => (a.memory_usage || 0) - (b.memory_usage || 0));
+
+        case 'cpu-desc':
+            return sorted.sort((a, b) => (b.cpu_percent || 0) - (a.cpu_percent || 0));
+
+        case 'cpu-asc':
+            return sorted.sort((a, b) => (a.cpu_percent || 0) - (b.cpu_percent || 0));
+
+        default:
+            return sorted;
+    }
+}
diff --git a/dockmon/src/js/events.js b/dockmon/src/js/events.js
new file mode 100644
index 0000000..ff7d9b4
--- /dev/null
+++ b/dockmon/src/js/events.js
@@ -0,0 +1,471 @@
+// ==================== Event Log Functions ====================
+
+let currentEventsPage = 0;
+const eventsPerPage = 50;
+let eventSearchTimeout = null;
+let currentSortOrder = 'desc'; // 'desc' = newest first, 'asc' = oldest first
+
+// Multi-select dropdown functions
+function toggleMultiselect(filterId) {
+    const multiselect = document.getElementById(`${filterId}Multiselect`);
+    const wasOpen = multiselect.classList.contains('open');
+
+    // Close all other multiselects
+    document.querySelectorAll('.multiselect').forEach(ms => ms.classList.remove('open'));
+
+    // Toggle this one
+    if (!wasOpen) {
+        multiselect.classList.add('open');
+    }
+
+    // Re-create icons after DOM manipulation
+    if (typeof lucide !== 'undefined') {
+        lucide.createIcons();
+    }
+}
+
+function updateMultiselect(filterId) {
+    const dropdown = document.getElementById(`${filterId}Dropdown`);
+    const checkboxes = dropdown.querySelectorAll('input[type="checkbox"]:checked');
+    const selected = Array.from(checkboxes).map(cb => cb.value);
+
+    // Update the label
+    const label = document.querySelector(`#${filterId}Multiselect .multiselect-label`);
+    if (selected.length === 0) {
+        if (filterId === 'eventCategory') label.textContent = 'All Categories';
+        else if (filterId === 'eventSeverity') label.textContent = 'All Severities';
+        else if (filterId === 'eventHost') label.textContent = 'All Hosts';
+    } else if (selected.length === 1) {
+        label.textContent = selected[0].charAt(0).toUpperCase() + selected[0].slice(1);
+    } else {
+        label.textContent = `${selected.length} selected`;
+    }
+
+    // Trigger filter update
+    filterEvents();
+}
+
+function getMultiselectValues(filterId) {
+    const dropdown = document.getElementById(`${filterId}Dropdown`);
+    const checkboxes = dropdown.querySelectorAll('input[type="checkbox"]:checked');
+    return Array.from(checkboxes).map(cb => cb.value);
+}
+
+// Close multiselects when clicking outside
+document.addEventListener('click', function(event) {
+    if (!event.target.closest('.multiselect')) {
+        document.querySelectorAll('.multiselect').forEach(ms => ms.classList.remove('open'));
+    }
+});
+
+async function loadEvents() {
+    const eventsList = document.getElementById('eventsList');
+    if (!eventsList) return;
+
+    eventsList.innerHTML = '<div class="events-loading">Loading events...</div>';
+
+    try {
+        // Build query parameters
+        const timeRange = document.getElementById('eventTimeRange').value;
+        const categories = getMultiselectValues('eventCategory');
+        const severities = getMultiselectValues('eventSeverity');
+        const hostIds = getMultiselectValues('eventHost');
+        const search = document.getElementById('eventSearch').value;
+
+        const params = new URLSearchParams({
+            limit: eventsPerPage,
+            offset: currentEventsPage * eventsPerPage
+        });
+
+        if (timeRange !== 'all') {
+            params.append('hours', timeRange);
+        }
+
+        // Append multiple values for multi-select filters
+        categories.forEach(cat => params.append('category', cat));
+        severities.forEach(sev => params.append('severity', sev));
+        hostIds.forEach(host => params.append('host_id', host));
+
+        if (search) params.append('search', search);
+
+        const response = await fetch(`/api/events?${params}`, {
+            credentials: 'include'
+        });
+
+        if (!response.ok) {
+            throw new Error('Failed to load events');
+        }
+
+        const data = await response.json();
+        renderEvents(data);
+    } catch (error) {
+        logger.error('Error loading events:', error);
+        eventsList.innerHTML = '<div class="events-empty">Failed to load events. Please try again.</div>';
+        showToast('Failed to load events', 'error');
+    }
+}
+
+function renderEvents(data) {
+    const eventsList = document.getElementById('eventsList');
+    const eventsPagination = document.getElementById('eventsPagination');
+
+    if (!data.events || data.events.length === 0) {
+        eventsList.innerHTML = `
+            <div class="events-empty">
+                <span data-lucide="inbox"></span>
+                <p>No events found</p>
+            </div>
+        `;
+        lucide.createIcons();
+        eventsPagination.innerHTML = '';
+        return;
+    }
+
+    // Render events
+    let html = '';
+    data.events.forEach(event => {
+        html += renderEventItem(event);
+    });
+    eventsList.innerHTML = html;
+    lucide.createIcons();
+
+    // Render pagination
+    const start = currentEventsPage * eventsPerPage + 1;
+    const end = Math.min((currentEventsPage + 1) * eventsPerPage, data.total_count);
+
+    eventsPagination.innerHTML = `
+        <div class="pagination-info">
+            Showing ${start}-${end} of ${data.total_count} events
+        </div>
+        <div class="pagination-controls">
+            <button class="pagination-btn" ${currentEventsPage === 0 ? 'disabled' : ''} onclick="previousEventsPage()">
+                <span data-lucide="chevron-left"></span> Previous
+            </button>
+            <button class="pagination-btn" ${!data.has_more ? 'disabled' : ''} onclick="nextEventsPage()">
+                Next <span data-lucide="chevron-right"></span>
+            </button>
+        </div>
+    `;
+    lucide.createIcons();
+}
+
+function renderEventItem(event) {
+    // Ensure timestamp is treated as UTC if no timezone info
+    let timestampStr = event.timestamp;
+    if (!timestampStr.includes('+') && !timestampStr.endsWith('Z')) {
+        timestampStr += 'Z';  // Treat as UTC
+    }
+    const timestamp = new Date(timestampStr).toLocaleString('en-US', {
+        month: '2-digit',
+        day: '2-digit',
+        year: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: true
+    });
+
+    // Build inline metadata
+    let metaParts = [];
+
+    if (event.container_name) {
+        metaParts.push(`container=${escapeHtml(event.container_name)}`);
+    }
+
+    if (event.host_name) {
+        metaParts.push(`host=${escapeHtml(event.host_name)}`);
+    }
+
+    // Don't show user=user since we already show (user action) in the event text
+    // if (event.triggered_by && event.triggered_by !== 'system') {
+    //     metaParts.push(`user=${escapeHtml(event.triggered_by)}`);
+    // }
+
+    const metaString = metaParts.length > 0 ? metaParts.join(' ') : '';
+
+    // Build the event text - show message if it's different from title
+    let eventText = escapeHtml(event.title);
+    if (event.message && event.message !== event.title) {
+        // Extract the useful part of the message (e.g., "from running to exited")
+        const stateChangeMatch = event.message.match(/state changed from (\w+) to (\w+)/i);
+        if (stateChangeMatch) {
+            const fromState = stateChangeMatch[1];
+            const toState = stateChangeMatch[2];
+            const userAction = event.message.includes('(user action)') ? ' <span style="color: var(--text-secondary);">(user action)</span>' : '';
+            eventText += ` from <span class="state-${fromState}">${escapeHtml(fromState)}</span> to <span class="state-${toState}">${escapeHtml(toState)}</span>${userAction}`;
+        } else {
+            // For other messages, show full message instead of title
+            eventText = escapeHtml(event.message);
+        }
+    }
+
+    return `
+        <div class="event-line severity-${event.severity}">
+            <span class="event-timestamp">${timestamp}</span>
+            <span class="event-severity-dot"></span>
+            <span class="event-level">level=${event.severity}</span>
+            <span class="event-message-text">${eventText}</span>
+            ${metaString ? `<span class="event-meta-inline">${metaString}</span>` : ''}
+            <div class="event-mobile-content">
+                <div class="event-mobile-header"><span class="event-severity-dot"></span><span class="event-mobile-time">${timestamp}</span></div>
+                <div class="event-mobile-message">${eventText}</div>
+            </div>
+        </div>
+    `;
+}
+
+// getCategoryIcon() removed - unused function
+
+function formatEventTime(timestamp) {
+    const date = new Date(timestamp);
+    const now = new Date();
+    const diff = now - date;
+    const seconds = Math.floor(diff / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+
+    if (seconds < 60) return 'Just now';
+    if (minutes < 60) return `${minutes}m ago`;
+    if (hours < 24) return `${hours}h ago`;
+    if (days < 7) return `${days}d ago`;
+
+    return date.toLocaleDateString() + ' ' + date.toLocaleTimeString();
+}
+
+// showEventDetails() removed - unused function (TODO was never implemented)
+
+function refreshEvents() {
+    currentEventsPage = 0;
+    loadEvents();
+}
+
+function filterEvents() {
+    currentEventsPage = 0;
+    loadEvents();
+}
+
+function debounceEventSearch() {
+    clearTimeout(eventSearchTimeout);
+    eventSearchTimeout = setTimeout(() => {
+        filterEvents();
+    }, 500);
+}
+
+function nextEventsPage() {
+    currentEventsPage++;
+    loadEvents();
+}
+
+function previousEventsPage() {
+    if (currentEventsPage > 0) {
+        currentEventsPage--;
+        loadEvents();
+    }
+}
+
+async function populateEventHostFilter() {
+    const hostDropdown = document.getElementById('eventHostDropdown');
+    if (!hostDropdown) return;
+
+    // Clear existing checkboxes
+    hostDropdown.innerHTML = '';
+
+    // Add hosts from the global hosts array
+    hosts.forEach(host => {
+        const label = document.createElement('label');
+        const checkbox = document.createElement('input');
+        checkbox.type = 'checkbox';
+        checkbox.value = host.id;
+        checkbox.onchange = () => updateMultiselect('eventHost');
+
+        label.appendChild(checkbox);
+        label.appendChild(document.createTextNode(' ' + host.name));
+        hostDropdown.appendChild(label);
+    });
+}
+
+async function loadEventSortOrder() {
+    try {
+        const response = await fetch('/api/user/event-sort-order', {
+            credentials: 'include'
+        });
+        if (response.ok) {
+            const data = await response.json();
+            currentSortOrder = data.sort_order || 'desc';
+            updateSortOrderButton();
+        }
+    } catch (error) {
+        logger.error('Failed to load sort order preference:', error);
+    }
+}
+
+async function toggleEventSortOrder() {
+    // Toggle between asc and desc
+    currentSortOrder = currentSortOrder === 'desc' ? 'asc' : 'desc';
+
+    // Save to backend
+    try {
+        await fetch('/api/user/event-sort-order', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            credentials: 'include',
+            body: JSON.stringify({ sort_order: currentSortOrder })
+        });
+    } catch (error) {
+        logger.error('Failed to save sort order:', error);
+        showToast('Failed to save sort order', 'error');
+    }
+
+    // Update button
+    updateSortOrderButton();
+
+    // Reload events with new sort order
+    currentEventsPage = 0;
+    loadEvents();
+}
+
+function updateSortOrderButton() {
+    const btn = document.getElementById('sortOrderBtn');
+    if (!btn) return;
+
+    if (currentSortOrder === 'desc') {
+        btn.innerHTML = '<span data-lucide="arrow-down-wide-narrow"></span> Newest First';
+    } else {
+        btn.innerHTML = '<span data-lucide="arrow-up-narrow-wide"></span> Oldest First';
+    }
+    lucide.createIcons();
+}
+
+// WebSocket handling for real-time event updates
+let isOnEventsPage = false;
+
+// Register a custom handler using the wsMessageHandlers array instead of overriding the function
+if (!window.wsMessageHandlers) {
+    window.wsMessageHandlers = [];
+}
+
+window.wsMessageHandlers.push(function(data) {
+    // Only process new_event messages when on the events page
+    if (data.type === 'new_event' && isOnEventsPage) {
+        const event = data.event;
+
+        // Check if event matches current filters
+        if (shouldShowEvent(event)) {
+            prependNewEvent(event);
+        }
+    }
+});
+
+function shouldShowEvent(event) {
+    // Check if event matches current filters
+    const categories = getMultiselectValues('eventCategory');
+    const severities = getMultiselectValues('eventSeverity');
+    const hostIds = getMultiselectValues('eventHost');
+    const search = document.getElementById('eventSearch')?.value;
+
+    // Category filter - if any categories selected, event must match one
+    if (categories.length > 0 && !categories.includes(event.category)) return false;
+
+    // Severity filter - if any severities selected, event must match one
+    if (severities.length > 0 && !severities.includes(event.severity)) return false;
+
+    // Host filter - if any hosts selected, event must match one
+    if (hostIds.length > 0 && !hostIds.includes(event.host_id)) return false;
+
+    // Search filter (supports regex)
+    if (search) {
+        const searchTerm = search.trim();
+
+        // Try to use as regex first, fall back to plain string search
+        try {
+            const regex = new RegExp(searchTerm, 'i');
+            const titleMatch = event.title && regex.test(event.title);
+            const messageMatch = event.message && regex.test(event.message);
+            const containerMatch = event.container_name && regex.test(event.container_name);
+            if (!titleMatch && !messageMatch && !containerMatch) return false;
+        } catch (e) {
+            // Invalid regex, use plain string search
+            const searchLower = searchTerm.toLowerCase();
+            const titleMatch = event.title?.toLowerCase().includes(searchLower);
+            const messageMatch = event.message?.toLowerCase().includes(searchLower);
+            const containerMatch = event.container_name?.toLowerCase().includes(searchLower);
+            if (!titleMatch && !messageMatch && !containerMatch) return false;
+        }
+    }
+
+    return true;
+}
+
+function prependNewEvent(event) {
+    const eventsList = document.getElementById('eventsList');
+    if (!eventsList) return;
+
+    // Check if we're showing empty state
+    const emptyState = eventsList.querySelector('.events-empty');
+    if (emptyState) {
+        emptyState.remove();
+    }
+
+    // Create new event HTML
+    const eventHtml = renderEventItem(event);
+
+    // Add to top or bottom depending on sort order
+    const tempDiv = document.createElement('div');
+    tempDiv.innerHTML = eventHtml;
+    const eventElement = tempDiv.firstElementChild;
+    eventElement.style.opacity = '0';
+
+    if (currentSortOrder === 'desc') {
+        // Newest first - add to top
+        eventElement.style.transform = 'translateY(-10px)';
+        eventsList.insertBefore(eventElement, eventsList.firstChild);
+    } else {
+        // Oldest first - add to bottom
+        eventElement.style.transform = 'translateY(10px)';
+        eventsList.appendChild(eventElement);
+    }
+
+    // Trigger animation
+    setTimeout(() => {
+        eventElement.style.transition = 'all 0.3s ease';
+        eventElement.style.opacity = '1';
+        eventElement.style.transform = 'translateY(0)';
+    }, 10);
+
+    // Re-render icons
+    lucide.createIcons();
+
+    // Show a subtle notification
+    const badge = document.createElement('div');
+    badge.style.cssText = 'position: fixed; top: 80px; right: 20px; background: var(--primary); color: white; padding: 8px 16px; border-radius: 6px; font-size: 14px; z-index: 10000; box-shadow: 0 4px 12px rgba(0,0,0,0.3); animation: slideIn 0.3s ease;';
+    badge.innerHTML = '<span data-lucide="bell"></span> New event';
+    document.body.appendChild(badge);
+    lucide.createIcons();
+
+    setTimeout(() => {
+        badge.style.opacity = '0';
+        badge.style.transition = 'opacity 0.3s ease';
+        setTimeout(() => badge.remove(), 300);
+    }, 2000);
+}
+
+// Hook into the existing WebSocket connection
+// The websocket is initialized in app.js and messages are handled globally
+// Hook into page switching to load events
+document.addEventListener('DOMContentLoaded', function() {
+    const originalSwitchPage = window.switchPage;
+    if (originalSwitchPage) {
+        window.switchPage = function(page) {
+            originalSwitchPage(page);
+            if (page === 'events') {
+                isOnEventsPage = true;
+                loadEventSortOrder();
+                populateEventHostFilter();
+                loadEvents();
+            } else {
+                isOnEventsPage = false;
+            }
+        };
+    }
+});
\ No newline at end of file
diff --git a/dockmon/src/js/logger.js b/dockmon/src/js/logger.js
new file mode 100644
index 0000000..725b961
--- /dev/null
+++ b/dockmon/src/js/logger.js
@@ -0,0 +1,68 @@
+/**
+ * DockMon Logging Utility
+ * Centralized logging with environment-based levels
+ */
+
+const LogLevel = {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3,
+    NONE: 4
+};
+
+class Logger {
+    constructor() {
+        // Set log level based on environment or default to INFO for production
+        this.level = this.getLogLevel();
+    }
+
+    getLogLevel() {
+        // Default to WARN level (only show warnings and errors)
+        return LogLevel.WARN;
+    }
+
+    debug(...args) {
+        if (this.level <= LogLevel.DEBUG) {
+            console.log('[DEBUG]', ...args);
+        }
+    }
+
+    info(...args) {
+        if (this.level <= LogLevel.INFO) {
+            console.info('[INFO]', ...args);
+        }
+    }
+
+    warn(...args) {
+        if (this.level <= LogLevel.WARN) {
+            console.warn('[WARN]', ...args);
+        }
+    }
+
+    error(...args) {
+        if (this.level <= LogLevel.ERROR) {
+            console.error('[ERROR]', ...args);
+        }
+    }
+
+    // For WebSocket/Network debugging
+    ws(...args) {
+        if (this.level <= LogLevel.DEBUG) {
+            console.log('[WS]', ...args);
+        }
+    }
+
+    // For API debugging
+    api(...args) {
+        if (this.level <= LogLevel.DEBUG) {
+            console.log('[API]', ...args);
+        }
+    }
+}
+
+// Create singleton instance
+const logger = new Logger();
+
+// Make available globally
+window.logger = logger;
diff --git a/dockmon/src/js/logs.js b/dockmon/src/js/logs.js
new file mode 100644
index 0000000..0c7e0da
--- /dev/null
+++ b/dockmon/src/js/logs.js
@@ -0,0 +1,539 @@
+// logs.js - Container Logs Viewer with multi-container support
+
+let selectedContainers = []; // Array of {hostId, containerId, name}
+let logsPaused = false;
+let logsPollingInterval = null;
+let allLogs = []; // Consolidated logs from all containers
+let containerColorMap = {}; // Map container IDs to color indices
+let nextColorIndex = 0;
+let logsSortOrder = 'desc'; // 'asc' or 'desc'
+let isFetchingLogs = false; // Prevent concurrent fetch calls
+let isRestoringSelection = false; // Prevent onchange during dropdown rebuild
+let pendingSelectionChange = false; // Track if selection changed while dropdown was open
+
+// Initialize logs page when switched to
+function initLogsPage() {
+    // Wait a bit for hosts data to load if needed
+    if (!window.hosts || window.hosts.length === 0) {
+        setTimeout(() => {
+            populateContainerList();
+        }, 500);
+    } else {
+        populateContainerList();
+    }
+    stopLogsPolling(); // Stop any existing polling
+    loadLogsSortOrder();
+}
+
+// Load sort order from localStorage
+function loadLogsSortOrder() {
+    const saved = localStorage.getItem('logsSortOrder');
+    if (saved) {
+        logsSortOrder = saved;
+        updateLogsSortButton();
+    }
+}
+
+// Save sort order to localStorage
+function saveLogsSortOrder() {
+    localStorage.setItem('logsSortOrder', logsSortOrder);
+}
+
+// Populate container list for multi-select
+function populateContainerList() {
+    const dropdown = document.getElementById('logsContainerDropdown');
+    if (!dropdown) {
+        logger.error('Dropdown element not found');
+        return;
+    }
+
+    // Save current selection state before rebuilding
+    const selectedKeys = selectedContainers.map(c => `${c.hostId}:${c.containerId}`);
+
+    // Prevent onchange events during restoration
+    isRestoringSelection = true;
+
+    dropdown.innerHTML = '';
+
+    // Get hosts and containers from global arrays (populated by core.js via WebSocket)
+    if (!window.hosts || window.hosts.length === 0) {
+        dropdown.innerHTML = '<div style="padding: 12px; color: var(--text-tertiary);">No hosts available. Make sure you have hosts configured.</div>';
+        return;
+    }
+
+    if (!window.containers || window.containers.length === 0) {
+        dropdown.innerHTML = '<div style="padding: 12px; color: var(--text-tertiary);">No containers available. Make sure your hosts have running containers.</div>';
+        return;
+    }
+
+    // Group containers by host_id
+    const containersByHost = {};
+    window.containers.forEach(container => {
+        if (!containersByHost[container.host_id]) {
+            containersByHost[container.host_id] = [];
+        }
+        containersByHost[container.host_id].push(container);
+    });
+
+    let totalContainers = 0;
+
+    // Sort hosts by dashboard widget position (left-to-right, top-to-bottom)
+    // Get widget positions from GridStack if available
+    let sortedHosts = [...window.hosts];
+    if (typeof grid !== 'undefined' && grid) {
+        const widgetPositions = {};
+        grid.getGridItems().forEach(widget => {
+            const widgetId = widget.getAttribute('data-widget-id');
+            if (widgetId && widgetId.startsWith('host-')) {
+                const hostId = widgetId.replace('host-', '');
+                const gridData = widget.gridstackNode;
+                if (gridData) {
+                    widgetPositions[hostId] = { y: gridData.y, x: gridData.x };
+                }
+            }
+        });
+
+        // Sort by y (row) first, then x (column)
+        sortedHosts.sort((a, b) => {
+            const posA = widgetPositions[a.id];
+            const posB = widgetPositions[b.id];
+
+            // If no position data, put at end
+            if (!posA && !posB) return 0;
+            if (!posA) return 1;
+            if (!posB) return -1;
+
+            // Sort by row (y), then column (x)
+            if (posA.y !== posB.y) {
+                return posA.y - posB.y;
+            }
+            return posA.x - posB.x;
+        });
+    }
+
+    // Iterate through hosts and show their containers
+    sortedHosts.forEach(host => {
+        const hostContainers = containersByHost[host.id] || [];
+        if (hostContainers.length === 0) return;
+
+        // Sort containers alphabetically by name (same as dashboard)
+        hostContainers.sort((a, b) => a.name.localeCompare(b.name));
+
+        totalContainers += hostContainers.length;
+
+        // Add host header
+        const hostHeader = document.createElement('div');
+        hostHeader.style.padding = '8px 12px';
+        hostHeader.style.fontWeight = '600';
+        hostHeader.style.color = 'var(--text-secondary)';
+        hostHeader.style.fontSize = '12px';
+        hostHeader.style.borderBottom = '1px solid var(--border)';
+        hostHeader.textContent = host.name;
+        dropdown.appendChild(hostHeader);
+
+        // Add containers for this host
+        hostContainers.forEach(container => {
+            const label = document.createElement('label');
+            label.style.display = 'block';
+            label.style.padding = '8px 12px';
+            label.style.cursor = 'pointer';
+
+            // Determine status color and symbol
+            let statusColor, statusSymbol;
+            if (container.state === 'running') {
+                statusColor = '#22c55e'; // Green
+                statusSymbol = '●';
+            } else if (container.state === 'exited') {
+                statusColor = '#ef4444'; // Red
+                statusSymbol = '●';
+            } else {
+                statusColor = '#6b7280'; // Grey
+                statusSymbol = '○';
+            }
+
+            const containerKey = `${host.id}:${container.id}`;
+            const isSelected = selectedKeys.includes(containerKey);
+
+            label.innerHTML = `
+                <input type="checkbox"
+                       value="${containerKey}"
+                       ${isSelected ? 'checked' : ''}
+                       onchange="updateContainerSelection()">
+                <span style="margin-left: 8px;">${container.name}</span>
+                <span style="margin-left: 8px; color: ${statusColor}; font-size: 11px;">
+                    ${statusSymbol}
+                </span>
+            `;
+            dropdown.appendChild(label);
+        });
+    });
+
+    if (totalContainers === 0) {
+        dropdown.innerHTML = '<div style="padding: 12px; color: var(--text-tertiary);">No containers available. Make sure your hosts have running containers.</div>';
+    }
+
+    // Re-enable onchange events after restoration is complete
+    setTimeout(() => {
+        isRestoringSelection = false;
+    }, 0);
+}
+
+// Update selected containers and fetch logs immediately
+function updateContainerSelection() {
+    // Skip if we're just restoring selection during dropdown rebuild
+    if (isRestoringSelection) {
+        return;
+    }
+
+    // Update UI immediately (label and selection state)
+    const dropdown = document.getElementById('logsContainerDropdown');
+    const checkboxes = dropdown.querySelectorAll('input[type="checkbox"]:checked');
+
+    // Enforce 15 container limit to protect API
+    if (checkboxes.length > 15) {
+        showToast('⚠️ Maximum 15 containers can be selected at once', 'warning');
+        // Uncheck the last selected checkbox
+        checkboxes[checkboxes.length - 1].checked = false;
+        return;
+    }
+
+    selectedContainers = Array.from(checkboxes).map(cb => {
+        const [hostId, containerId] = cb.value.split(':');
+        const containersData = window.containers || [];
+        const container = containersData.find(c => c.id === containerId && c.host_id === hostId);
+        return {
+            hostId,
+            containerId,
+            name: container?.name || 'Unknown'
+        };
+    });
+
+    // Update label
+    const label = document.querySelector('#logsContainerMultiselect .multiselect-label');
+    if (selectedContainers.length === 0) {
+        label.textContent = 'Select containers to view logs...';
+    } else if (selectedContainers.length === 1) {
+        label.textContent = selectedContainers[0].name;
+    } else {
+        label.textContent = `${selectedContainers.length} containers selected`;
+    }
+
+    // Assign colors to containers
+    selectedContainers.forEach((container, index) => {
+        const key = `${container.hostId}:${container.containerId}`;
+        if (!(key in containerColorMap)) {
+            containerColorMap[key] = nextColorIndex % 8;
+            nextColorIndex++;
+        }
+    });
+
+    if (typeof lucide !== 'undefined') {
+        lucide.createIcons();
+    }
+
+    // Reload logs immediately (no rate limiting on backend for authenticated users)
+    reloadLogs();
+}
+
+// Reload logs from scratch
+async function reloadLogs() {
+    stopLogsPolling();
+    allLogs = [];
+
+    if (selectedContainers.length === 0) {
+        showLogsPlaceholder();
+        return;
+    }
+
+    await fetchLogs();
+    startLogsPolling();
+}
+
+// Fetch logs from all selected containers
+async function fetchLogs() {
+    if (selectedContainers.length === 0 || logsPaused) return;
+
+    // Prevent concurrent fetches
+    if (isFetchingLogs) {
+        logger.debug('[LOGS] Fetch already in progress, skipping...');
+        return;
+    }
+
+    isFetchingLogs = true;
+    logger.debug('[LOGS] Starting fetch for', selectedContainers.length, 'containers');
+
+    const tailCount = document.getElementById('logsTailCount').value;
+    const tail = tailCount === 'all' ? 10000 : parseInt(tailCount);
+    let rateLimitHit = false;
+
+    try {
+        // Fetch logs from all containers with staggered delays to avoid rate limiting
+        const promises = selectedContainers.map(async (container, index) => {
+            // Add 100ms delay between each request to spread them out
+            if (index > 0) {
+                await new Promise(resolve => setTimeout(resolve, index * 100));
+            }
+
+            try {
+                const response = await fetch(
+                    `${API_BASE}/api/hosts/${container.hostId}/containers/${container.containerId}/logs?tail=${tail}`
+                );
+
+                if (response.status === 429) {
+                    rateLimitHit = true;
+                    return [];
+                }
+
+                if (!response.ok) return [];
+
+                const data = await response.json();
+                // Add container info to each log line
+                return (data.logs || []).map(log => ({
+                    ...log,
+                    containerName: container.name,
+                    containerKey: `${container.hostId}:${container.containerId}`
+                }));
+            } catch (error) {
+                logger.error(`Error fetching logs for ${container.name}:`, error);
+                return [];
+            }
+        });
+
+        const logsArrays = await Promise.all(promises);
+
+        // If rate limit was hit, pause auto-refresh and notify user
+        if (rateLimitHit) {
+            stopLogsPolling();
+            const autoRefreshCheckbox = document.getElementById('logsAutoRefresh');
+            if (autoRefreshCheckbox) {
+                autoRefreshCheckbox.checked = false;
+            }
+            showToast('⚠️ Rate limit reached. Auto-refresh paused. Try selecting fewer containers or wait a moment.', 'error');
+        }
+
+        // Merge all logs
+        const newLogs = logsArrays.flat();
+
+        // Sort by timestamp (based on sort order)
+        newLogs.sort((a, b) => {
+            const aTime = new Date(a.timestamp);
+            const bTime = new Date(b.timestamp);
+            return logsSortOrder === 'asc' ? aTime - bTime : bTime - aTime;
+        });
+
+        allLogs = newLogs;
+        renderLogs();
+    } catch (error) {
+        logger.error('[LOGS] Error fetching logs:', error);
+    } finally {
+        isFetchingLogs = false;
+        logger.debug('[LOGS] Fetch completed');
+    }
+}
+
+// Render logs to the container
+function renderLogs() {
+    const container = document.getElementById('logsContainer');
+    if (!container) return;
+
+    if (allLogs.length === 0) {
+        container.innerHTML = '<div class="logs-placeholder"><p>No logs available</p></div>';
+        return;
+    }
+
+    const showTimestamps = document.getElementById('logsTimestamps').checked;
+    const searchInput = document.getElementById('logsSearchInput').value;
+
+    // Filter logs by search term (supports regex)
+    let filteredLogs = allLogs;
+    if (searchInput && searchInput.trim() !== '') {
+        const searchTerm = searchInput.trim();
+
+        // Try to use as regex first, fall back to plain string search
+        try {
+            const regex = new RegExp(searchTerm, 'i');
+            filteredLogs = allLogs.filter(log => regex.test(log.log));
+        } catch (e) {
+            // Invalid regex, use plain string search
+            const searchLower = searchTerm.toLowerCase();
+            filteredLogs = allLogs.filter(log => log.log.toLowerCase().includes(searchLower));
+        }
+    }
+
+    // Build HTML
+    let html = '';
+    filteredLogs.forEach(log => {
+        const colorIndex = containerColorMap[log.containerKey] || 0;
+        const timestamp = new Date(log.timestamp).toLocaleString('en-US', {
+            month: '2-digit',
+            day: '2-digit',
+            year: 'numeric',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            hour12: true
+        });
+
+        html += `<div class="log-line" data-container="${colorIndex}">`;
+        if (showTimestamps) {
+            html += `<span class="log-timestamp">${timestamp}</span>`;
+        }
+        if (selectedContainers.length > 1) {
+            html += `<span class="log-container-name">${escapeHtml(log.containerName)}</span>`;
+        }
+        html += `<span class="log-text">${escapeHtml(log.log)}</span>`;
+        html += `</div>`;
+    });
+
+    const shouldScroll = isScrolledToBottom(container);
+    container.innerHTML = html;
+
+    if (shouldScroll && !logsPaused) {
+        scrollToBottom(container);
+    }
+}
+
+// Helper functions
+function escapeHtml(text) {
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+}
+
+function isScrolledToBottom(element) {
+    return element.scrollHeight - element.scrollTop <= element.clientHeight + 100;
+}
+
+function scrollToBottom(element) {
+    element.scrollTop = element.scrollHeight;
+}
+
+function showLogsPlaceholder() {
+    const container = document.getElementById('logsContainer');
+    if (container) {
+        container.innerHTML = `
+            <div class="logs-placeholder">
+                <span data-lucide="file-text" style="width: 48px; height: 48px; opacity: 0.3;"></span>
+                <p>Select one or more containers to view logs</p>
+            </div>
+        `;
+        if (typeof lucide !== 'undefined') {
+            lucide.createIcons();
+        }
+    }
+}
+
+// Polling management
+function startLogsPolling() {
+    stopLogsPolling();
+    const autoRefresh = document.getElementById('logsAutoRefresh')?.checked;
+    if (selectedContainers.length > 0 && autoRefresh && !logsPaused) {
+        logger.debug('[LOGS] Starting polling interval (2s)');
+        logsPollingInterval = setInterval(fetchLogs, 2000); // Poll every 2 seconds (same as container modal)
+    }
+}
+
+function stopLogsPolling() {
+    if (logsPollingInterval) {
+        logger.debug('[LOGS] Stopping polling interval');
+        clearInterval(logsPollingInterval);
+        logsPollingInterval = null;
+    }
+}
+
+// Control functions
+function toggleLogsAutoRefresh() {
+    const autoRefresh = document.getElementById('logsAutoRefresh').checked;
+    if (autoRefresh) {
+        startLogsPolling();
+    } else {
+        stopLogsPolling();
+    }
+}
+
+function toggleLogsSort() {
+    logsSortOrder = logsSortOrder === 'asc' ? 'desc' : 'asc';
+    saveLogsSortOrder();
+    updateLogsSortButton();
+
+    // Re-sort and re-render existing logs
+    allLogs.sort((a, b) => {
+        const aTime = new Date(a.timestamp);
+        const bTime = new Date(b.timestamp);
+        return logsSortOrder === 'asc' ? aTime - bTime : bTime - aTime;
+    });
+    renderLogs();
+}
+
+function updateLogsSortButton() {
+    const btn = document.getElementById('logsSortBtn');
+    if (!btn) return;
+
+    if (logsSortOrder === 'desc') {
+        btn.innerHTML = '<span data-lucide="arrow-down-wide-narrow"></span> Newest First';
+    } else {
+        btn.innerHTML = '<span data-lucide="arrow-up-narrow-wide"></span> Oldest First';
+    }
+
+    if (typeof lucide !== 'undefined') {
+        lucide.createIcons();
+    }
+}
+
+function clearLogs() {
+    allLogs = [];
+    renderLogs();
+}
+
+function downloadLogs() {
+    if (allLogs.length === 0) return;
+
+    const showTimestamps = document.getElementById('logsTimestamps').checked;
+    let content = '';
+
+    allLogs.forEach(log => {
+        let line = '';
+        if (showTimestamps) {
+            const timestamp = new Date(log.timestamp).toISOString();
+            line += `[${timestamp}] `;
+        }
+        if (selectedContainers.length > 1) {
+            line += `[${log.containerName}] `;
+        }
+        line += log.log + '\n';
+        content += line;
+    });
+
+    const blob = new Blob([content], { type: 'text/plain' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = `container-logs-${new Date().toISOString()}.txt`;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+}
+
+function filterLogs() {
+    renderLogs();
+}
+
+function toggleTimestamps() {
+    renderLogs();
+}
+
+// Hook into page switching
+document.addEventListener('DOMContentLoaded', function() {
+    const originalSwitchPage = window.switchPage;
+    if (originalSwitchPage) {
+        window.switchPage = function(page) {
+            originalSwitchPage(page);
+            if (page === 'logs') {
+                initLogsPage();
+            } else {
+                stopLogsPolling();
+            }
+        };
+    }
+});
diff --git a/dockmon/src/js/metrics.js b/dockmon/src/js/metrics.js
new file mode 100644
index 0000000..e4618e6
--- /dev/null
+++ b/dockmon/src/js/metrics.js
@@ -0,0 +1,381 @@
+// Host Metrics Management
+// Handles visualization of host metrics received via WebSocket
+
+// Configuration constants
+const HOST_CHART_DATA_POINTS = 60;  // ~5 minutes of data at 5s intervals
+const CONTAINER_CHART_DATA_POINTS = 20;  // ~1.5 minutes of data at 5s intervals
+const CHART_LOAD_TIMEOUT = 5000;  // Timeout for Chart.js to load (ms)
+const CHART_POLL_INTERVAL = 50;  // Polling interval for Chart.js availability (ms)
+const METRICS_CLEANUP_INTERVAL = 60000;  // Cleanup stale metrics every 60 seconds
+
+// Store chart instances for each host
+const hostMetricsCharts = new Map(); // host_id -> { cpu: Chart, ram: Chart, net: Chart }
+
+// Store previous network values for rate calculation
+const networkHistory = new Map(); // host_id -> { lastRx: 0, lastTx: 0, lastTimestamp: 0 }
+
+// Track pending updates for hosts whose charts aren't ready yet
+const pendingHostUpdates = new Map(); // host_id -> metrics
+
+/**
+ * Create sparkline charts for a host widget
+ * Called after the host widget DOM is rendered
+ */
+function createHostMetricsCharts(hostId) {
+    // Wait for Chart.js to be loaded
+    const waitForChart = setInterval(() => {
+        if (typeof Chart === 'undefined') {
+            return; // Chart.js not loaded yet
+        }
+
+        clearInterval(waitForChart);
+
+        const cpuCanvas = document.getElementById(`cpu-chart-${hostId}`);
+        const ramCanvas = document.getElementById(`ram-chart-${hostId}`);
+        const netCanvas = document.getElementById(`net-chart-${hostId}`);
+
+        if (!cpuCanvas || !ramCanvas || !netCanvas) {
+            logger.warn(`Charts not found for host ${hostId}`);
+            return;
+        }
+
+        // Destroy existing charts if they exist
+        const existing = hostMetricsCharts.get(hostId);
+        if (existing) {
+            existing.cpu?.destroy();
+            existing.ram?.destroy();
+            existing.net?.destroy();
+        }
+
+        // Create charts with different colors
+        const cpuChart = createSparkline(cpuCanvas, '#3b82f6', HOST_CHART_DATA_POINTS); // blue
+        const ramChart = createSparkline(ramCanvas, '#10b981', HOST_CHART_DATA_POINTS); // green
+        const netChart = createSparkline(netCanvas, '#8b5cf6', HOST_CHART_DATA_POINTS); // purple
+
+        hostMetricsCharts.set(hostId, {
+            cpu: cpuChart,
+            ram: ramChart,
+            net: netChart
+        });
+
+        // Initialize network history
+        networkHistory.set(hostId, {
+            lastRx: 0,
+            lastTx: 0,
+            lastTimestamp: 0
+        });
+
+        logger.debug(`Created metrics charts for host ${hostId}`);
+
+        // Process any pending updates
+        const pending = pendingHostUpdates.get(hostId);
+        if (pending) {
+            updateHostMetrics(hostId, pending);
+            pendingHostUpdates.delete(hostId);
+        }
+    }, CHART_POLL_INTERVAL);
+
+    // Timeout after configured duration
+    setTimeout(() => clearInterval(waitForChart), CHART_LOAD_TIMEOUT);
+}
+
+/**
+ * Update host metrics charts from WebSocket data
+ * @param {string} hostId - Host ID
+ * @param {object} metrics - Metrics data from WebSocket
+ */
+function updateHostMetrics(hostId, metrics) {
+    const charts = hostMetricsCharts.get(hostId);
+    if (!charts) {
+        // Charts not created yet - store this update to apply when ready
+        pendingHostUpdates.set(hostId, metrics);
+        return;
+    }
+
+    // Update CPU chart
+    if (charts.cpu && metrics.cpu_percent !== undefined) {
+        updateSparkline(charts.cpu, metrics.cpu_percent);
+    }
+
+    // Update RAM chart
+    if (charts.ram && metrics.memory_percent !== undefined) {
+        updateSparkline(charts.ram, metrics.memory_percent);
+    }
+
+    // Calculate network rate (bytes/sec)
+    const history = networkHistory.get(hostId);
+    if (history && metrics.network_rx_bytes !== undefined && metrics.network_tx_bytes !== undefined) {
+        const now = Date.now();
+        if (history.lastTimestamp > 0) {
+            const timeDelta = (now - history.lastTimestamp) / 1000; // seconds
+            if (timeDelta > 0) {
+                const rxDelta = metrics.network_rx_bytes - history.lastRx;
+                const txDelta = metrics.network_tx_bytes - history.lastTx;
+                const totalRate = (rxDelta + txDelta) / timeDelta; // bytes/sec
+
+                // Convert to percentage (scale to 100, assuming 1 Gbps = 125 MB/s as max)
+                const netPercent = Math.min((totalRate / (125 * 1024 * 1024)) * 100, 100);
+
+                if (charts.net) {
+                    updateSparkline(charts.net, netPercent);
+                }
+
+                // Update network value display
+                const netValue = document.getElementById(`net-value-${hostId}`);
+                if (netValue) {
+                    netValue.textContent = formatBytes(totalRate) + '/s';
+                }
+            }
+        }
+
+        // Update history
+        history.lastRx = metrics.network_rx_bytes;
+        history.lastTx = metrics.network_tx_bytes;
+        history.lastTimestamp = now;
+    }
+
+    // Update text values
+    const cpuValue = document.getElementById(`cpu-value-${hostId}`);
+    const ramValue = document.getElementById(`ram-value-${hostId}`);
+
+    if (cpuValue && metrics.cpu_percent !== undefined) {
+        cpuValue.textContent = `${metrics.cpu_percent}%`;
+    }
+    if (ramValue && metrics.memory_percent !== undefined) {
+        ramValue.textContent = `${metrics.memory_percent}%`;
+    }
+}
+
+/**
+ * Cleanup metrics for a removed host
+ */
+function removeHostMetrics(hostId) {
+    const charts = hostMetricsCharts.get(hostId);
+    if (charts) {
+        // Destroy charts
+        if (charts.cpu) charts.cpu.destroy();
+        if (charts.ram) charts.ram.destroy();
+        if (charts.net) charts.net.destroy();
+
+        hostMetricsCharts.delete(hostId);
+    }
+
+    networkHistory.delete(hostId);
+    pendingHostUpdates.delete(hostId);
+}
+
+// Container Sparklines Management
+const containerSparklineCharts = new Map(); // "hostId-containerId" -> { cpu: Chart, ram: Chart, net: Chart }
+const containerNetworkHistory = new Map(); // Track previous network values for rate calculation
+const containerChartsReady = new Map(); // Track Promise resolvers for when charts are ready
+const pendingUpdates = new Map(); // Queue updates that arrive before charts are ready
+
+/**
+ * Remove container metrics and cleanup resources
+ */
+function removeContainerMetrics(hostId, containerId) {
+    const key = `${hostId}-${containerId}`;
+    const charts = containerSparklineCharts.get(key);
+
+    if (charts) {
+        // Destroy charts
+        if (charts.cpu) charts.cpu.destroy();
+        if (charts.ram) charts.ram.destroy();
+        if (charts.net) charts.net.destroy();
+
+        containerSparklineCharts.delete(key);
+    }
+
+    // Remove network history
+    containerNetworkHistory.delete(key);
+
+    // Remove ready promise
+    containerChartsReady.delete(key);
+
+    // Remove pending updates
+    pendingUpdates.delete(key);
+}
+
+// Export for use in other modules
+window.removeContainerMetrics = removeContainerMetrics;
+
+/**
+ * Create sparkline charts for a container
+ * Returns a Promise that resolves when charts are created
+ */
+function createContainerSparklines(hostId, containerId) {
+    const key = `${hostId}-${containerId}`;
+
+    // Create a Promise that will resolve when charts are ready
+    const readyPromise = new Promise((resolve) => {
+        // Wait for Chart.js to be loaded
+        const waitForChart = setInterval(() => {
+            if (typeof Chart === 'undefined') {
+                return; // Chart.js not loaded yet
+            }
+
+            clearInterval(waitForChart);
+
+            const cpuCanvas = document.getElementById(`container-cpu-${key}`);
+            const ramCanvas = document.getElementById(`container-ram-${key}`);
+            const netCanvas = document.getElementById(`container-net-${key}`);
+
+            if (!cpuCanvas || !ramCanvas || !netCanvas) {
+                resolve(false); // Elements not found
+                return;
+            }
+
+            // Destroy existing charts if they exist
+            const existing = containerSparklineCharts.get(key);
+            if (existing) {
+                existing.cpu?.destroy();
+                existing.ram?.destroy();
+                existing.net?.destroy();
+            }
+
+            // Create mini sparklines
+            const cpuChart = createSparkline(cpuCanvas, '#3b82f6', CONTAINER_CHART_DATA_POINTS); // blue
+            const ramChart = createSparkline(ramCanvas, '#10b981', CONTAINER_CHART_DATA_POINTS); // green
+            const netChart = createSparkline(netCanvas, '#a855f7', CONTAINER_CHART_DATA_POINTS); // purple
+
+            containerSparklineCharts.set(key, {
+                cpu: cpuChart,
+                ram: ramChart,
+                net: netChart
+            });
+
+            resolve(true); // Charts created successfully
+
+            // Process any pending updates
+            const pending = pendingUpdates.get(key);
+            if (pending) {
+                updateContainerSparklines(hostId, containerId, pending);
+                pendingUpdates.delete(key);
+            }
+        }, CHART_POLL_INTERVAL);
+
+        // Timeout after configured duration
+        setTimeout(() => {
+            clearInterval(waitForChart);
+            resolve(false);
+        }, CHART_LOAD_TIMEOUT);
+    });
+
+    containerChartsReady.set(key, readyPromise);
+    return readyPromise;
+}
+
+/**
+ * Update container sparklines from container data
+ * If charts aren't ready yet, queue the update
+ */
+function updateContainerSparklines(hostId, containerId, containerData) {
+    const key = `${hostId}-${containerId}`;
+    const charts = containerSparklineCharts.get(key);
+
+    if (!charts) {
+        // Charts not created yet - store this update to apply when ready
+        pendingUpdates.set(key, containerData);
+        return;
+    }
+
+    // Update CPU sparkline
+    if (charts.cpu && containerData.cpu_percent !== undefined && containerData.cpu_percent !== null) {
+        updateSparkline(charts.cpu, containerData.cpu_percent);
+
+        // Update CPU text value
+        const cpuValueEl = document.querySelector(`#container-cpu-${key}`).closest('.container-stats').querySelector('.container-stats-values > div:nth-child(1)');
+        if (cpuValueEl) {
+            cpuValueEl.textContent = `CPU ${containerData.cpu_percent.toFixed(1)}%`;
+        }
+    }
+
+    // Update RAM sparkline (convert bytes to percentage for visualization)
+    if (charts.ram && containerData.memory_usage !== undefined && containerData.memory_usage !== null && containerData.memory_limit !== undefined && containerData.memory_limit > 0) {
+        const ramPercent = (containerData.memory_usage / containerData.memory_limit) * 100;
+        updateSparkline(charts.ram, ramPercent);
+
+        // Update RAM text value
+        const ramValueEl = document.querySelector(`#container-ram-${key}`).closest('.container-stats').querySelector('.container-stats-values > div:nth-child(2)');
+        if (ramValueEl) {
+            ramValueEl.textContent = `RAM ${formatBytes(containerData.memory_usage)}`;
+        }
+    }
+
+    // Update Network sparkline (calculate rate from cumulative values)
+    if (charts.net && containerData.network_tx !== undefined && containerData.network_rx !== undefined) {
+        const now = Date.now();
+        const history = containerNetworkHistory.get(key);
+
+        if (history) {
+            const timeDelta = (now - history.timestamp) / 1000; // seconds
+            if (timeDelta >= 1) {
+                const txRate = (containerData.network_tx - history.tx) / timeDelta;
+                const rxRate = (containerData.network_rx - history.rx) / timeDelta;
+                const totalRate = Math.max(0, txRate + rxRate);
+
+                updateSparkline(charts.net, totalRate / 1024); // Convert to KB for better visualization
+
+                // Update text value
+                const valueEl = document.getElementById(`container-net-value-${key}`);
+                if (valueEl) {
+                    valueEl.textContent = `NET ${formatBytes(totalRate)}/s`;
+                }
+
+                // Update history
+                containerNetworkHistory.set(key, {
+                    tx: containerData.network_tx,
+                    rx: containerData.network_rx,
+                    timestamp: now
+                });
+            }
+        } else {
+            // Initialize history
+            containerNetworkHistory.set(key, {
+                tx: containerData.network_tx,
+                rx: containerData.network_rx,
+                timestamp: now
+            });
+        }
+    }
+}
+
+/**
+ * Cleanup stale container metrics
+ * Call this periodically to remove metrics for containers that no longer exist
+ */
+function cleanupStaleContainerMetrics() {
+    const currentContainers = new Set();
+
+    // Collect all currently visible containers
+    document.querySelectorAll('.container-item').forEach(item => {
+        const cpuCanvas = item.querySelector('[id^="container-cpu-"]');
+        if (cpuCanvas) {
+            const key = cpuCanvas.id.replace('container-cpu-', '');
+            currentContainers.add(key);
+        }
+    });
+
+    // Remove metrics for containers that no longer exist
+    for (const key of containerSparklineCharts.keys()) {
+        if (!currentContainers.has(key)) {
+            const [hostId, containerId] = key.split('-');
+            removeContainerMetrics(hostId, containerId);
+        }
+    }
+
+    // Also cleanup network history for containers that no longer exist
+    for (const key of containerNetworkHistory.keys()) {
+        if (!currentContainers.has(key)) {
+            containerNetworkHistory.delete(key);
+        }
+    }
+}
+
+// Run cleanup periodically
+const metricsCleanupInterval = setInterval(cleanupStaleContainerMetrics, METRICS_CLEANUP_INTERVAL);
+
+// Stop cleanup when page is unloaded
+window.addEventListener('beforeunload', () => {
+    clearInterval(metricsCleanupInterval);
+});
diff --git a/dockmon/src/js/notifications.js b/dockmon/src/js/notifications.js
new file mode 100644
index 0000000..858995d
--- /dev/null
+++ b/dockmon/src/js/notifications.js
@@ -0,0 +1,728 @@
+async function populateNotificationChannels() {
+    try {
+        const response = await fetch(`${API_BASE}/api/notifications/channels`, {
+            credentials: 'include'
+        });
+        const channels = await response.json();
+
+        const channelsSection = document.getElementById('notificationChannelsSection');
+
+        if (channels && channels.length > 0) {
+            // Show available channels as checkboxes
+            let channelsHtml = '<div class="checkbox-group">';
+            channels.forEach(channel => {
+                channelsHtml += `
+                    <label class="checkbox-item">
+                        <input type="checkbox" name="channels" value="${channel.id}" data-channel-id="${channel.id}">
+                        ${channel.name}
+                    </label>
+                `;
+            });
+            channelsHtml += '</div>';
+
+            channelsSection.innerHTML = channelsHtml;
+        } else {
+            // No channels configured yet
+            channelsSection.innerHTML = `
+                <p style="color: var(--text-tertiary); font-size: 14px; margin-bottom: 15px;">
+                    No notification channels configured yet. Set up Discord, Telegram, Pushover, Gotify, SMTP, or Slack to receive alerts.
+                </p>
+                <button type="button" class="btn btn-secondary" onclick="openNotificationSettings()">
+                    Configure Channels
+                </button>
+            `;
+        }
+    } catch (error) {
+        logger.error('Error fetching notification channels:', error);
+        const channelsSection = document.getElementById('notificationChannelsSection');
+        channelsSection.innerHTML = `
+            <p style="color: var(--text-tertiary); font-size: 14px; margin-bottom: 15px;">
+                Configure notification channels first in Settings to enable alerts.
+            </p>
+            <button type="button" class="btn btn-secondary" onclick="openNotificationSettings()">
+                Configure Channels
+            </button>
+        `;
+    }
+}
+
+let notificationChannels = [];
+let templateVariables = {};
+
+async function openNotificationSettings() {
+    try {
+        await loadNotificationChannels();
+        await loadNotificationTemplate();
+        await loadTemplateVariables();
+        await fetchSettings(); // Load settings including blackout windows
+        document.getElementById('notificationModal').classList.add('active');
+    } catch (error) {
+        logger.error('Error opening notification settings:', error);
+        showToast('Failed to open notification settings', 'error');
+    }
+}
+
+function switchNotificationTab(tab) {
+    const channelsTab = document.getElementById('channelsTab');
+    const templateTab = document.getElementById('templateTab');
+    const blackoutTab = document.getElementById('blackoutTab');
+    const channelsContent = document.getElementById('channelsTabContent');
+    const templateContent = document.getElementById('templateTabContent');
+    const blackoutContent = document.getElementById('blackoutTabContent');
+
+    // Reset all tabs
+    [channelsTab, templateTab, blackoutTab].forEach(btn => {
+        btn.classList.remove('active');
+        btn.style.borderBottom = 'none';
+        btn.style.color = 'var(--text-secondary)';
+    });
+
+    // Hide all content
+    [channelsContent, templateContent, blackoutContent].forEach(content => {
+        if (content) content.style.display = 'none';
+    });
+
+    // Show selected tab
+    if (tab === 'channels') {
+        channelsTab.classList.add('active');
+        channelsTab.style.borderBottom = '2px solid var(--primary)';
+        channelsTab.style.color = 'var(--primary)';
+        channelsContent.style.display = 'block';
+    } else if (tab === 'template') {
+        templateTab.classList.add('active');
+        templateTab.style.borderBottom = '2px solid var(--primary)';
+        templateTab.style.color = 'var(--primary)';
+        templateContent.style.display = 'block';
+    } else if (tab === 'blackout') {
+        blackoutTab.classList.add('active');
+        blackoutTab.style.borderBottom = '2px solid var(--primary)';
+        blackoutTab.style.color = 'var(--primary)';
+        blackoutContent.style.display = 'block';
+        // Load blackout status and show timezone info when switching to this tab
+        renderBlackoutWindows();
+        updateBlackoutStatus();
+        updateTimezoneInfo();
+    }
+}
+
+function updateTimezoneInfo() {
+    const offsetElement = document.getElementById('localTimezoneOffset');
+    if (offsetElement) {
+        const offsetMinutes = new Date().getTimezoneOffset();
+        const offsetHours = Math.abs(offsetMinutes / 60);
+        const offsetSign = offsetMinutes > 0 ? '-' : '+';
+        offsetElement.textContent = `UTC${offsetSign}${offsetHours}`;
+    }
+}
+
+async function loadNotificationChannels() {
+    try {
+        const response = await fetch(`${API_BASE}/api/notifications/channels`, {
+            credentials: 'include'
+        });
+        notificationChannels = await response.json();
+        renderNotificationChannels();
+    } catch (error) {
+        logger.error('Error loading notification channels:', error);
+        notificationChannels = [];
+    }
+}
+
+async function loadNotificationTemplate() {
+    try {
+        const response = await fetch(`${API_BASE}/api/settings`, {
+            credentials: 'include'
+        });
+        const settings = await response.json();
+        const template = settings.alert_template || '';
+        document.getElementById('alertTemplate').value = template;
+    } catch (error) {
+        logger.error('Error loading template:', error);
+    }
+}
+
+async function loadTemplateVariables() {
+    try {
+        const response = await fetch(`${API_BASE}/api/notifications/template-variables`, {
+            credentials: 'include'
+        });
+        templateVariables = await response.json();
+    } catch (error) {
+        logger.error('Error loading template variables:', error);
+    }
+}
+
+function renderNotificationChannels() {
+    const container = document.getElementById('notificationChannelsList');
+    if (!container) return;
+
+    if (notificationChannels.length === 0) {
+        container.innerHTML = `
+            <div style="text-align: center; padding: var(--spacing-lg); color: var(--text-secondary);">
+                No notification channels configured yet. Click "Add Channel" to get started.
+            </div>
+        `;
+        return;
+    }
+
+    container.innerHTML = notificationChannels.map((channel, index) => `
+        <div class="notification-channel-card" style="padding: var(--spacing-md); margin-bottom: var(--spacing-md); background: var(--surface); border: 1px solid var(--surface-light); border-radius: var(--radius-md);">
+            <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: var(--spacing-md);">
+                <h4 style="color: var(--text-primary); margin: 0;">${channel.name || 'Unnamed Channel'}</h4>
+                <div style="display: flex; gap: var(--spacing-sm);">
+                    <button type="button" class="btn btn-small ${channel.enabled ? 'btn-success' : 'btn-secondary'}" onclick="toggleChannelStatus(${index})">
+                        ${channel.enabled ? '✓ Enabled' : 'Disabled'}
+                    </button>
+                    <button type="button" class="btn-icon" onclick="removeChannel(${index})">
+                        <i data-lucide="trash-2"></i>
+                    </button>
+                </div>
+            </div>
+            <div style="display: grid; gap: var(--spacing-sm);">
+                <label class="form-label">Channel Type</label>
+                ${channel.id ?
+                    `<input type="text" class="form-input" value="${channel.type.charAt(0).toUpperCase() + channel.type.slice(1)}" disabled style="background: var(--surface-light); cursor: not-allowed;">`
+                    :
+                    `<select class="form-input" onchange="updateChannelType(${index}, this.value)">
+                        ${getAvailableChannelTypes(channel.type).map(type => `<option value="${type}" ${channel.type === type ? 'selected' : ''}>${type.charAt(0).toUpperCase() + type.slice(1)}</option>`).join('')}
+                    </select>`
+                }
+                ${renderChannelConfig(channel, index)}
+            </div>
+            <div style="display: flex; gap: var(--spacing-sm); margin-top: var(--spacing-md);">
+                <button type="button" class="btn btn-primary btn-small" onclick="saveChannel(${index})">
+                    <i data-lucide="save"></i> Save Channel
+                </button>
+                <button type="button" class="btn btn-secondary btn-small" onclick="testChannel(${index})">
+                    <i data-lucide="bell"></i> Test Channel
+                </button>
+            </div>
+        </div>
+    `).join('');
+    initIcons();
+}
+
+function renderChannelConfig(channel, index) {
+    switch(channel.type) {
+        case 'discord':
+            return `
+                <label class="form-label">Webhook URL</label>
+                <input type="text" class="form-input" placeholder="https://discord.com/api/webhooks/..."
+                       value="${channel.config?.webhook_url || ''}"
+                       onchange="updateChannelConfig(${index}, 'webhook_url', this.value)">
+            `;
+        case 'slack':
+            return `
+                <label class="form-label">Webhook URL</label>
+                <input type="text" class="form-input" placeholder="https://hooks.slack.com/services/..."
+                       value="${channel.config?.webhook_url || ''}"
+                       onchange="updateChannelConfig(${index}, 'webhook_url', this.value)">
+            `;
+        case 'telegram':
+            return `
+                <label class="form-label">Bot Token</label>
+                <input type="text" class="form-input" placeholder="Bot token from @BotFather"
+                       value="${channel.config?.bot_token || ''}"
+                       onchange="updateChannelConfig(${index}, 'bot_token', this.value)">
+                <label class="form-label">Chat ID</label>
+                <input type="text" class="form-input" placeholder="Chat ID"
+                       value="${channel.config?.chat_id || ''}"
+                       onchange="updateChannelConfig(${index}, 'chat_id', this.value)">
+            `;
+        case 'pushover':
+            return `
+                <label class="form-label">App Token</label>
+                <input type="text" class="form-input" placeholder="Pushover app token"
+                       value="${channel.config?.app_token || ''}"
+                       onchange="updateChannelConfig(${index}, 'app_token', this.value)">
+                <label class="form-label">User Key</label>
+                <input type="text" class="form-input" placeholder="User key"
+                       value="${channel.config?.user_key || ''}"
+                       onchange="updateChannelConfig(${index}, 'user_key', this.value)">
+            `;
+        case 'gotify':
+            return `
+                <label class="form-label">Server URL</label>
+                <input type="url" class="form-input" placeholder="http://gotify.example.com"
+                       value="${channel.config?.server_url || ''}"
+                       onchange="updateChannelConfig(${index}, 'server_url', this.value)">
+                <small style="color: var(--text-tertiary); display: block; margin-top: 4px; margin-bottom: 12px;">
+                    Your Gotify server URL (e.g., http://192.168.1.100:8080)
+                </small>
+                <label class="form-label">App Token</label>
+                <input type="text" class="form-input" placeholder="AaBbCcDd123456"
+                       value="${channel.config?.app_token || ''}"
+                       onchange="updateChannelConfig(${index}, 'app_token', this.value)">
+                <small style="color: var(--text-tertiary); display: block; margin-top: 4px;">
+                    Create an app in Gotify and copy its token
+                </small>
+            `;
+        case 'smtp':
+            return `
+                <label class="form-label">SMTP Server</label>
+                <input type="text" class="form-input" placeholder="smtp.gmail.com"
+                       value="${channel.config?.smtp_host || ''}"
+                       onchange="updateChannelConfig(${index}, 'smtp_host', this.value)">
+                <label class="form-label">SMTP Port</label>
+                <input type="number" class="form-input" placeholder="587"
+                       value="${channel.config?.smtp_port || ''}"
+                       onchange="updateChannelConfig(${index}, 'smtp_port', this.value)">
+                <label class="form-label">Username</label>
+                <input type="text" class="form-input" placeholder="user@example.com"
+                       value="${channel.config?.smtp_user || ''}"
+                       onchange="updateChannelConfig(${index}, 'smtp_user', this.value)">
+                <label class="form-label">Password</label>
+                <input type="password" class="form-input" placeholder="••••••••"
+                       value="${channel.config?.smtp_password || ''}"
+                       onchange="updateChannelConfig(${index}, 'smtp_password', this.value)">
+                <label class="form-label">From Email</label>
+                <input type="email" class="form-input" placeholder="dockmon@example.com"
+                       value="${channel.config?.from_email || ''}"
+                       onchange="updateChannelConfig(${index}, 'from_email', this.value)">
+                <label class="form-label">To Email</label>
+                <input type="email" class="form-input" placeholder="alerts@example.com"
+                       value="${channel.config?.to_email || ''}"
+                       onchange="updateChannelConfig(${index}, 'to_email', this.value)">
+                <label class="form-label" style="display: flex; align-items: center; margin-top: 12px;">
+                    <input type="checkbox" style="margin-right: 8px;"
+                           ${channel.config?.use_tls !== false ? 'checked' : ''}
+                           onchange="updateChannelConfig(${index}, 'use_tls', this.checked)">
+                    Use TLS/STARTTLS
+                </label>
+                <small style="color: var(--text-tertiary); display: block; margin-top: 4px;">
+                    Enable for ports 587 (STARTTLS) or 465 (SSL/TLS). Disable for port 25.
+                </small>
+            `;
+        default:
+            return '';
+    }
+}
+
+function addNotificationChannel() {
+    // Get available channel types (those not already in use)
+    const usedTypes = notificationChannels.map(ch => ch.type);
+    const availableTypes = ['discord', 'slack', 'telegram', 'pushover', 'gotify', 'smtp'].filter(type => !usedTypes.includes(type));
+
+    if (availableTypes.length === 0) {
+        showToast('❌ All notification channel types are already configured');
+        return;
+    }
+
+    // Use the first available type
+    const channelType = availableTypes[0];
+    const channelName = channelType.charAt(0).toUpperCase() + channelType.slice(1);
+
+    const newChannel = {
+        name: channelName,
+        type: channelType,
+        config: {},
+        enabled: true,
+        isNew: true
+    };
+    notificationChannels.push(newChannel);
+    renderNotificationChannels();
+
+    // Scroll to the newly added channel
+    setTimeout(() => {
+        const cards = document.querySelectorAll('.notification-channel-card');
+        if (cards.length > 0) {
+            const lastCard = cards[cards.length - 1];
+            lastCard.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+        }
+    }, 100);
+}
+
+async function removeChannel(index) {
+    const channel = notificationChannels[index];
+
+    // If channel doesn't exist in backend, just remove from local array
+    if (!channel.id) {
+        notificationChannels.splice(index, 1);
+        renderNotificationChannels();
+        return;
+    }
+
+    // Check for dependent alerts first
+    try {
+        const dependentAlerts = await checkDependentAlerts(channel.id);
+
+        let message = `Are you sure you want to delete the notification channel <strong>"${channel.name}"</strong>?<br><br>`;
+
+        message += `Any alerts that only use this notification channel will also be deleted.<br><br>`;
+
+        if (dependentAlerts.length > 0) {
+            message += `⚠️ <strong>Warning:</strong> The following alert rules will be deleted:<br>`;
+            message += '<ul style="margin: var(--spacing-sm) 0; padding-left: var(--spacing-lg);">';
+            dependentAlerts.forEach(alert => {
+                message += `<li>${alert.name}</li>`;
+            });
+            message += '</ul>';
+        }
+
+        message += `<strong>This action cannot be undone.</strong>`;
+
+        showConfirmation('Delete Notification Channel', message, 'Delete Channel', async () => {
+            try {
+                // Delete from backend
+                const response = await fetch(`${API_BASE}/api/notifications/channels/${channel.id}`, {
+                    method: 'DELETE',
+                    credentials: 'include'
+                });
+
+                if (!response.ok) {
+                    throw new Error('Failed to delete channel');
+                }
+
+                const result = await response.json();
+                if (result.deleted_alerts && result.deleted_alerts.length > 0) {
+                    showToast(`✅ Channel deleted (${result.deleted_alerts.length} alert(s) also removed)`);
+                } else {
+                    showToast('✅ Channel deleted');
+                }
+
+                // Remove from local array and re-render
+                notificationChannels.splice(index, 1);
+                renderNotificationChannels();
+
+                // Refresh alert modal if open
+                await populateNotificationChannels();
+
+                // Refresh alert rules list if it's currently displayed
+                await fetchAlertRules();
+                renderAlertRules();
+            } catch (error) {
+                logger.error('Error deleting channel:', error);
+                showToast('❌ Failed to delete channel');
+            }
+        });
+    } catch (error) {
+        logger.error('Error checking dependent alerts:', error);
+        showToast('❌ Failed to check dependent alerts');
+    }
+}
+
+function toggleChannelStatus(index) {
+    notificationChannels[index].enabled = !notificationChannels[index].enabled;
+    renderNotificationChannels();
+}
+
+function getAvailableChannelTypes(currentType) {
+    // Get all types that are either the current type or not already in use
+    const usedTypes = notificationChannels.map(ch => ch.type);
+    const allTypes = ['discord', 'slack', 'telegram', 'pushover', 'gotify', 'smtp'];
+    return allTypes.filter(type => type === currentType || !usedTypes.includes(type));
+}
+
+function updateChannelType(index, type) {
+    // Update the channel name to match the type
+    notificationChannels[index].name = type.charAt(0).toUpperCase() + type.slice(1);
+    notificationChannels[index].type = type;
+    notificationChannels[index].config = {};
+    renderNotificationChannels();
+}
+
+function updateChannelConfig(index, key, value) {
+    if (!notificationChannels[index].config) {
+        notificationChannels[index].config = {};
+    }
+    notificationChannels[index].config[key] = value;
+}
+
+async function saveAllChannels() {
+    try {
+        // Save each channel
+        for (const channel of notificationChannels) {
+            if (channel.isNew) {
+                // Create new channel
+                await fetch(`${API_BASE}/api/notifications/channels`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    credentials: 'include',
+                    body: JSON.stringify(channel)
+                });
+            } else if (channel.id) {
+                // Update existing channel
+                await fetch(`${API_BASE}/api/notifications/channels/${channel.id}`, {
+                    method: 'PUT',
+                    headers: { 'Content-Type': 'application/json' },
+                    credentials: 'include',
+                    body: JSON.stringify(channel)
+                });
+            }
+        }
+        showToast('✅ Notification channels saved successfully!');
+        await loadNotificationChannels();
+
+        // Refresh the alert modal's channel list if it's open
+        await populateNotificationChannels();
+    } catch (error) {
+        logger.error('Error saving channels:', error);
+        showToast('❌ Failed to save notification channels');
+    }
+}
+
+function validateChannelConfig(channel) {
+    // Validate based on channel type
+    const config = channel.config || {};
+
+    switch (channel.type) {
+        case 'discord':
+        case 'slack':
+            if (!config.webhook_url || !config.webhook_url.trim()) {
+                return { valid: false, error: 'Webhook URL is required' };
+            }
+            if (!config.webhook_url.startsWith('https://')) {
+                return { valid: false, error: 'Webhook URL must start with https://' };
+            }
+            break;
+
+        case 'telegram':
+            if (!config.bot_token || !config.bot_token.trim()) {
+                return { valid: false, error: 'Bot token is required' };
+            }
+            if (!config.chat_id || !config.chat_id.trim()) {
+                return { valid: false, error: 'Chat ID is required' };
+            }
+            break;
+
+        case 'pushover':
+            if (!config.app_token || !config.app_token.trim()) {
+                return { valid: false, error: 'App token is required' };
+            }
+            if (!config.user_key || !config.user_key.trim()) {
+                return { valid: false, error: 'User key is required' };
+            }
+            break;
+
+        case 'gotify':
+            if (!config.server_url || !config.server_url.trim()) {
+                return { valid: false, error: 'Gotify server URL is required' };
+            }
+            if (!config.server_url.startsWith('http://') && !config.server_url.startsWith('https://')) {
+                return { valid: false, error: 'Gotify server URL must start with http:// or https://' };
+            }
+            if (!config.app_token || !config.app_token.trim()) {
+                return { valid: false, error: 'Gotify app token is required' };
+            }
+            break;
+
+        case 'smtp':
+            if (!config.smtp_host || !config.smtp_host.trim()) {
+                return { valid: false, error: 'SMTP server is required' };
+            }
+            const port = parseInt(config.smtp_port);
+            if (isNaN(port) || port < 1 || port > 65535) {
+                return { valid: false, error: 'SMTP port must be between 1-65535' };
+            }
+            if (!config.smtp_user || !config.smtp_user.trim()) {
+                return { valid: false, error: 'SMTP username is required' };
+            }
+            if (!config.smtp_password || !config.smtp_password.trim()) {
+                return { valid: false, error: 'SMTP password is required' };
+            }
+            if (!config.from_email || !config.from_email.trim()) {
+                return { valid: false, error: 'From email is required' };
+            }
+            if (!config.to_email || !config.to_email.trim()) {
+                return { valid: false, error: 'To email is required' };
+            }
+            // Basic email validation
+            const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+            if (!emailRegex.test(config.from_email)) {
+                return { valid: false, error: 'Invalid from email format' };
+            }
+            if (!emailRegex.test(config.to_email)) {
+                return { valid: false, error: 'Invalid to email format' };
+            }
+            break;
+    }
+
+    return { valid: true };
+}
+
+async function saveChannel(index) {
+    try {
+        const channel = notificationChannels[index];
+
+        // Validate channel configuration before saving
+        const validation = validateChannelConfig(channel);
+        if (!validation.valid) {
+            showToast(`❌ ${validation.error}`);
+            return;
+        }
+
+        if (channel.isNew) {
+            // Create new channel
+            const response = await fetch(`${API_BASE}/api/notifications/channels`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify(channel)
+            });
+
+            if (response.ok) {
+                const savedChannel = await response.json();
+                // Update the channel with the returned ID and remove isNew flag
+                notificationChannels[index] = { ...savedChannel, isNew: false };
+                showToast('✅ Channel saved successfully!');
+            } else {
+                const errorData = await response.json().catch(() => ({}));
+                let errorMsg = 'Failed to save channel';
+
+                if (errorData.detail) {
+                    if (Array.isArray(errorData.detail)) {
+                        // Pydantic validation errors are arrays
+                        errorMsg = errorData.detail.map(err => err.msg || JSON.stringify(err)).join(', ');
+                    } else if (typeof errorData.detail === 'string') {
+                        errorMsg = errorData.detail;
+                    } else {
+                        errorMsg = JSON.stringify(errorData.detail);
+                    }
+                }
+
+                throw new Error(errorMsg);
+            }
+        } else if (channel.id) {
+            // Update existing channel
+            const response = await fetch(`${API_BASE}/api/notifications/channels/${channel.id}`, {
+                method: 'PUT',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify(channel)
+            });
+
+            if (response.ok) {
+                showToast('✅ Channel updated successfully!');
+            } else {
+                throw new Error('Failed to update channel');
+            }
+        }
+
+        // Preserve unsaved channels (those with isNew flag)
+        const unsavedChannels = notificationChannels.filter(ch => ch.isNew && ch !== channel);
+
+        // Refresh the channels list from backend
+        await loadNotificationChannels();
+
+        // Re-add the unsaved channels
+        notificationChannels.push(...unsavedChannels);
+        renderNotificationChannels();
+
+        // Refresh the alert modal's channel list if it's open
+        await populateNotificationChannels();
+    } catch (error) {
+        logger.error('Error saving channel:', error);
+        showToast(`❌ ${error.message || 'Failed to save channel'}`);
+    }
+}
+
+async function testChannel(index) {
+    const channel = notificationChannels[index];
+    if (!channel.id) {
+        showToast('❌ Please save the channel first');
+        return;
+    }
+
+    try {
+        const response = await fetch(`${API_BASE}/api/notifications/channels/${channel.id}/test`, {
+            method: 'POST',
+            credentials: 'include'
+        });
+
+        if (response.ok) {
+            showToast('✅ Test notification sent!');
+        } else {
+            showToast('❌ Failed to send test notification');
+        }
+    } catch (error) {
+        logger.error('Error testing channel:', error);
+        showToast('❌ Failed to test channel');
+    }
+}
+
+function applyTemplateExample(exampleKey) {
+    if (!exampleKey || !templateVariables.examples) return;
+
+    const examples = {
+        'default': templateVariables.default_template,
+        'simple': 'Alert: {CONTAINER_NAME} on {HOST_NAME} changed from {OLD_STATE} to {NEW_STATE}',
+        'minimal': '{CONTAINER_NAME}: {NEW_STATE} at {TIME}',
+        'emoji': '🔴 {CONTAINER_NAME} is {NEW_STATE}\\n📍 Host: {HOST_NAME}\\n🕐 Time: {TIMESTAMP}'
+    };
+
+    const template = examples[exampleKey];
+    if (template) {
+        document.getElementById('alertTemplate').value = template;
+    }
+}
+
+async function saveNotificationTemplate() {
+    try {
+        const template = document.getElementById('alertTemplate').value;
+
+        // Get current settings
+        const response = await fetch(`${API_BASE}/api/settings`, {
+            credentials: 'include'
+        });
+        const settings = await response.json();
+
+        // Update with new template
+        settings.alert_template = template;
+
+        const updateResponse = await fetch(`${API_BASE}/api/settings`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            credentials: 'include',
+            body: JSON.stringify(settings)
+        });
+
+        if (updateResponse.ok) {
+            showToast('✅ Notification template saved!');
+        } else {
+            showToast('❌ Failed to save template');
+        }
+    } catch (error) {
+        logger.error('Error saving template:', error);
+        showToast('❌ Failed to save notification template');
+    }
+}
+
+async function loadNotificationSettings() {
+    try {
+        const response = await fetch(`${API_BASE}/api/notifications/channels`, {
+            credentials: 'include'
+        });
+        const channels = await response.json();
+
+        // Clear existing values
+        document.querySelectorAll('#notificationModal .form-input').forEach(input => {
+            input.value = '';
+        });
+
+        // Populate existing settings
+        channels.forEach(channel => {
+            if (channel.type === 'telegram') {
+                const tokenInput = document.querySelector('#notificationModal .form-input[placeholder*="Telegram bot token"]');
+                const chatInput = document.querySelector('#notificationModal .form-input[placeholder*="chat ID"]');
+                if (tokenInput && chatInput && channel.config) {
+                    tokenInput.value = channel.config.bot_token || '';
+                    chatInput.value = channel.config.chat_id || '';
+                }
+            } else if (channel.type === 'discord') {
+                const webhookInput = document.querySelector('#notificationModal .form-input[placeholder*="Discord webhook"]');
+                if (webhookInput && channel.config) {
+                    webhookInput.value = channel.config.webhook_url || '';
+                }
+            } else if (channel.type === 'pushover') {
+                const tokenInput = document.querySelector('#notificationModal .form-input[placeholder*="Pushover app token"]');
+                const userInput = document.querySelector('#notificationModal .form-input[placeholder*="user key"]');
+                if (tokenInput && userInput && channel.config) {
+                    tokenInput.value = channel.config.app_token || '';
+                    userInput.value = channel.config.user_key || '';
+                }
+            }
+        });
+    } catch (error) {
+        logger.error('Error loading notification settings:', error);
+    }
+}
diff --git a/dockmon/src/login.html b/dockmon/src/login.html
new file mode 100644
index 0000000..47f1f46
--- /dev/null
+++ b/dockmon/src/login.html
@@ -0,0 +1,465 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>DockMon - Login</title>
+    <style>
+        :root {
+            --primary: #0066cc;
+            --primary-dark: #0052a3;
+            --secondary: #6c757d;
+            --success: #28a745;
+            --danger: #dc3545;
+            --warning: #ffc107;
+            --info: #17a2b8;
+            --light: #f8f9fa;
+            --dark: #343a40;
+            --background: #1a1a1a;
+            --surface: #2d2d2d;
+            --surface-light: #3d3d3d;
+            --text-primary: #ffffff;
+            --text-secondary: #b3b3b3;
+            --border: #404040;
+            --spacing-xs: 0.25rem;
+            --spacing-sm: 0.5rem;
+            --spacing-md: 1rem;
+            --spacing-lg: 1.5rem;
+            --spacing-xl: 3rem;
+        }
+
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'sans-serif';
+            background: linear-gradient(135deg, var(--background) 0%, #0f1419 100%);
+            color: var(--text-primary);
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            position: relative;
+            overflow: hidden;
+        }
+
+        /* Animated background particles */
+        .background-animation {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            overflow: hidden;
+            z-index: 0;
+        }
+
+        .particle {
+            position: absolute;
+            background: rgba(0, 102, 204, 0.1);
+            border-radius: 50%;
+            animation: float 6s ease-in-out infinite;
+        }
+
+        .particle:nth-child(1) { width: 80px; height: 80px; left: 10%; animation-delay: 0s; }
+        .particle:nth-child(2) { width: 60px; height: 60px; left: 20%; animation-delay: 1s; }
+        .particle:nth-child(3) { width: 100px; height: 100px; left: 35%; animation-delay: 2s; }
+        .particle:nth-child(4) { width: 40px; height: 40px; left: 70%; animation-delay: 3s; }
+        .particle:nth-child(5) { width: 120px; height: 120px; left: 85%; animation-delay: 4s; }
+
+        @keyframes float {
+            0%, 100% { transform: translateY(0px) rotate(0deg); opacity: 0.1; }
+            50% { transform: translateY(-20px) rotate(180deg); opacity: 0.3; }
+        }
+
+        /* Login container */
+        .login-container {
+            background: var(--surface);
+            border-radius: 16px;
+            padding: var(--spacing-xl);
+            box-shadow: 0 20px 40px rgba(0, 0, 0, 0.3);
+            border: 1px solid var(--border);
+            width: 100%;
+            max-width: 400px;
+            position: relative;
+            z-index: 1;
+            backdrop-filter: blur(10px);
+        }
+
+        .login-header {
+            text-align: center;
+            margin-bottom: var(--spacing-xl);
+        }
+
+        .login-logo {
+            width: 80px;
+            height: 80px;
+            margin: 0 auto var(--spacing-lg);
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .login-logo img {
+            width: 100%;
+            height: 100%;
+            object-fit: contain;
+            filter: drop-shadow(0 8px 16px rgba(0, 102, 204, 0.3));
+        }
+
+        .login-title {
+            font-size: 28px;
+            font-weight: 700;
+            color: var(--text-primary);
+            margin-bottom: var(--spacing-sm);
+        }
+
+        .login-subtitle {
+            color: var(--text-secondary);
+            font-size: 16px;
+            margin-bottom: var(--spacing-lg);
+        }
+
+        .form-group {
+            margin-bottom: var(--spacing-lg);
+        }
+
+        .form-label {
+            display: block;
+            margin-bottom: var(--spacing-sm);
+            font-weight: 600;
+            color: var(--text-primary);
+            font-size: 14px;
+        }
+
+        .form-control {
+            width: 100%;
+            padding: var(--spacing-md);
+            background: var(--background);
+            border: 2px solid var(--border);
+            border-radius: 8px;
+            color: var(--text-primary);
+            font-size: 16px;
+            transition: all 0.3s ease;
+        }
+
+        .form-control:focus {
+            outline: none;
+            border-color: var(--primary);
+            box-shadow: 0 0 0 3px rgba(0, 102, 204, 0.1);
+        }
+
+        .form-control::placeholder {
+            color: var(--text-secondary);
+        }
+
+        .btn {
+            width: 100%;
+            padding: var(--spacing-md) var(--spacing-lg);
+            background: linear-gradient(135deg, var(--primary), var(--primary-dark));
+            color: white;
+            border: none;
+            border-radius: 8px;
+            font-size: 16px;
+            font-weight: 600;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            position: relative;
+            overflow: hidden;
+        }
+
+        .btn:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 8px 16px rgba(0, 102, 204, 0.3);
+        }
+
+        .btn:active {
+            transform: translateY(0);
+        }
+
+        .btn:disabled {
+            opacity: 0.6;
+            cursor: not-allowed;
+            transform: none;
+        }
+
+        .alert {
+            padding: var(--spacing-md);
+            border-radius: 8px;
+            margin-bottom: var(--spacing-lg);
+            font-size: 14px;
+            border: 1px solid transparent;
+        }
+
+        .alert-danger {
+            background: rgba(220, 53, 69, 0.1);
+            border-color: rgba(220, 53, 69, 0.3);
+            color: #ff6b6b;
+        }
+
+        .alert-success {
+            background: rgba(40, 167, 69, 0.1);
+            border-color: rgba(40, 167, 69, 0.3);
+            color: #51cf66;
+        }
+
+        .loading {
+            display: none;
+            text-align: center;
+            margin-top: var(--spacing-md);
+        }
+
+        .spinner {
+            width: 20px;
+            height: 20px;
+            border: 2px solid var(--border);
+            border-top: 2px solid var(--primary);
+            border-radius: 50%;
+            animation: spin 1s linear infinite;
+            display: inline-block;
+            margin-right: var(--spacing-sm);
+        }
+
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+
+        .forgot-password {
+            text-align: center;
+            margin-top: var(--spacing-lg);
+            color: var(--text-secondary);
+            font-size: 14px;
+        }
+
+        .version {
+            position: absolute;
+            bottom: var(--spacing-md);
+            left: 50%;
+            transform: translateX(-50%);
+            color: var(--text-secondary);
+            font-size: 12px;
+            z-index: 1;
+        }
+
+        /* Responsive design */
+        @media (max-width: 480px) {
+            .login-container {
+                margin: var(--spacing-md);
+                padding: var(--spacing-lg);
+            }
+
+            .login-title {
+                font-size: 24px;
+            }
+        }
+
+        /* Focus animations */
+        .form-group {
+            position: relative;
+        }
+
+        .form-control:focus + .form-label {
+            color: var(--primary);
+        }
+    </style>
+</head>
+<body>
+    <!-- Background animation -->
+    <div class="background-animation">
+        <div class="particle"></div>
+        <div class="particle"></div>
+        <div class="particle"></div>
+        <div class="particle"></div>
+        <div class="particle"></div>
+    </div>
+
+    <!-- Login container -->
+    <div class="login-container">
+        <div class="login-header">
+            <div class="login-logo">
+                <img src="images/logo.png" alt="DockMon Logo">
+            </div>
+            <h1 class="login-title">DockMon</h1>
+            <p class="login-subtitle">Docker Container Monitoring & Management</p>
+        </div>
+
+        <form id="loginForm">
+            <div id="alertContainer"></div>
+
+            <div class="form-group">
+                <label class="form-label" for="username">Username</label>
+                <input type="text" id="username" name="username" class="form-control"
+                       placeholder="Enter your username" required autocomplete="username">
+            </div>
+
+            <div class="form-group">
+                <label class="form-label" for="password">Password</label>
+                <input type="password" id="password" name="password" class="form-control"
+                       placeholder="Enter your password" required autocomplete="current-password">
+            </div>
+
+            <button type="submit" class="btn" id="loginBtn">
+                Sign In
+            </button>
+
+            <div class="loading" id="loading">
+                <span class="spinner"></span>
+                Authenticating...
+            </div>
+        </form>
+
+        <div class="forgot-password">
+            <small></small>
+        </div>
+    </div>
+
+    <div class="version">DockMon v1.1.2</div>
+
+    <script>
+        const API_BASE = '';
+
+        // DOM elements
+        const loginForm = document.getElementById('loginForm');
+        const loginBtn = document.getElementById('loginBtn');
+        const loading = document.getElementById('loading');
+        const alertContainer = document.getElementById('alertContainer');
+        const usernameInput = document.getElementById('username');
+        const passwordInput = document.getElementById('password');
+
+        // Show alert message
+        function showAlert(message, type = 'danger') {
+            alertContainer.innerHTML = `
+                <div class="alert alert-${type}">
+                    ${message}
+                </div>
+            `;
+        }
+
+        // Clear alerts
+        function clearAlert() {
+            alertContainer.innerHTML = '';
+        }
+
+        // Show loading state
+        function setLoading(isLoading) {
+            if (isLoading) {
+                loginBtn.disabled = true;
+                loginBtn.style.display = 'none';
+                loading.style.display = 'block';
+            } else {
+                loginBtn.disabled = false;
+                loginBtn.style.display = 'block';
+                loading.style.display = 'none';
+            }
+        }
+
+        // Check if already authenticated
+        async function checkAuthStatus() {
+            try {
+                const response = await fetch(`${API_BASE}/api/auth/status`, {
+                    credentials: 'include'
+                });
+
+                if (response.ok) {
+                    const data = await response.json();
+                    if (data.authenticated) {
+                        // Redirect to main dashboard
+                        window.location.href = '/';
+                        return;
+                    }
+                }
+            } catch (error) {
+                console.log('Auth check failed:', error);
+            }
+        }
+
+        // Handle login form submission
+        async function handleLogin(event) {
+            event.preventDefault();
+
+            clearAlert();
+            setLoading(true);
+
+            const username = usernameInput.value.trim();
+            const password = passwordInput.value;
+
+            if (!username || !password) {
+                showAlert('Please enter both username and password');
+                setLoading(false);
+                return;
+            }
+
+            try {
+                const response = await fetch(`${API_BASE}/api/auth/login`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    credentials: 'include',
+                    body: JSON.stringify({ username, password })
+                });
+
+                const data = await response.json();
+                console.log('Login response:', data);
+
+                if (response.ok) {
+                    // Store password change requirement in sessionStorage
+                    if (data.must_change_password || data.is_first_login) {
+                        sessionStorage.setItem('must_change_password', 'true');
+                        // Temporarily store password for auto-fill (will be cleared after use)
+                        sessionStorage.setItem('temp_current_password', password);
+                    }
+
+                    showAlert('Login successful! Redirecting...', 'success');
+                    console.log('Login successful, redirecting to dashboard in 1.5 seconds...');
+
+                    // Redirect to main dashboard after short delay
+                    setTimeout(() => {
+                        console.log('Redirecting to /');
+                        window.location.href = '/';
+                    }, 1500);
+                } else {
+                    showAlert(data.detail || 'Login failed. Please try again.');
+                    setLoading(false);
+                }
+            } catch (error) {
+                console.error('Login error:', error);
+                showAlert('Connection error. Please check if the backend is running.');
+                setLoading(false);
+            }
+        }
+
+        // Event listeners
+        loginForm.addEventListener('submit', handleLogin);
+
+        // Auto-focus username field
+        usernameInput.focus();
+
+        // Check auth status on page load
+        checkAuthStatus();
+
+        // Handle Enter key in password field
+        passwordInput.addEventListener('keypress', function(event) {
+            if (event.key === 'Enter') {
+                handleLogin(event);
+            }
+        });
+
+        // Add some visual feedback for form interactions
+        [usernameInput, passwordInput].forEach(input => {
+            input.addEventListener('focus', function() {
+                this.parentElement.style.transform = 'scale(1.02)';
+                this.parentElement.style.transition = 'transform 0.2s ease';
+            });
+
+            input.addEventListener('blur', function() {
+                this.parentElement.style.transform = 'scale(1)';
+            });
+        });
+    </script>
+</body>
+</html>
\ No newline at end of file
diff --git a/dockmon/src/lucide.min.js b/dockmon/src/lucide.min.js
new file mode 100644
index 0000000..bfb1670
--- /dev/null
+++ b/dockmon/src/lucide.min.js
@@ -0,0 +1,12 @@
+/**
+ * @license lucide v0.544.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+
+(function(a,n){typeof exports=="object"&&typeof module<"u"?n(exports):typeof define=="function"&&define.amd?define(["exports"],n):(a=typeof globalThis<"u"?globalThis:a||self,n(a.lucide={}))})(this,(function(a){"use strict";const n={xmlns:"http://www.w3.org/2000/svg",width:24,height:24,viewBox:"0 0 24 24",fill:"none",stroke:"currentColor","stroke-width":2,"stroke-linecap":"round","stroke-linejoin":"round"},la=([t,h,d])=>{const c=document.createElementNS("http://www.w3.org/2000/svg",t);return Object.keys(h).forEach(M=>{c.setAttribute(M,String(h[M]))}),d?.length&&d.forEach(M=>{const i=la(M);c.appendChild(i)}),c},ea=(t,h={})=>{const d={...n,...h};return la(["svg",d,t])},bu=t=>Array.from(t.attributes).reduce((h,d)=>(h[d.name]=d.value,h),{}),Ru=t=>typeof t=="string"?t:!t||!t.class?"":t.class&&typeof t.class=="string"?t.class.split(" "):t.class&&Array.isArray(t.class)?t.class:"",Tu=t=>t.flatMap(Ru).map(h=>h.trim()).filter(Boolean).filter((h,d,c)=>c.indexOf(h)===d).join(" "),qu=t=>t.replace(/(\w)(\w*)(_|-|\s*)/g,(h,d,c)=>d.toUpperCase()+c.toLowerCase()),ra=(t,{nameAttr:h,icons:d,attrs:c})=>{const M=t.getAttribute(h);if(M==null)return;const i=qu(M),na=d[i];if(!na)return console.warn(`${t.outerHTML} icon name was not found in the provided icons object.`);const Du=bu(t),Fu={...n,"data-lucide":M,...c,...Du},zu=Tu(["lucide",`lucide-${M}`,Du,c]);zu&&Object.assign(Fu,{class:zu});const Ou=ea(na,Fu);return t.parentNode?.replaceChild(Ou,t)},oa=[["path",{d:"m14 12 4 4 4-4"}],["path",{d:"M18 16V7"}],["path",{d:"m2 16 4.039-9.69a.5.5 0 0 1 .923 0L11 16"}],["path",{d:"M3.304 13h6.392"}]],va=[["path",{d:"m14 11 4-4 4 4"}],["path",{d:"M18 16V7"}],["path",{d:"m2 16 4.039-9.69a.5.5 0 0 1 .923 0L11 16"}],["path",{d:"M3.304 13h6.392"}]],$a=[["path",{d:"m15 16 2.536-7.328a1.02 1.02 1 0 1 1.928 0L22 16"}],["path",{d:"M15.697 14h5.606"}],["path",{d:"m2 16 4.039-9.69a.5.5 0 0 1 .923 0L11 16"}],["path",{d:"M3.304 13h6.392"}]],ma=[["circle",{cx:"16",cy:"4",r:"1"}],["path",{d:"m18 19 1-7-6 1"}],["path",{d:"m5 8 3-3 5.5 3-2.36 3.5"}],["path",{d:"M4.24 14.5a5 5 0 0 0 6.88 6"}],["path",{d:"M13.76 17.5a5 5 0 0 0-6.88-6"}]],ya=[["path",{d:"M22 12h-2.48a2 2 0 0 0-1.93 1.46l-2.35 8.36a.25.25 0 0 1-.48 0L9.24 2.18a.25.25 0 0 0-.48 0l-2.35 8.36A2 2 0 0 1 4.49 12H2"}]],sa=[["path",{d:"M18 17.5a2.5 2.5 0 1 1-4 2.03V12"}],["path",{d:"M6 12H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2"}],["path",{d:"M6 8h12"}],["path",{d:"M6.6 15.572A2 2 0 1 0 10 17v-5"}]],ga=[["path",{d:"M5 17H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-1"}],["path",{d:"m12 15 5 6H7Z"}]],y=[["circle",{cx:"12",cy:"13",r:"8"}],["path",{d:"M5 3 2 6"}],["path",{d:"m22 6-3-3"}],["path",{d:"M6.38 18.7 4 21"}],["path",{d:"M17.64 18.67 20 21"}],["path",{d:"m9 13 2 2 4-4"}]],s=[["circle",{cx:"12",cy:"13",r:"8"}],["path",{d:"M5 3 2 6"}],["path",{d:"m22 6-3-3"}],["path",{d:"M6.38 18.7 4 21"}],["path",{d:"M17.64 18.67 20 21"}],["path",{d:"M9 13h6"}]],ua=[["path",{d:"M6.87 6.87a8 8 0 1 0 11.26 11.26"}],["path",{d:"M19.9 14.25a8 8 0 0 0-9.15-9.15"}],["path",{d:"m22 6-3-3"}],["path",{d:"M6.26 18.67 4 21"}],["path",{d:"m2 2 20 20"}],["path",{d:"M4 4 2 6"}]],g=[["circle",{cx:"12",cy:"13",r:"8"}],["path",{d:"M5 3 2 6"}],["path",{d:"m22 6-3-3"}],["path",{d:"M6.38 18.7 4 21"}],["path",{d:"M17.64 18.67 20 21"}],["path",{d:"M12 10v6"}],["path",{d:"M9 13h6"}]],Ca=[["circle",{cx:"12",cy:"13",r:"8"}],["path",{d:"M12 9v4l2 2"}],["path",{d:"M5 3 2 6"}],["path",{d:"m22 6-3-3"}],["path",{d:"M6.38 18.7 4 21"}],["path",{d:"M17.64 18.67 20 21"}]],Ha=[["path",{d:"M11 21c0-2.5 2-2.5 2-5"}],["path",{d:"M16 21c0-2.5 2-2.5 2-5"}],["path",{d:"m19 8-.8 3a1.25 1.25 0 0 1-1.2 1H7a1.25 1.25 0 0 1-1.2-1L5 8"}],["path",{d:"M21 3a1 1 0 0 1 1 1v2a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V4a1 1 0 0 1 1-1z"}],["path",{d:"M6 21c0-2.5 2-2.5 2-5"}]],Aa=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2",ry:"2"}],["polyline",{points:"11 3 11 11 14 8 17 11 17 3"}]],wa=[["path",{d:"M2 12h20"}],["path",{d:"M10 16v4a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-4"}],["path",{d:"M10 8V4a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v4"}],["path",{d:"M20 16v1a2 2 0 0 1-2 2h-2a2 2 0 0 1-2-2v-1"}],["path",{d:"M14 8V7c0-1.1.9-2 2-2h2a2 2 0 0 1 2 2v1"}]],Va=[["path",{d:"M12 2v20"}],["path",{d:"M8 10H4a2 2 0 0 1-2-2V6c0-1.1.9-2 2-2h4"}],["path",{d:"M16 10h4a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2h-4"}],["path",{d:"M8 20H7a2 2 0 0 1-2-2v-2c0-1.1.9-2 2-2h1"}],["path",{d:"M16 14h1a2 2 0 0 1 2 2v2a2 2 0 0 1-2 2h-1"}]],Sa=[["rect",{width:"6",height:"16",x:"4",y:"2",rx:"2"}],["rect",{width:"6",height:"9",x:"14",y:"9",rx:"2"}],["path",{d:"M22 22H2"}]],La=[["rect",{width:"16",height:"6",x:"2",y:"4",rx:"2"}],["rect",{width:"9",height:"6",x:"9",y:"14",rx:"2"}],["path",{d:"M22 22V2"}]],fa=[["rect",{width:"6",height:"14",x:"4",y:"5",rx:"2"}],["rect",{width:"6",height:"10",x:"14",y:"7",rx:"2"}],["path",{d:"M17 22v-5"}],["path",{d:"M17 7V2"}],["path",{d:"M7 22v-3"}],["path",{d:"M7 5V2"}]],ka=[["rect",{width:"6",height:"14",x:"4",y:"5",rx:"2"}],["rect",{width:"6",height:"10",x:"14",y:"7",rx:"2"}],["path",{d:"M10 2v20"}],["path",{d:"M20 2v20"}]],Pa=[["rect",{width:"6",height:"14",x:"4",y:"5",rx:"2"}],["rect",{width:"6",height:"10",x:"14",y:"7",rx:"2"}],["path",{d:"M4 2v20"}],["path",{d:"M14 2v20"}]],Ba=[["rect",{width:"6",height:"14",x:"2",y:"5",rx:"2"}],["rect",{width:"6",height:"10",x:"16",y:"7",rx:"2"}],["path",{d:"M12 2v20"}]],Da=[["rect",{width:"6",height:"14",x:"2",y:"5",rx:"2"}],["rect",{width:"6",height:"10",x:"12",y:"7",rx:"2"}],["path",{d:"M22 2v20"}]],Fa=[["rect",{width:"6",height:"14",x:"6",y:"5",rx:"2"}],["rect",{width:"6",height:"10",x:"16",y:"7",rx:"2"}],["path",{d:"M2 2v20"}]],za=[["rect",{width:"6",height:"10",x:"9",y:"7",rx:"2"}],["path",{d:"M4 22V2"}],["path",{d:"M20 22V2"}]],ba=[["rect",{width:"6",height:"14",x:"3",y:"5",rx:"2"}],["rect",{width:"6",height:"10",x:"15",y:"7",rx:"2"}],["path",{d:"M3 2v20"}],["path",{d:"M21 2v20"}]],Ra=[["rect",{width:"6",height:"16",x:"4",y:"6",rx:"2"}],["rect",{width:"6",height:"9",x:"14",y:"6",rx:"2"}],["path",{d:"M22 2H2"}]],Ta=[["rect",{width:"9",height:"6",x:"6",y:"14",rx:"2"}],["rect",{width:"16",height:"6",x:"6",y:"4",rx:"2"}],["path",{d:"M2 2v20"}]],qa=[["path",{d:"M22 17h-3"}],["path",{d:"M22 7h-5"}],["path",{d:"M5 17H2"}],["path",{d:"M7 7H2"}],["rect",{x:"5",y:"14",width:"14",height:"6",rx:"2"}],["rect",{x:"7",y:"4",width:"10",height:"6",rx:"2"}]],Ua=[["rect",{width:"14",height:"6",x:"5",y:"14",rx:"2"}],["rect",{width:"10",height:"6",x:"7",y:"4",rx:"2"}],["path",{d:"M2 20h20"}],["path",{d:"M2 10h20"}]],Oa=[["rect",{width:"14",height:"6",x:"5",y:"14",rx:"2"}],["rect",{width:"10",height:"6",x:"7",y:"4",rx:"2"}],["path",{d:"M2 14h20"}],["path",{d:"M2 4h20"}]],Za=[["rect",{width:"14",height:"6",x:"5",y:"16",rx:"2"}],["rect",{width:"10",height:"6",x:"7",y:"2",rx:"2"}],["path",{d:"M2 12h20"}]],Ga=[["rect",{width:"14",height:"6",x:"5",y:"12",rx:"2"}],["rect",{width:"10",height:"6",x:"7",y:"2",rx:"2"}],["path",{d:"M2 22h20"}]],Ia=[["rect",{width:"14",height:"6",x:"5",y:"16",rx:"2"}],["rect",{width:"10",height:"6",x:"7",y:"6",rx:"2"}],["path",{d:"M2 2h20"}]],Wa=[["rect",{width:"10",height:"6",x:"7",y:"9",rx:"2"}],["path",{d:"M22 20H2"}],["path",{d:"M22 4H2"}]],Ea=[["rect",{width:"14",height:"6",x:"5",y:"15",rx:"2"}],["rect",{width:"10",height:"6",x:"7",y:"3",rx:"2"}],["path",{d:"M2 21h20"}],["path",{d:"M2 3h20"}]],Xa=[["path",{d:"M10 10H6"}],["path",{d:"M14 18V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v11a1 1 0 0 0 1 1h2"}],["path",{d:"M19 18h2a1 1 0 0 0 1-1v-3.28a1 1 0 0 0-.684-.948l-1.923-.641a1 1 0 0 1-.578-.502l-1.539-3.076A1 1 0 0 0 16.382 8H14"}],["path",{d:"M8 8v4"}],["path",{d:"M9 18h6"}],["circle",{cx:"17",cy:"18",r:"2"}],["circle",{cx:"7",cy:"18",r:"2"}]],ja=[["path",{d:"M17.5 12c0 4.4-3.6 8-8 8A4.5 4.5 0 0 1 5 15.5c0-6 8-4 8-8.5a3 3 0 1 0-6 0c0 3 2.5 8.5 12 13"}],["path",{d:"M16 12h3"}]],Na=[["path",{d:"M10 17c-5-3-7-7-7-9a2 2 0 0 1 4 0c0 2.5-5 2.5-5 6 0 1.7 1.3 3 3 3 2.8 0 5-2.2 5-5"}],["path",{d:"M22 17c-5-3-7-7-7-9a2 2 0 0 1 4 0c0 2.5-5 2.5-5 6 0 1.7 1.3 3 3 3 2.8 0 5-2.2 5-5"}]],Ka=[["path",{d:"M10 2v5.632c0 .424-.272.795-.653.982A6 6 0 0 0 6 14c.006 4 3 7 5 8"}],["path",{d:"M10 5H8a2 2 0 0 0 0 4h.68"}],["path",{d:"M14 2v5.632c0 .424.272.795.652.982A6 6 0 0 1 18 14c0 4-3 7-5 8"}],["path",{d:"M14 5h2a2 2 0 0 1 0 4h-.68"}],["path",{d:"M18 22H6"}],["path",{d:"M9 2h6"}]],Qa=[["path",{d:"M12 22V8"}],["path",{d:"M5 12H2a10 10 0 0 0 20 0h-3"}],["circle",{cx:"12",cy:"5",r:"3"}]],Ja=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M16 16s-1.5-2-4-2-4 2-4 2"}],["path",{d:"M7.5 8 10 9"}],["path",{d:"m14 9 2.5-1"}],["path",{d:"M9 10h.01"}],["path",{d:"M15 10h.01"}]],Ya=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M8 15h8"}],["path",{d:"M8 9h2"}],["path",{d:"M14 9h2"}]],_a=[["path",{d:"M2 12 7 2"}],["path",{d:"m7 12 5-10"}],["path",{d:"m12 12 5-10"}],["path",{d:"m17 12 5-10"}],["path",{d:"M4.5 7h15"}],["path",{d:"M12 16v6"}]],xa=[["path",{d:"M7 10H6a4 4 0 0 1-4-4 1 1 0 0 1 1-1h4"}],["path",{d:"M7 5a1 1 0 0 1 1-1h13a1 1 0 0 1 1 1 7 7 0 0 1-7 7H8a1 1 0 0 1-1-1z"}],["path",{d:"M9 12v5"}],["path",{d:"M15 12v5"}],["path",{d:"M5 20a3 3 0 0 1 3-3h8a3 3 0 0 1 3 3 1 1 0 0 1-1 1H6a1 1 0 0 1-1-1"}]],at=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"m14.31 8 5.74 9.94"}],["path",{d:"M9.69 8h11.48"}],["path",{d:"m7.38 12 5.74-9.94"}],["path",{d:"M9.69 16 3.95 6.06"}],["path",{d:"M14.31 16H2.83"}],["path",{d:"m16.62 12-5.74 9.94"}]],tt=[["rect",{width:"20",height:"16",x:"2",y:"4",rx:"2"}],["path",{d:"M6 8h.01"}],["path",{d:"M10 8h.01"}],["path",{d:"M14 8h.01"}]],ht=[["rect",{x:"2",y:"4",width:"20",height:"16",rx:"2"}],["path",{d:"M10 4v4"}],["path",{d:"M2 8h20"}],["path",{d:"M6 4v4"}]],dt=[["path",{d:"M12 6.528V3a1 1 0 0 1 1-1h0"}],["path",{d:"M18.237 21A15 15 0 0 0 22 11a6 6 0 0 0-10-4.472A6 6 0 0 0 2 11a15.1 15.1 0 0 0 3.763 10 3 3 0 0 0 3.648.648 5.5 5.5 0 0 1 5.178 0A3 3 0 0 0 18.237 21"}]],ct=[["rect",{width:"20",height:"5",x:"2",y:"3",rx:"1"}],["path",{d:"M4 8v11a2 2 0 0 0 2 2h2"}],["path",{d:"M20 8v11a2 2 0 0 1-2 2h-2"}],["path",{d:"m9 15 3-3 3 3"}],["path",{d:"M12 12v9"}]],Mt=[["rect",{width:"20",height:"5",x:"2",y:"3",rx:"1"}],["path",{d:"M4 8v11a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8"}],["path",{d:"m9.5 17 5-5"}],["path",{d:"m9.5 12 5 5"}]],pt=[["path",{d:"M19 9V6a2 2 0 0 0-2-2H7a2 2 0 0 0-2 2v3"}],["path",{d:"M3 16a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-5a2 2 0 0 0-4 0v1.5a.5.5 0 0 1-.5.5h-9a.5.5 0 0 1-.5-.5V11a2 2 0 0 0-4 0z"}],["path",{d:"M5 18v2"}],["path",{d:"M19 18v2"}]],it=[["rect",{width:"20",height:"5",x:"2",y:"3",rx:"1"}],["path",{d:"M4 8v11a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8"}],["path",{d:"M10 12h4"}]],nt=[["path",{d:"M15 11a1 1 0 0 0 1 1h2.939a1 1 0 0 1 .75 1.811l-6.835 6.836a1.207 1.207 0 0 1-1.707 0L4.31 13.81a1 1 0 0 1 .75-1.811H8a1 1 0 0 0 1-1V9a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1z"}],["path",{d:"M9 4h6"}]],lt=[["path",{d:"M15 11a1 1 0 0 0 1 1h2.939a1 1 0 0 1 .75 1.811l-6.835 6.836a1.207 1.207 0 0 1-1.707 0L4.31 13.81a1 1 0 0 1 .75-1.811H8a1 1 0 0 0 1-1V5a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1z"}]],et=[["path",{d:"M13 9a1 1 0 0 1-1-1V5.061a1 1 0 0 0-1.811-.75l-6.835 6.836a1.207 1.207 0 0 0 0 1.707l6.835 6.835a1 1 0 0 0 1.811-.75V16a1 1 0 0 1 1-1h2a1 1 0 0 0 1-1v-4a1 1 0 0 0-1-1z"}],["path",{d:"M20 9v6"}]],rt=[["path",{d:"M13 9a1 1 0 0 1-1-1V5.061a1 1 0 0 0-1.811-.75l-6.835 6.836a1.207 1.207 0 0 0 0 1.707l6.835 6.835a1 1 0 0 0 1.811-.75V16a1 1 0 0 1 1-1h6a1 1 0 0 0 1-1v-4a1 1 0 0 0-1-1z"}]],ot=[["path",{d:"M11 9a1 1 0 0 0 1-1V5.061a1 1 0 0 1 1.811-.75l6.836 6.836a1.207 1.207 0 0 1 0 1.707l-6.836 6.835a1 1 0 0 1-1.811-.75V16a1 1 0 0 0-1-1H9a1 1 0 0 1-1-1v-4a1 1 0 0 1 1-1z"}],["path",{d:"M4 9v6"}]],vt=[["path",{d:"M11 9a1 1 0 0 0 1-1V5.061a1 1 0 0 1 1.811-.75l6.836 6.836a1.207 1.207 0 0 1 0 1.707l-6.836 6.835a1 1 0 0 1-1.811-.75V16a1 1 0 0 0-1-1H5a1 1 0 0 1-1-1v-4a1 1 0 0 1 1-1z"}]],$t=[["path",{d:"M9 13a1 1 0 0 0-1-1H5.061a1 1 0 0 1-.75-1.811l6.836-6.835a1.207 1.207 0 0 1 1.707 0l6.835 6.835a1 1 0 0 1-.75 1.811H16a1 1 0 0 0-1 1v2a1 1 0 0 1-1 1h-4a1 1 0 0 1-1-1z"}],["path",{d:"M9 20h6"}]],mt=[["path",{d:"M9 13a1 1 0 0 0-1-1H5.061a1 1 0 0 1-.75-1.811l6.836-6.835a1.207 1.207 0 0 1 1.707 0l6.835 6.835a1 1 0 0 1-.75 1.811H16a1 1 0 0 0-1 1v6a1 1 0 0 1-1 1h-4a1 1 0 0 1-1-1z"}]],yt=[["path",{d:"m3 16 4 4 4-4"}],["path",{d:"M7 20V4"}],["rect",{x:"15",y:"4",width:"4",height:"6",ry:"2"}],["path",{d:"M17 20v-6h-2"}],["path",{d:"M15 20h4"}]],st=[["path",{d:"m3 16 4 4 4-4"}],["path",{d:"M7 20V4"}],["path",{d:"M17 10V4h-2"}],["path",{d:"M15 10h4"}],["rect",{x:"15",y:"14",width:"4",height:"6",ry:"2"}]],u=[["path",{d:"m3 16 4 4 4-4"}],["path",{d:"M7 20V4"}],["path",{d:"M20 8h-5"}],["path",{d:"M15 10V6.5a2.5 2.5 0 0 1 5 0V10"}],["path",{d:"M15 14h5l-5 6h5"}]],gt=[["path",{d:"M19 3H5"}],["path",{d:"M12 21V7"}],["path",{d:"m6 15 6 6 6-6"}]],ut=[["path",{d:"m3 16 4 4 4-4"}],["path",{d:"M7 20V4"}],["path",{d:"M11 4h4"}],["path",{d:"M11 8h7"}],["path",{d:"M11 12h10"}]],Ct=[["path",{d:"M17 7 7 17"}],["path",{d:"M17 17H7V7"}]],Ht=[["path",{d:"m7 7 10 10"}],["path",{d:"M17 7v10H7"}]],At=[["path",{d:"M12 2v14"}],["path",{d:"m19 9-7 7-7-7"}],["circle",{cx:"12",cy:"21",r:"1"}]],wt=[["path",{d:"M12 17V3"}],["path",{d:"m6 11 6 6 6-6"}],["path",{d:"M19 21H5"}]],Vt=[["path",{d:"m3 16 4 4 4-4"}],["path",{d:"M7 20V4"}],["path",{d:"m21 8-4-4-4 4"}],["path",{d:"M17 4v16"}]],C=[["path",{d:"m3 16 4 4 4-4"}],["path",{d:"M7 20V4"}],["path",{d:"M11 4h10"}],["path",{d:"M11 8h7"}],["path",{d:"M11 12h4"}]],St=[["path",{d:"M12 5v14"}],["path",{d:"m19 12-7 7-7-7"}]],H=[["path",{d:"m3 16 4 4 4-4"}],["path",{d:"M7 4v16"}],["path",{d:"M15 4h5l-5 6h5"}],["path",{d:"M15 20v-3.5a2.5 2.5 0 0 1 5 0V20"}],["path",{d:"M20 18h-5"}]],Lt=[["path",{d:"m9 6-6 6 6 6"}],["path",{d:"M3 12h14"}],["path",{d:"M21 19V5"}]],ft=[["path",{d:"M8 3 4 7l4 4"}],["path",{d:"M4 7h16"}],["path",{d:"m16 21 4-4-4-4"}],["path",{d:"M20 17H4"}]],kt=[["path",{d:"M3 19V5"}],["path",{d:"m13 6-6 6 6 6"}],["path",{d:"M7 12h14"}]],Pt=[["path",{d:"m12 19-7-7 7-7"}],["path",{d:"M19 12H5"}]],Bt=[["path",{d:"M3 5v14"}],["path",{d:"M21 12H7"}],["path",{d:"m15 18 6-6-6-6"}]],Dt=[["path",{d:"m16 3 4 4-4 4"}],["path",{d:"M20 7H4"}],["path",{d:"m8 21-4-4 4-4"}],["path",{d:"M4 17h16"}]],Ft=[["path",{d:"M17 12H3"}],["path",{d:"m11 18 6-6-6-6"}],["path",{d:"M21 5v14"}]],zt=[["path",{d:"M5 12h14"}],["path",{d:"m12 5 7 7-7 7"}]],bt=[["path",{d:"m3 8 4-4 4 4"}],["path",{d:"M7 4v16"}],["rect",{x:"15",y:"4",width:"4",height:"6",ry:"2"}],["path",{d:"M17 20v-6h-2"}],["path",{d:"M15 20h4"}]],Rt=[["path",{d:"m3 8 4-4 4 4"}],["path",{d:"M7 4v16"}],["path",{d:"M17 10V4h-2"}],["path",{d:"M15 10h4"}],["rect",{x:"15",y:"14",width:"4",height:"6",ry:"2"}]],A=[["path",{d:"m3 8 4-4 4 4"}],["path",{d:"M7 4v16"}],["path",{d:"M20 8h-5"}],["path",{d:"M15 10V6.5a2.5 2.5 0 0 1 5 0V10"}],["path",{d:"M15 14h5l-5 6h5"}]],Tt=[["path",{d:"m21 16-4 4-4-4"}],["path",{d:"M17 20V4"}],["path",{d:"m3 8 4-4 4 4"}],["path",{d:"M7 4v16"}]],qt=[["path",{d:"m5 9 7-7 7 7"}],["path",{d:"M12 16V2"}],["circle",{cx:"12",cy:"21",r:"1"}]],Ut=[["path",{d:"m18 9-6-6-6 6"}],["path",{d:"M12 3v14"}],["path",{d:"M5 21h14"}]],Ot=[["path",{d:"M7 17V7h10"}],["path",{d:"M17 17 7 7"}]],w=[["path",{d:"m3 8 4-4 4 4"}],["path",{d:"M7 4v16"}],["path",{d:"M11 12h4"}],["path",{d:"M11 16h7"}],["path",{d:"M11 20h10"}]],Zt=[["path",{d:"M7 7h10v10"}],["path",{d:"M7 17 17 7"}]],Gt=[["path",{d:"M5 3h14"}],["path",{d:"m18 13-6-6-6 6"}],["path",{d:"M12 7v14"}]],It=[["path",{d:"m3 8 4-4 4 4"}],["path",{d:"M7 4v16"}],["path",{d:"M11 12h10"}],["path",{d:"M11 16h7"}],["path",{d:"M11 20h4"}]],V=[["path",{d:"m3 8 4-4 4 4"}],["path",{d:"M7 4v16"}],["path",{d:"M15 4h5l-5 6h5"}],["path",{d:"M15 20v-3.5a2.5 2.5 0 0 1 5 0V20"}],["path",{d:"M20 18h-5"}]],Wt=[["path",{d:"m5 12 7-7 7 7"}],["path",{d:"M12 19V5"}]],Et=[["path",{d:"m4 6 3-3 3 3"}],["path",{d:"M7 17V3"}],["path",{d:"m14 6 3-3 3 3"}],["path",{d:"M17 17V3"}],["path",{d:"M4 21h16"}]],Xt=[["path",{d:"M12 6v12"}],["path",{d:"M17.196 9 6.804 15"}],["path",{d:"m6.804 9 10.392 6"}]],jt=[["circle",{cx:"12",cy:"12",r:"4"}],["path",{d:"M16 8v5a3 3 0 0 0 6 0v-1a10 10 0 1 0-4 8"}]],Nt=[["circle",{cx:"12",cy:"12",r:"1"}],["path",{d:"M20.2 20.2c2.04-2.03.02-7.36-4.5-11.9-4.54-4.52-9.87-6.54-11.9-4.5-2.04 2.03-.02 7.36 4.5 11.9 4.54 4.52 9.87 6.54 11.9 4.5Z"}],["path",{d:"M15.7 15.7c4.52-4.54 6.54-9.87 4.5-11.9-2.03-2.04-7.36-.02-11.9 4.5-4.52 4.54-6.54 9.87-4.5 11.9 2.03 2.04 7.36.02 11.9-4.5Z"}]],Kt=[["path",{d:"M2 10v3"}],["path",{d:"M6 6v11"}],["path",{d:"M10 3v18"}],["path",{d:"M14 8v7"}],["path",{d:"M18 5v13"}],["path",{d:"M22 10v3"}]],Qt=[["path",{d:"m15.477 12.89 1.515 8.526a.5.5 0 0 1-.81.47l-3.58-2.687a1 1 0 0 0-1.197 0l-3.586 2.686a.5.5 0 0 1-.81-.469l1.514-8.526"}],["circle",{cx:"12",cy:"8",r:"6"}]],Jt=[["path",{d:"M2 13a2 2 0 0 0 2-2V7a2 2 0 0 1 4 0v13a2 2 0 0 0 4 0V4a2 2 0 0 1 4 0v13a2 2 0 0 0 4 0v-4a2 2 0 0 1 2-2"}]],Yt=[["path",{d:"m14 12-8.381 8.38a1 1 0 0 1-3.001-3L11 9"}],["path",{d:"M15 15.5a.5.5 0 0 0 .5.5A6.5 6.5 0 0 0 22 9.5a.5.5 0 0 0-.5-.5h-1.672a2 2 0 0 1-1.414-.586l-5.062-5.062a1.205 1.205 0 0 0-1.704 0L9.352 5.648a1.205 1.205 0 0 0 0 1.704l5.062 5.062A2 2 0 0 1 15 13.828z"}]],S=[["path",{d:"M13.5 10.5 15 9"}],["path",{d:"M4 4v15a1 1 0 0 0 1 1h15"}],["path",{d:"M4.293 19.707 6 18"}],["path",{d:"m9 15 1.5-1.5"}]],_t=[["path",{d:"M10 16c.5.3 1.2.5 2 .5s1.5-.2 2-.5"}],["path",{d:"M15 12h.01"}],["path",{d:"M19.38 6.813A9 9 0 0 1 20.8 10.2a2 2 0 0 1 0 3.6 9 9 0 0 1-17.6 0 2 2 0 0 1 0-3.6A9 9 0 0 1 12 3c2 0 3.5 1.1 3.5 2.5s-.9 2.5-2 2.5c-.8 0-1.5-.4-1.5-1"}],["path",{d:"M9 12h.01"}]],xt=[["path",{d:"M4 10a4 4 0 0 1 4-4h8a4 4 0 0 1 4 4v10a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2z"}],["path",{d:"M8 10h8"}],["path",{d:"M8 18h8"}],["path",{d:"M8 22v-6a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v6"}],["path",{d:"M9 6V4a2 2 0 0 1 2-2h2a2 2 0 0 1 2 2v2"}]],ah=[["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"}],["line",{x1:"12",x2:"12",y1:"8",y2:"12"}],["line",{x1:"12",x2:"12.01",y1:"16",y2:"16"}]],L=[["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"}],["path",{d:"m9 12 2 2 4-4"}]],th=[["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"}],["path",{d:"M16 8h-6a2 2 0 1 0 0 4h4a2 2 0 1 1 0 4H8"}],["path",{d:"M12 18V6"}]],hh=[["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"}],["path",{d:"M12 7v10"}],["path",{d:"M15.4 10a4 4 0 1 0 0 4"}]],dh=[["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"}],["path",{d:"M7 12h5"}],["path",{d:"M15 9.4a4 4 0 1 0 0 5.2"}]],ch=[["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"}],["path",{d:"M8 8h8"}],["path",{d:"M8 12h8"}],["path",{d:"m13 17-5-1h1a4 4 0 0 0 0-8"}]],Mh=[["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"}],["line",{x1:"12",x2:"12",y1:"16",y2:"12"}],["line",{x1:"12",x2:"12.01",y1:"8",y2:"8"}]],ph=[["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"}],["path",{d:"m9 8 3 3v7"}],["path",{d:"m12 11 3-3"}],["path",{d:"M9 12h6"}],["path",{d:"M9 16h6"}]],ih=[["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"}],["line",{x1:"8",x2:"16",y1:"12",y2:"12"}]],nh=[["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"}],["path",{d:"m15 9-6 6"}],["path",{d:"M9 9h.01"}],["path",{d:"M15 15h.01"}]],lh=[["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"}],["line",{x1:"12",x2:"12",y1:"8",y2:"16"}],["line",{x1:"8",x2:"16",y1:"12",y2:"12"}]],f=[["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"}],["path",{d:"M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"}],["line",{x1:"12",x2:"12.01",y1:"17",y2:"17"}]],eh=[["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"}],["path",{d:"M8 12h4"}],["path",{d:"M10 16V9.5a2.5 2.5 0 0 1 5 0"}],["path",{d:"M8 16h7"}]],rh=[["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"}],["path",{d:"M9 16h5"}],["path",{d:"M9 12h5a2 2 0 1 0 0-4h-3v9"}]],oh=[["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"}],["path",{d:"M11 17V8h4"}],["path",{d:"M11 12h3"}],["path",{d:"M9 16h4"}]],vh=[["path",{d:"M11 7v10a5 5 0 0 0 5-5"}],["path",{d:"m15 8-6 3"}],["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76"}]],$h=[["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"}],["line",{x1:"15",x2:"9",y1:"9",y2:"15"}],["line",{x1:"9",x2:"15",y1:"9",y2:"15"}]],mh=[["path",{d:"M3.85 8.62a4 4 0 0 1 4.78-4.77 4 4 0 0 1 6.74 0 4 4 0 0 1 4.78 4.78 4 4 0 0 1 0 6.74 4 4 0 0 1-4.77 4.78 4 4 0 0 1-6.75 0 4 4 0 0 1-4.78-4.77 4 4 0 0 1 0-6.76Z"}]],yh=[["path",{d:"M22 18H6a2 2 0 0 1-2-2V7a2 2 0 0 0-2-2"}],["path",{d:"M17 14V4a2 2 0 0 0-2-2h-1a2 2 0 0 0-2 2v10"}],["rect",{width:"13",height:"8",x:"8",y:"6",rx:"1"}],["circle",{cx:"18",cy:"20",r:"2"}],["circle",{cx:"9",cy:"20",r:"2"}]],sh=[["path",{d:"M4.929 4.929 19.07 19.071"}],["circle",{cx:"12",cy:"12",r:"10"}]],gh=[["path",{d:"M4 13c3.5-2 8-2 10 2a5.5 5.5 0 0 1 8 5"}],["path",{d:"M5.15 17.89c5.52-1.52 8.65-6.89 7-12C11.55 4 11.5 2 13 2c3.22 0 5 5.5 5 8 0 6.5-4.2 12-10.49 12C5.11 22 2 22 2 20c0-1.5 1.14-1.55 3.15-2.11Z"}]],uh=[["path",{d:"M10 10.01h.01"}],["path",{d:"M10 14.01h.01"}],["path",{d:"M14 10.01h.01"}],["path",{d:"M14 14.01h.01"}],["path",{d:"M18 6v11.5"}],["path",{d:"M6 6v12"}],["rect",{x:"2",y:"6",width:"20",height:"12",rx:"2"}]],Ch=[["path",{d:"M12 18H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5"}],["path",{d:"m16 19 3 3 3-3"}],["path",{d:"M18 12h.01"}],["path",{d:"M19 16v6"}],["path",{d:"M6 12h.01"}],["circle",{cx:"12",cy:"12",r:"2"}]],Hh=[["path",{d:"M12 18H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5"}],["path",{d:"M18 12h.01"}],["path",{d:"M19 22v-6"}],["path",{d:"m22 19-3-3-3 3"}],["path",{d:"M6 12h.01"}],["circle",{cx:"12",cy:"12",r:"2"}]],Ah=[["path",{d:"M13 18H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5"}],["path",{d:"m17 17 5 5"}],["path",{d:"M18 12h.01"}],["path",{d:"m22 17-5 5"}],["path",{d:"M6 12h.01"}],["circle",{cx:"12",cy:"12",r:"2"}]],wh=[["rect",{width:"20",height:"12",x:"2",y:"6",rx:"2"}],["circle",{cx:"12",cy:"12",r:"2"}],["path",{d:"M6 12h.01M18 12h.01"}]],Vh=[["path",{d:"M3 5v14"}],["path",{d:"M8 5v14"}],["path",{d:"M12 5v14"}],["path",{d:"M17 5v14"}],["path",{d:"M21 5v14"}]],Sh=[["path",{d:"M10 3a41 41 0 0 0 0 18"}],["path",{d:"M14 3a41 41 0 0 1 0 18"}],["path",{d:"M17 3a2 2 0 0 1 1.68.92 15.25 15.25 0 0 1 0 16.16A2 2 0 0 1 17 21H7a2 2 0 0 1-1.68-.92 15.25 15.25 0 0 1 0-16.16A2 2 0 0 1 7 3z"}],["path",{d:"M3.84 17h16.32"}],["path",{d:"M3.84 7h16.32"}]],Lh=[["path",{d:"M4 20h16"}],["path",{d:"m6 16 6-12 6 12"}],["path",{d:"M8 12h8"}]],fh=[["path",{d:"M10 4 8 6"}],["path",{d:"M17 19v2"}],["path",{d:"M2 12h20"}],["path",{d:"M7 19v2"}],["path",{d:"M9 5 7.621 3.621A2.121 2.121 0 0 0 4 5v12a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-5"}]],kh=[["path",{d:"m11 7-3 5h4l-3 5"}],["path",{d:"M14.856 6H16a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-2.935"}],["path",{d:"M22 14v-4"}],["path",{d:"M5.14 18H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h2.936"}]],Ph=[["path",{d:"M10 10v4"}],["path",{d:"M14 10v4"}],["path",{d:"M22 14v-4"}],["path",{d:"M6 10v4"}],["rect",{x:"2",y:"6",width:"16",height:"12",rx:"2"}]],Bh=[["path",{d:"M22 14v-4"}],["path",{d:"M6 14v-4"}],["rect",{x:"2",y:"6",width:"16",height:"12",rx:"2"}]],Dh=[["path",{d:"M10 14v-4"}],["path",{d:"M22 14v-4"}],["path",{d:"M6 14v-4"}],["rect",{x:"2",y:"6",width:"16",height:"12",rx:"2"}]],Fh=[["path",{d:"M10 9v6"}],["path",{d:"M12.543 6H16a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-3.605"}],["path",{d:"M22 14v-4"}],["path",{d:"M7 12h6"}],["path",{d:"M7.606 18H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h3.606"}]],zh=[["path",{d:"M10 17h.01"}],["path",{d:"M10 7v6"}],["path",{d:"M14 6h2a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-2"}],["path",{d:"M22 14v-4"}],["path",{d:"M6 18H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h2"}]],bh=[["path",{d:"M 22 14 L 22 10"}],["rect",{x:"2",y:"6",width:"16",height:"12",rx:"2"}]],Rh=[["path",{d:"M4.5 3h15"}],["path",{d:"M6 3v16a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V3"}],["path",{d:"M6 14h12"}]],Th=[["path",{d:"M9 9c-.64.64-1.521.954-2.402 1.165A6 6 0 0 0 8 22a13.96 13.96 0 0 0 9.9-4.1"}],["path",{d:"M10.75 5.093A6 6 0 0 1 22 8c0 2.411-.61 4.68-1.683 6.66"}],["path",{d:"M5.341 10.62a4 4 0 0 0 6.487 1.208M10.62 5.341a4.015 4.015 0 0 1 2.039 2.04"}],["line",{x1:"2",x2:"22",y1:"2",y2:"22"}]],qh=[["path",{d:"M10.165 6.598C9.954 7.478 9.64 8.36 9 9c-.64.64-1.521.954-2.402 1.165A6 6 0 0 0 8 22c7.732 0 14-6.268 14-14a6 6 0 0 0-11.835-1.402Z"}],["path",{d:"M5.341 10.62a4 4 0 1 0 5.279-5.28"}]],Uh=[["path",{d:"M2 20v-8a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v8"}],["path",{d:"M4 10V6a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v4"}],["path",{d:"M12 4v6"}],["path",{d:"M2 18h20"}]],Oh=[["path",{d:"M3 20v-8a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v8"}],["path",{d:"M5 10V6a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v4"}],["path",{d:"M3 18h18"}]],Zh=[["path",{d:"M2 4v16"}],["path",{d:"M2 8h18a2 2 0 0 1 2 2v10"}],["path",{d:"M2 17h20"}],["path",{d:"M6 8v9"}]],Gh=[["path",{d:"M16.4 13.7A6.5 6.5 0 1 0 6.28 6.6c-1.1 3.13-.78 3.9-3.18 6.08A3 3 0 0 0 5 18c4 0 8.4-1.8 11.4-4.3"}],["path",{d:"m18.5 6 2.19 4.5a6.48 6.48 0 0 1-2.29 7.2C15.4 20.2 11 22 7 22a3 3 0 0 1-2.68-1.66L2.4 16.5"}],["circle",{cx:"12.5",cy:"8.5",r:"2.5"}]],Ih=[["path",{d:"M13 13v5"}],["path",{d:"M17 11.47V8"}],["path",{d:"M17 11h1a3 3 0 0 1 2.745 4.211"}],["path",{d:"m2 2 20 20"}],["path",{d:"M5 8v12a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2v-3"}],["path",{d:"M7.536 7.535C6.766 7.649 6.154 8 5.5 8a2.5 2.5 0 0 1-1.768-4.268"}],["path",{d:"M8.727 3.204C9.306 2.767 9.885 2 11 2c1.56 0 2 1.5 3 1.5s1.72-.5 2.5-.5a1 1 0 1 1 0 5c-.78 0-1.5-.5-2.5-.5a3.149 3.149 0 0 0-.842.12"}],["path",{d:"M9 14.6V18"}]],Wh=[["path",{d:"M17 11h1a3 3 0 0 1 0 6h-1"}],["path",{d:"M9 12v6"}],["path",{d:"M13 12v6"}],["path",{d:"M14 7.5c-1 0-1.44.5-3 .5s-2-.5-3-.5-1.72.5-2.5.5a2.5 2.5 0 0 1 0-5c.78 0 1.57.5 2.5.5S9.44 2 11 2s2 1.5 3 1.5 1.72-.5 2.5-.5a2.5 2.5 0 0 1 0 5c-.78 0-1.5-.5-2.5-.5Z"}],["path",{d:"M5 8v12a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V8"}]],Eh=[["path",{d:"M10.268 21a2 2 0 0 0 3.464 0"}],["path",{d:"M13.916 2.314A6 6 0 0 0 6 8c0 4.499-1.411 5.956-2.74 7.327A1 1 0 0 0 4 17h16a1 1 0 0 0 .74-1.673 9 9 0 0 1-.585-.665"}],["circle",{cx:"18",cy:"8",r:"3"}]],Xh=[["path",{d:"M18.518 17.347A7 7 0 0 1 14 19"}],["path",{d:"M18.8 4A11 11 0 0 1 20 9"}],["path",{d:"M9 9h.01"}],["circle",{cx:"20",cy:"16",r:"2"}],["circle",{cx:"9",cy:"9",r:"7"}],["rect",{x:"4",y:"16",width:"10",height:"6",rx:"2"}]],jh=[["path",{d:"M10.268 21a2 2 0 0 0 3.464 0"}],["path",{d:"M15 8h6"}],["path",{d:"M16.243 3.757A6 6 0 0 0 6 8c0 4.499-1.411 5.956-2.738 7.326A1 1 0 0 0 4 17h16a1 1 0 0 0 .74-1.673A9.4 9.4 0 0 1 18.667 12"}]],Nh=[["path",{d:"M10.268 21a2 2 0 0 0 3.464 0"}],["path",{d:"M17 17H4a1 1 0 0 1-.74-1.673C4.59 13.956 6 12.499 6 8a6 6 0 0 1 .258-1.742"}],["path",{d:"m2 2 20 20"}],["path",{d:"M8.668 3.01A6 6 0 0 1 18 8c0 2.687.77 4.653 1.707 6.05"}]],Kh=[["path",{d:"M10.268 21a2 2 0 0 0 3.464 0"}],["path",{d:"M15 8h6"}],["path",{d:"M18 5v6"}],["path",{d:"M20.002 14.464a9 9 0 0 0 .738.863A1 1 0 0 1 20 17H4a1 1 0 0 1-.74-1.673C4.59 13.956 6 12.499 6 8a6 6 0 0 1 8.75-5.332"}]],Qh=[["path",{d:"M10.268 21a2 2 0 0 0 3.464 0"}],["path",{d:"M22 8c0-2.3-.8-4.3-2-6"}],["path",{d:"M3.262 15.326A1 1 0 0 0 4 17h16a1 1 0 0 0 .74-1.673C19.41 13.956 18 12.499 18 8A6 6 0 0 0 6 8c0 4.499-1.411 5.956-2.738 7.326"}],["path",{d:"M4 2C2.8 3.7 2 5.7 2 8"}]],Jh=[["path",{d:"M10.268 21a2 2 0 0 0 3.464 0"}],["path",{d:"M3.262 15.326A1 1 0 0 0 4 17h16a1 1 0 0 0 .74-1.673C19.41 13.956 18 12.499 18 8A6 6 0 0 0 6 8c0 4.499-1.411 5.956-2.738 7.326"}]],k=[["rect",{width:"13",height:"7",x:"3",y:"3",rx:"1"}],["path",{d:"m22 15-3-3 3-3"}],["rect",{width:"13",height:"7",x:"3",y:"14",rx:"1"}]],P=[["rect",{width:"13",height:"7",x:"8",y:"3",rx:"1"}],["path",{d:"m2 9 3 3-3 3"}],["rect",{width:"13",height:"7",x:"8",y:"14",rx:"1"}]],Yh=[["rect",{width:"7",height:"13",x:"3",y:"3",rx:"1"}],["path",{d:"m9 22 3-3 3 3"}],["rect",{width:"7",height:"13",x:"14",y:"3",rx:"1"}]],_h=[["rect",{width:"7",height:"13",x:"3",y:"8",rx:"1"}],["path",{d:"m15 2-3 3-3-3"}],["rect",{width:"7",height:"13",x:"14",y:"8",rx:"1"}]],xh=[["circle",{cx:"18.5",cy:"17.5",r:"3.5"}],["circle",{cx:"5.5",cy:"17.5",r:"3.5"}],["circle",{cx:"15",cy:"5",r:"1"}],["path",{d:"M12 17.5V14l-3-3 4-3 2 3h2"}]],a4=[["path",{d:"M12.409 13.017A5 5 0 0 1 22 15c0 3.866-4 7-9 7-4.077 0-8.153-.82-10.371-2.462-.426-.316-.631-.832-.62-1.362C2.118 12.723 2.627 2 10 2a3 3 0 0 1 3 3 2 2 0 0 1-2 2c-1.105 0-1.64-.444-2-1"}],["path",{d:"M15 14a5 5 0 0 0-7.584 2"}],["path",{d:"M9.964 6.825C8.019 7.977 9.5 13 8 15"}]],t4=[["rect",{x:"14",y:"14",width:"4",height:"6",rx:"2"}],["rect",{x:"6",y:"4",width:"4",height:"6",rx:"2"}],["path",{d:"M6 20h4"}],["path",{d:"M14 10h4"}],["path",{d:"M6 14h2v6"}],["path",{d:"M14 4h2v6"}]],h4=[["path",{d:"M10 10h4"}],["path",{d:"M19 7V4a1 1 0 0 0-1-1h-2a1 1 0 0 0-1 1v3"}],["path",{d:"M20 21a2 2 0 0 0 2-2v-3.851c0-1.39-2-2.962-2-4.829V8a1 1 0 0 0-1-1h-4a1 1 0 0 0-1 1v11a2 2 0 0 0 2 2z"}],["path",{d:"M 22 16 L 2 16"}],["path",{d:"M4 21a2 2 0 0 1-2-2v-3.851c0-1.39 2-2.962 2-4.829V8a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v11a2 2 0 0 1-2 2z"}],["path",{d:"M9 7V4a1 1 0 0 0-1-1H6a1 1 0 0 0-1 1v3"}]],d4=[["circle",{cx:"12",cy:"11.9",r:"2"}],["path",{d:"M6.7 3.4c-.9 2.5 0 5.2 2.2 6.7C6.5 9 3.7 9.6 2 11.6"}],["path",{d:"m8.9 10.1 1.4.8"}],["path",{d:"M17.3 3.4c.9 2.5 0 5.2-2.2 6.7 2.4-1.2 5.2-.6 6.9 1.5"}],["path",{d:"m15.1 10.1-1.4.8"}],["path",{d:"M16.7 20.8c-2.6-.4-4.6-2.6-4.7-5.3-.2 2.6-2.1 4.8-4.7 5.2"}],["path",{d:"M12 13.9v1.6"}],["path",{d:"M13.5 5.4c-1-.2-2-.2-3 0"}],["path",{d:"M17 16.4c.7-.7 1.2-1.6 1.5-2.5"}],["path",{d:"M5.5 13.9c.3.9.8 1.8 1.5 2.5"}]],c4=[["path",{d:"M16 7h.01"}],["path",{d:"M3.4 18H12a8 8 0 0 0 8-8V7a4 4 0 0 0-7.28-2.3L2 20"}],["path",{d:"m20 7 2 .5-2 .5"}],["path",{d:"M10 18v3"}],["path",{d:"M14 17.75V21"}],["path",{d:"M7 18a6 6 0 0 0 3.84-10.61"}]],M4=[["path",{d:"M11.767 19.089c4.924.868 6.14-6.025 1.216-6.894m-1.216 6.894L5.86 18.047m5.908 1.042-.347 1.97m1.563-8.864c4.924.869 6.14-6.025 1.215-6.893m-1.215 6.893-3.94-.694m5.155-6.2L8.29 4.26m5.908 1.042.348-1.97M7.48 20.364l3.126-17.727"}]],p4=[["circle",{cx:"9",cy:"9",r:"7"}],["circle",{cx:"15",cy:"15",r:"7"}]],i4=[["path",{d:"M3 3h18"}],["path",{d:"M20 7H8"}],["path",{d:"M20 11H8"}],["path",{d:"M10 19h10"}],["path",{d:"M8 15h12"}],["path",{d:"M4 3v14"}],["circle",{cx:"4",cy:"19",r:"2"}]],n4=[["path",{d:"M10 22V7a1 1 0 0 0-1-1H4a2 2 0 0 0-2 2v12a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-5a1 1 0 0 0-1-1H2"}],["rect",{x:"14",y:"2",width:"8",height:"8",rx:"1"}]],l4=[["path",{d:"m7 7 10 10-5 5V2l5 5L7 17"}],["line",{x1:"18",x2:"21",y1:"12",y2:"12"}],["line",{x1:"3",x2:"6",y1:"12",y2:"12"}]],e4=[["path",{d:"m17 17-5 5V12l-5 5"}],["path",{d:"m2 2 20 20"}],["path",{d:"M14.5 9.5 17 7l-5-5v4.5"}]],r4=[["path",{d:"m7 7 10 10-5 5V2l5 5L7 17"}],["path",{d:"M20.83 14.83a4 4 0 0 0 0-5.66"}],["path",{d:"M18 12h.01"}]],o4=[["path",{d:"M6 12h9a4 4 0 0 1 0 8H7a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1h7a4 4 0 0 1 0 8"}]],v4=[["path",{d:"m7 7 10 10-5 5V2l5 5L7 17"}]],$4=[["path",{d:"M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"}],["circle",{cx:"12",cy:"12",r:"4"}]],m4=[["circle",{cx:"11",cy:"13",r:"9"}],["path",{d:"M14.35 4.65 16.3 2.7a2.41 2.41 0 0 1 3.4 0l1.6 1.6a2.4 2.4 0 0 1 0 3.4l-1.95 1.95"}],["path",{d:"m22 2-1.5 1.5"}]],y4=[["path",{d:"M17 10c.7-.7 1.69 0 2.5 0a2.5 2.5 0 1 0 0-5 .5.5 0 0 1-.5-.5 2.5 2.5 0 1 0-5 0c0 .81.7 1.8 0 2.5l-7 7c-.7.7-1.69 0-2.5 0a2.5 2.5 0 0 0 0 5c.28 0 .5.22.5.5a2.5 2.5 0 1 0 5 0c0-.81-.7-1.8 0-2.5Z"}]],s4=[["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}],["path",{d:"m8 13 4-7 4 7"}],["path",{d:"M9.1 11h5.7"}]],g4=[["path",{d:"M12 13h.01"}],["path",{d:"M12 6v3"}],["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}]],u4=[["path",{d:"M12 6v7"}],["path",{d:"M16 8v3"}],["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}],["path",{d:"M8 8v3"}]],C4=[["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}],["path",{d:"m9 9.5 2 2 4-4"}]],H4=[["path",{d:"M5 7a2 2 0 0 0-2 2v11"}],["path",{d:"M5.803 18H5a2 2 0 0 0 0 4h9.5a.5.5 0 0 0 .5-.5V21"}],["path",{d:"M9 15V4a2 2 0 0 1 2-2h9.5a.5.5 0 0 1 .5.5v14a.5.5 0 0 1-.5.5H11a2 2 0 0 1 0-4h10"}]],B=[["path",{d:"M12 17h1.5"}],["path",{d:"M12 22h1.5"}],["path",{d:"M12 2h1.5"}],["path",{d:"M17.5 22H19a1 1 0 0 0 1-1"}],["path",{d:"M17.5 2H19a1 1 0 0 1 1 1v1.5"}],["path",{d:"M20 14v3h-2.5"}],["path",{d:"M20 8.5V10"}],["path",{d:"M4 10V8.5"}],["path",{d:"M4 19.5V14"}],["path",{d:"M4 4.5A2.5 2.5 0 0 1 6.5 2H8"}],["path",{d:"M8 22H6.5a1 1 0 0 1 0-5H8"}]],A4=[["path",{d:"M12 13V7"}],["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}],["path",{d:"m9 10 3 3 3-3"}]],w4=[["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}],["path",{d:"M8 12v-2a4 4 0 0 1 8 0v2"}],["circle",{cx:"15",cy:"12",r:"1"}],["circle",{cx:"9",cy:"12",r:"1"}]],V4=[["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}],["path",{d:"M8.62 9.8A2.25 2.25 0 1 1 12 6.836a2.25 2.25 0 1 1 3.38 2.966l-2.626 2.856a.998.998 0 0 1-1.507 0z"}]],S4=[["path",{d:"m20 13.7-2.1-2.1a2 2 0 0 0-2.8 0L9.7 17"}],["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}],["circle",{cx:"10",cy:"8",r:"2"}]],L4=[["path",{d:"m19 3 1 1"}],["path",{d:"m20 2-4.5 4.5"}],["path",{d:"M20 7.898V21a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}],["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2h7.844"}],["circle",{cx:"14",cy:"8",r:"2"}]],f4=[["path",{d:"M18 6V4a2 2 0 1 0-4 0v2"}],["path",{d:"M20 15v6a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}],["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H10"}],["rect",{x:"12",y:"6",width:"8",height:"5",rx:"1"}]],k4=[["path",{d:"M10 2v8l3-3 3 3V2"}],["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}]],P4=[["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}],["path",{d:"M9 10h6"}]],B4=[["path",{d:"M12 21V7"}],["path",{d:"m16 12 2 2 4-4"}],["path",{d:"M22 6V4a1 1 0 0 0-1-1h-5a4 4 0 0 0-4 4 4 4 0 0 0-4-4H3a1 1 0 0 0-1 1v13a1 1 0 0 0 1 1h6a3 3 0 0 1 3 3 3 3 0 0 1 3-3h6a1 1 0 0 0 1-1v-1.3"}]],D4=[["path",{d:"M12 7v14"}],["path",{d:"M16 12h2"}],["path",{d:"M16 8h2"}],["path",{d:"M3 18a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1h5a4 4 0 0 1 4 4 4 4 0 0 1 4-4h5a1 1 0 0 1 1 1v13a1 1 0 0 1-1 1h-6a3 3 0 0 0-3 3 3 3 0 0 0-3-3z"}],["path",{d:"M6 12h2"}],["path",{d:"M6 8h2"}]],F4=[["path",{d:"M12 7v14"}],["path",{d:"M3 18a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1h5a4 4 0 0 1 4 4 4 4 0 0 1 4-4h5a1 1 0 0 1 1 1v13a1 1 0 0 1-1 1h-6a3 3 0 0 0-3 3 3 3 0 0 0-3-3z"}]],z4=[["path",{d:"M12 7v6"}],["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}],["path",{d:"M9 10h6"}]],b4=[["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}],["path",{d:"M8 11h8"}],["path",{d:"M8 7h6"}]],R4=[["path",{d:"M10 13h4"}],["path",{d:"M12 6v7"}],["path",{d:"M16 8V6H8v2"}],["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}]],T4=[["path",{d:"M12 13V7"}],["path",{d:"M18 2h1a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}],["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2"}],["path",{d:"m9 10 3-3 3 3"}],["path",{d:"m9 5 3-3 3 3"}]],q4=[["path",{d:"M12 13V7"}],["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}],["path",{d:"m9 10 3-3 3 3"}]],U4=[["path",{d:"M15 13a3 3 0 1 0-6 0"}],["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}],["circle",{cx:"12",cy:"8",r:"2"}]],O4=[["path",{d:"m14.5 7-5 5"}],["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}],["path",{d:"m9.5 7 5 5"}]],Z4=[["path",{d:"M4 19.5v-15A2.5 2.5 0 0 1 6.5 2H19a1 1 0 0 1 1 1v18a1 1 0 0 1-1 1H6.5a1 1 0 0 1 0-5H20"}]],G4=[["path",{d:"m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2Z"}],["path",{d:"m9 10 2 2 4-4"}]],I4=[["path",{d:"m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v16z"}],["line",{x1:"15",x2:"9",y1:"10",y2:"10"}]],W4=[["path",{d:"m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v16z"}],["line",{x1:"12",x2:"12",y1:"7",y2:"13"}],["line",{x1:"15",x2:"9",y1:"10",y2:"10"}]],E4=[["path",{d:"m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2Z"}],["path",{d:"m14.5 7.5-5 5"}],["path",{d:"m9.5 7.5 5 5"}]],X4=[["path",{d:"m19 21-7-4-7 4V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v16z"}]],j4=[["path",{d:"M4 9V5a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v4"}],["path",{d:"M8 8v1"}],["path",{d:"M12 8v1"}],["path",{d:"M16 8v1"}],["rect",{width:"20",height:"12",x:"2",y:"9",rx:"2"}],["circle",{cx:"8",cy:"15",r:"2"}],["circle",{cx:"16",cy:"15",r:"2"}]],N4=[["path",{d:"M12 6V2H8"}],["path",{d:"M15 11v2"}],["path",{d:"M2 12h2"}],["path",{d:"M20 12h2"}],["path",{d:"M20 16a2 2 0 0 1-2 2H8.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 4 20.286V8a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2z"}],["path",{d:"M9 11v2"}]],K4=[["path",{d:"M13.67 8H18a2 2 0 0 1 2 2v4.33"}],["path",{d:"M2 14h2"}],["path",{d:"M20 14h2"}],["path",{d:"M22 22 2 2"}],["path",{d:"M8 8H6a2 2 0 0 0-2 2v8a2 2 0 0 0 2 2h12a2 2 0 0 0 1.414-.586"}],["path",{d:"M9 13v2"}],["path",{d:"M9.67 4H12v2.33"}]],Q4=[["path",{d:"M12 8V4H8"}],["rect",{width:"16",height:"12",x:"4",y:"8",rx:"2"}],["path",{d:"M2 14h2"}],["path",{d:"M20 14h2"}],["path",{d:"M15 13v2"}],["path",{d:"M9 13v2"}]],J4=[["path",{d:"M10 3a1 1 0 0 1 1-1h2a1 1 0 0 1 1 1v2a6 6 0 0 0 1.2 3.6l.6.8A6 6 0 0 1 17 13v8a1 1 0 0 1-1 1H8a1 1 0 0 1-1-1v-8a6 6 0 0 1 1.2-3.6l.6-.8A6 6 0 0 0 10 5z"}],["path",{d:"M17 13h-4a1 1 0 0 0-1 1v3a1 1 0 0 0 1 1h4"}]],Y4=[["path",{d:"M17 3h4v4"}],["path",{d:"M18.575 11.082a13 13 0 0 1 1.048 9.027 1.17 1.17 0 0 1-1.914.597L14 17"}],["path",{d:"M7 10 3.29 6.29a1.17 1.17 0 0 1 .6-1.91 13 13 0 0 1 9.03 1.05"}],["path",{d:"M7 14a1.7 1.7 0 0 0-1.207.5l-2.646 2.646A.5.5 0 0 0 3.5 18H5a1 1 0 0 1 1 1v1.5a.5.5 0 0 0 .854.354L9.5 18.207A1.7 1.7 0 0 0 10 17v-2a1 1 0 0 0-1-1z"}],["path",{d:"M9.707 14.293 21 3"}]],_4=[["path",{d:"M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"}],["path",{d:"m3.3 7 8.7 5 8.7-5"}],["path",{d:"M12 22V12"}]],x4=[["path",{d:"M2.97 12.92A2 2 0 0 0 2 14.63v3.24a2 2 0 0 0 .97 1.71l3 1.8a2 2 0 0 0 2.06 0L12 19v-5.5l-5-3-4.03 2.42Z"}],["path",{d:"m7 16.5-4.74-2.85"}],["path",{d:"m7 16.5 5-3"}],["path",{d:"M7 16.5v5.17"}],["path",{d:"M12 13.5V19l3.97 2.38a2 2 0 0 0 2.06 0l3-1.8a2 2 0 0 0 .97-1.71v-3.24a2 2 0 0 0-.97-1.71L17 10.5l-5 3Z"}],["path",{d:"m17 16.5-5-3"}],["path",{d:"m17 16.5 4.74-2.85"}],["path",{d:"M17 16.5v5.17"}],["path",{d:"M7.97 4.42A2 2 0 0 0 7 6.13v4.37l5 3 5-3V6.13a2 2 0 0 0-.97-1.71l-3-1.8a2 2 0 0 0-2.06 0l-3 1.8Z"}],["path",{d:"M12 8 7.26 5.15"}],["path",{d:"m12 8 4.74-2.85"}],["path",{d:"M12 13.5V8"}]],D=[["path",{d:"M8 3H7a2 2 0 0 0-2 2v5a2 2 0 0 1-2 2 2 2 0 0 1 2 2v5c0 1.1.9 2 2 2h1"}],["path",{d:"M16 21h1a2 2 0 0 0 2-2v-5c0-1.1.9-2 2-2a2 2 0 0 1-2-2V5a2 2 0 0 0-2-2h-1"}]],a5=[["path",{d:"M16 3h3a1 1 0 0 1 1 1v16a1 1 0 0 1-1 1h-3"}],["path",{d:"M8 21H5a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1h3"}]],t5=[["path",{d:"M12 5a3 3 0 1 0-5.997.125 4 4 0 0 0-2.526 5.77 4 4 0 0 0 .556 6.588A4 4 0 1 0 12 18Z"}],["path",{d:"M9 13a4.5 4.5 0 0 0 3-4"}],["path",{d:"M6.003 5.125A3 3 0 0 0 6.401 6.5"}],["path",{d:"M3.477 10.896a4 4 0 0 1 .585-.396"}],["path",{d:"M6 18a4 4 0 0 1-1.967-.516"}],["path",{d:"M12 13h4"}],["path",{d:"M12 18h6a2 2 0 0 1 2 2v1"}],["path",{d:"M12 8h8"}],["path",{d:"M16 8V5a2 2 0 0 1 2-2"}],["circle",{cx:"16",cy:"13",r:".5"}],["circle",{cx:"18",cy:"3",r:".5"}],["circle",{cx:"20",cy:"21",r:".5"}],["circle",{cx:"20",cy:"8",r:".5"}]],h5=[["path",{d:"m10.852 14.772-.383.923"}],["path",{d:"m10.852 9.228-.383-.923"}],["path",{d:"m13.148 14.772.382.924"}],["path",{d:"m13.531 8.305-.383.923"}],["path",{d:"m14.772 10.852.923-.383"}],["path",{d:"m14.772 13.148.923.383"}],["path",{d:"M17.598 6.5A3 3 0 1 0 12 5a3 3 0 0 0-5.63-1.446 3 3 0 0 0-.368 1.571 4 4 0 0 0-2.525 5.771"}],["path",{d:"M17.998 5.125a4 4 0 0 1 2.525 5.771"}],["path",{d:"M19.505 10.294a4 4 0 0 1-1.5 7.706"}],["path",{d:"M4.032 17.483A4 4 0 0 0 11.464 20c.18-.311.892-.311 1.072 0a4 4 0 0 0 7.432-2.516"}],["path",{d:"M4.5 10.291A4 4 0 0 0 6 18"}],["path",{d:"M6.002 5.125a3 3 0 0 0 .4 1.375"}],["path",{d:"m9.228 10.852-.923-.383"}],["path",{d:"m9.228 13.148-.923.383"}],["circle",{cx:"12",cy:"12",r:"3"}]],d5=[["path",{d:"M12 18V5"}],["path",{d:"M15 13a4.17 4.17 0 0 1-3-4 4.17 4.17 0 0 1-3 4"}],["path",{d:"M17.598 6.5A3 3 0 1 0 12 5a3 3 0 1 0-5.598 1.5"}],["path",{d:"M17.997 5.125a4 4 0 0 1 2.526 5.77"}],["path",{d:"M18 18a4 4 0 0 0 2-7.464"}],["path",{d:"M19.967 17.483A4 4 0 1 1 12 18a4 4 0 1 1-7.967-.517"}],["path",{d:"M6 18a4 4 0 0 1-2-7.464"}],["path",{d:"M6.003 5.125a4 4 0 0 0-2.526 5.77"}]],c5=[["path",{d:"M16 3v2.107"}],["path",{d:"M17 9c1 3 2.5 3.5 3.5 4.5A5 5 0 0 1 22 17a5 5 0 0 1-10 0c0-.3 0-.6.1-.9a2 2 0 1 0 3.3-2C13 11.5 16 9 17 9"}],["path",{d:"M21 8.274V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h3.938"}],["path",{d:"M3 15h5.253"}],["path",{d:"M3 9h8.228"}],["path",{d:"M8 15v6"}],["path",{d:"M8 3v6"}]],M5=[["path",{d:"M12 9v1.258"}],["path",{d:"M16 3v5.46"}],["path",{d:"M21 9.118V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h5.75"}],["path",{d:"M22 17.5c0 2.499-1.75 3.749-3.83 4.474a.5.5 0 0 1-.335-.005c-2.085-.72-3.835-1.97-3.835-4.47V14a.5.5 0 0 1 .5-.499c1 0 2.25-.6 3.12-1.36a.6.6 0 0 1 .76-.001c.875.765 2.12 1.36 3.12 1.36a.5.5 0 0 1 .5.5z"}],["path",{d:"M3 15h7"}],["path",{d:"M3 9h12.142"}],["path",{d:"M8 15v6"}],["path",{d:"M8 3v6"}]],p5=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M12 9v6"}],["path",{d:"M16 15v6"}],["path",{d:"M16 3v6"}],["path",{d:"M3 15h18"}],["path",{d:"M3 9h18"}],["path",{d:"M8 15v6"}],["path",{d:"M8 3v6"}]],i5=[["path",{d:"M12 12h.01"}],["path",{d:"M16 6V4a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v2"}],["path",{d:"M22 13a18.15 18.15 0 0 1-20 0"}],["rect",{width:"20",height:"14",x:"2",y:"6",rx:"2"}]],n5=[["path",{d:"M10 20v2"}],["path",{d:"M14 20v2"}],["path",{d:"M18 20v2"}],["path",{d:"M21 20H3"}],["path",{d:"M6 20v2"}],["path",{d:"M8 16V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v12"}],["rect",{x:"4",y:"6",width:"16",height:"10",rx:"2"}]],l5=[["path",{d:"M12 11v4"}],["path",{d:"M14 13h-4"}],["path",{d:"M16 6V4a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v2"}],["path",{d:"M18 6v14"}],["path",{d:"M6 6v14"}],["rect",{width:"20",height:"14",x:"2",y:"6",rx:"2"}]],e5=[["path",{d:"M16 20V4a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v16"}],["rect",{width:"20",height:"14",x:"2",y:"6",rx:"2"}]],r5=[["rect",{x:"8",y:"8",width:"8",height:"8",rx:"2"}],["path",{d:"M4 10a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2"}],["path",{d:"M14 20a2 2 0 0 0 2 2h4a2 2 0 0 0 2-2v-4a2 2 0 0 0-2-2"}]],o5=[["path",{d:"m16 22-1-4"}],["path",{d:"M19 13.99a1 1 0 0 0 1-1V12a2 2 0 0 0-2-2h-3a1 1 0 0 1-1-1V4a2 2 0 0 0-4 0v5a1 1 0 0 1-1 1H6a2 2 0 0 0-2 2v.99a1 1 0 0 0 1 1"}],["path",{d:"M5 14h14l1.973 6.767A1 1 0 0 1 20 22H4a1 1 0 0 1-.973-1.233z"}],["path",{d:"m8 22 1-4"}]],v5=[["path",{d:"m11 10 3 3"}],["path",{d:"M6.5 21A3.5 3.5 0 1 0 3 17.5a2.62 2.62 0 0 1-.708 1.792A1 1 0 0 0 3 21z"}],["path",{d:"M9.969 17.031 21.378 5.624a1 1 0 0 0-3.002-3.002L6.967 14.031"}]],$5=[["path",{d:"M7.2 14.8a2 2 0 0 1 2 2"}],["circle",{cx:"18.5",cy:"8.5",r:"3.5"}],["circle",{cx:"7.5",cy:"16.5",r:"5.5"}],["circle",{cx:"7.5",cy:"4.5",r:"2.5"}]],m5=[["path",{d:"M12 20v-8"}],["path",{d:"M14.12 3.88 16 2"}],["path",{d:"M15 7.13V6a3 3 0 0 0-5.14-2.1L8 2"}],["path",{d:"M18 12.34V11a4 4 0 0 0-4-4h-1.3"}],["path",{d:"m2 2 20 20"}],["path",{d:"M21 5a4 4 0 0 1-3.55 3.97"}],["path",{d:"M22 13h-3.34"}],["path",{d:"M3 21a4 4 0 0 1 3.81-4"}],["path",{d:"M6 13H2"}],["path",{d:"M7.7 7.7A4 4 0 0 0 6 11v3a6 6 0 0 0 11.13 3.13"}]],y5=[["path",{d:"M10 19.655A6 6 0 0 1 6 14v-3a4 4 0 0 1 4-4h4a4 4 0 0 1 4 3.97"}],["path",{d:"M14 15.003a1 1 0 0 1 1.517-.859l4.997 2.997a1 1 0 0 1 0 1.718l-4.997 2.997a1 1 0 0 1-1.517-.86z"}],["path",{d:"M14.12 3.88 16 2"}],["path",{d:"M21 5a4 4 0 0 1-3.55 3.97"}],["path",{d:"M3 21a4 4 0 0 1 3.81-4"}],["path",{d:"M3 5a4 4 0 0 0 3.55 3.97"}],["path",{d:"M6 13H2"}],["path",{d:"m8 2 1.88 1.88"}],["path",{d:"M9 7.13V6a3 3 0 1 1 6 0v1.13"}]],s5=[["path",{d:"M12 20v-9"}],["path",{d:"M14 7a4 4 0 0 1 4 4v3a6 6 0 0 1-12 0v-3a4 4 0 0 1 4-4z"}],["path",{d:"M14.12 3.88 16 2"}],["path",{d:"M21 21a4 4 0 0 0-3.81-4"}],["path",{d:"M21 5a4 4 0 0 1-3.55 3.97"}],["path",{d:"M22 13h-4"}],["path",{d:"M3 21a4 4 0 0 1 3.81-4"}],["path",{d:"M3 5a4 4 0 0 0 3.55 3.97"}],["path",{d:"M6 13H2"}],["path",{d:"m8 2 1.88 1.88"}],["path",{d:"M9 7.13V6a3 3 0 1 1 6 0v1.13"}]],g5=[["path",{d:"M6 22V4a2 2 0 0 1 2-2h8a2 2 0 0 1 2 2v18Z"}],["path",{d:"M6 12H4a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2h2"}],["path",{d:"M18 9h2a2 2 0 0 1 2 2v9a2 2 0 0 1-2 2h-2"}],["path",{d:"M10 6h4"}],["path",{d:"M10 10h4"}],["path",{d:"M10 14h4"}],["path",{d:"M10 18h4"}]],u5=[["path",{d:"M4 6 2 7"}],["path",{d:"M10 6h4"}],["path",{d:"m22 7-2-1"}],["rect",{width:"16",height:"16",x:"4",y:"3",rx:"2"}],["path",{d:"M4 11h16"}],["path",{d:"M8 15h.01"}],["path",{d:"M16 15h.01"}],["path",{d:"M6 19v2"}],["path",{d:"M18 21v-2"}]],C5=[["path",{d:"M12 10h.01"}],["path",{d:"M12 14h.01"}],["path",{d:"M12 6h.01"}],["path",{d:"M16 10h.01"}],["path",{d:"M16 14h.01"}],["path",{d:"M16 6h.01"}],["path",{d:"M8 10h.01"}],["path",{d:"M8 14h.01"}],["path",{d:"M8 6h.01"}],["path",{d:"M9 22v-3a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v3"}],["rect",{x:"4",y:"2",width:"16",height:"20",rx:"2"}]],H5=[["path",{d:"M8 6v6"}],["path",{d:"M15 6v6"}],["path",{d:"M2 12h19.6"}],["path",{d:"M18 18h3s.5-1.7.8-2.8c.1-.4.2-.8.2-1.2 0-.4-.1-.8-.2-1.2l-1.4-5C20.1 6.8 19.1 6 18 6H4a2 2 0 0 0-2 2v10h3"}],["circle",{cx:"7",cy:"18",r:"2"}],["path",{d:"M9 18h5"}],["circle",{cx:"16",cy:"18",r:"2"}]],A5=[["path",{d:"M10 3h.01"}],["path",{d:"M14 2h.01"}],["path",{d:"m2 9 20-5"}],["path",{d:"M12 12V6.5"}],["rect",{width:"16",height:"10",x:"4",y:"12",rx:"3"}],["path",{d:"M9 12v5"}],["path",{d:"M15 12v5"}],["path",{d:"M4 17h16"}]],w5=[["path",{d:"M17 19a1 1 0 0 1-1-1v-2a2 2 0 0 1 2-2h2a2 2 0 0 1 2 2v2a1 1 0 0 1-1 1z"}],["path",{d:"M17 21v-2"}],["path",{d:"M19 14V6.5a1 1 0 0 0-7 0v11a1 1 0 0 1-7 0V10"}],["path",{d:"M21 21v-2"}],["path",{d:"M3 5V3"}],["path",{d:"M4 10a2 2 0 0 1-2-2V6a1 1 0 0 1 1-1h4a1 1 0 0 1 1 1v2a2 2 0 0 1-2 2z"}],["path",{d:"M7 5V3"}]],V5=[["path",{d:"M16 13H3"}],["path",{d:"M16 17H3"}],["path",{d:"m7.2 7.9-3.388 2.5A2 2 0 0 0 3 12.01V20a1 1 0 0 0 1 1h16a1 1 0 0 0 1-1v-8.654c0-2-2.44-6.026-6.44-8.026a1 1 0 0 0-1.082.057L10.4 5.6"}],["circle",{cx:"9",cy:"7",r:"2"}]],S5=[["rect",{width:"16",height:"20",x:"4",y:"2",rx:"2"}],["line",{x1:"8",x2:"16",y1:"6",y2:"6"}],["line",{x1:"16",x2:"16",y1:"14",y2:"18"}],["path",{d:"M16 10h.01"}],["path",{d:"M12 10h.01"}],["path",{d:"M8 10h.01"}],["path",{d:"M12 14h.01"}],["path",{d:"M8 14h.01"}],["path",{d:"M12 18h.01"}],["path",{d:"M8 18h.01"}]],L5=[["path",{d:"M11 14h1v4"}],["path",{d:"M16 2v4"}],["path",{d:"M3 10h18"}],["path",{d:"M8 2v4"}],["rect",{x:"3",y:"4",width:"18",height:"18",rx:"2"}]],f5=[["path",{d:"M20 21v-8a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v8"}],["path",{d:"M4 16s.5-1 2-1 2.5 2 4 2 2.5-2 4-2 2.5 2 4 2 2-1 2-1"}],["path",{d:"M2 21h20"}],["path",{d:"M7 8v3"}],["path",{d:"M12 8v3"}],["path",{d:"M17 8v3"}],["path",{d:"M7 4h.01"}],["path",{d:"M12 4h.01"}],["path",{d:"M17 4h.01"}]],k5=[["path",{d:"m14 18 4 4 4-4"}],["path",{d:"M16 2v4"}],["path",{d:"M18 14v8"}],["path",{d:"M21 11.354V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h7.343"}],["path",{d:"M3 10h18"}],["path",{d:"M8 2v4"}]],P5=[["path",{d:"m14 18 4-4 4 4"}],["path",{d:"M16 2v4"}],["path",{d:"M18 22v-8"}],["path",{d:"M21 11.343V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h9"}],["path",{d:"M3 10h18"}],["path",{d:"M8 2v4"}]],B5=[["path",{d:"M8 2v4"}],["path",{d:"M16 2v4"}],["path",{d:"M21 14V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h8"}],["path",{d:"M3 10h18"}],["path",{d:"m16 20 2 2 4-4"}]],D5=[["path",{d:"M8 2v4"}],["path",{d:"M16 2v4"}],["rect",{width:"18",height:"18",x:"3",y:"4",rx:"2"}],["path",{d:"M3 10h18"}],["path",{d:"m9 16 2 2 4-4"}]],F5=[["path",{d:"M16 14v2.2l1.6 1"}],["path",{d:"M16 2v4"}],["path",{d:"M21 7.5V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h3.5"}],["path",{d:"M3 10h5"}],["path",{d:"M8 2v4"}],["circle",{cx:"16",cy:"16",r:"6"}]],z5=[["path",{d:"m15.228 16.852-.923-.383"}],["path",{d:"m15.228 19.148-.923.383"}],["path",{d:"M16 2v4"}],["path",{d:"m16.47 14.305.382.923"}],["path",{d:"m16.852 20.772-.383.924"}],["path",{d:"m19.148 15.228.383-.923"}],["path",{d:"m19.53 21.696-.382-.924"}],["path",{d:"m20.772 16.852.924-.383"}],["path",{d:"m20.772 19.148.924.383"}],["path",{d:"M21 10.592V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h6"}],["path",{d:"M3 10h18"}],["path",{d:"M8 2v4"}],["circle",{cx:"18",cy:"18",r:"3"}]],b5=[["path",{d:"M8 2v4"}],["path",{d:"M16 2v4"}],["rect",{width:"18",height:"18",x:"3",y:"4",rx:"2"}],["path",{d:"M3 10h18"}],["path",{d:"M8 14h.01"}],["path",{d:"M12 14h.01"}],["path",{d:"M16 14h.01"}],["path",{d:"M8 18h.01"}],["path",{d:"M12 18h.01"}],["path",{d:"M16 18h.01"}]],R5=[["path",{d:"M8 2v4"}],["path",{d:"M16 2v4"}],["path",{d:"M21 17V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h11Z"}],["path",{d:"M3 10h18"}],["path",{d:"M15 22v-4a2 2 0 0 1 2-2h4"}]],T5=[["path",{d:"M12.127 22H5a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v5.125"}],["path",{d:"M14.62 18.8A2.25 2.25 0 1 1 18 15.836a2.25 2.25 0 1 1 3.38 2.966l-2.626 2.856a.998.998 0 0 1-1.507 0z"}],["path",{d:"M16 2v4"}],["path",{d:"M3 10h18"}],["path",{d:"M8 2v4"}]],q5=[["path",{d:"M8 2v4"}],["path",{d:"M16 2v4"}],["rect",{width:"18",height:"18",x:"3",y:"4",rx:"2"}],["path",{d:"M3 10h18"}],["path",{d:"M10 16h4"}]],U5=[["path",{d:"M16 19h6"}],["path",{d:"M16 2v4"}],["path",{d:"M21 15V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h8.5"}],["path",{d:"M3 10h18"}],["path",{d:"M8 2v4"}]],O5=[["path",{d:"M4.2 4.2A2 2 0 0 0 3 6v14a2 2 0 0 0 2 2h14a2 2 0 0 0 1.82-1.18"}],["path",{d:"M21 15.5V6a2 2 0 0 0-2-2H9.5"}],["path",{d:"M16 2v4"}],["path",{d:"M3 10h7"}],["path",{d:"M21 10h-5.5"}],["path",{d:"m2 2 20 20"}]],Z5=[["path",{d:"M8 2v4"}],["path",{d:"M16 2v4"}],["rect",{width:"18",height:"18",x:"3",y:"4",rx:"2"}],["path",{d:"M3 10h18"}],["path",{d:"M10 16h4"}],["path",{d:"M12 14v4"}]],G5=[["path",{d:"M16 19h6"}],["path",{d:"M16 2v4"}],["path",{d:"M19 16v6"}],["path",{d:"M21 12.598V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h8.5"}],["path",{d:"M3 10h18"}],["path",{d:"M8 2v4"}]],I5=[["rect",{width:"18",height:"18",x:"3",y:"4",rx:"2"}],["path",{d:"M16 2v4"}],["path",{d:"M3 10h18"}],["path",{d:"M8 2v4"}],["path",{d:"M17 14h-6"}],["path",{d:"M13 18H7"}],["path",{d:"M7 14h.01"}],["path",{d:"M17 18h.01"}]],W5=[["path",{d:"M11 10v4h4"}],["path",{d:"m11 14 1.535-1.605a5 5 0 0 1 8 1.5"}],["path",{d:"M16 2v4"}],["path",{d:"m21 18-1.535 1.605a5 5 0 0 1-8-1.5"}],["path",{d:"M21 22v-4h-4"}],["path",{d:"M21 8.5V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h4.3"}],["path",{d:"M3 10h4"}],["path",{d:"M8 2v4"}]],E5=[["path",{d:"M16 2v4"}],["path",{d:"M21 11.75V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h7.25"}],["path",{d:"m22 22-1.875-1.875"}],["path",{d:"M3 10h18"}],["path",{d:"M8 2v4"}],["circle",{cx:"18",cy:"18",r:"3"}]],X5=[["path",{d:"M8 2v4"}],["path",{d:"M16 2v4"}],["path",{d:"M21 13V6a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h8"}],["path",{d:"M3 10h18"}],["path",{d:"m17 22 5-5"}],["path",{d:"m17 17 5 5"}]],j5=[["path",{d:"M8 2v4"}],["path",{d:"M16 2v4"}],["rect",{width:"18",height:"18",x:"3",y:"4",rx:"2"}],["path",{d:"M3 10h18"}],["path",{d:"m14 14-4 4"}],["path",{d:"m10 14 4 4"}]],N5=[["path",{d:"M8 2v4"}],["path",{d:"M16 2v4"}],["rect",{width:"18",height:"18",x:"3",y:"4",rx:"2"}],["path",{d:"M3 10h18"}]],K5=[["path",{d:"M14.564 14.558a3 3 0 1 1-4.122-4.121"}],["path",{d:"m2 2 20 20"}],["path",{d:"M20 20H4a2 2 0 0 1-2-2V9a2 2 0 0 1 2-2h1.997a2 2 0 0 0 .819-.175"}],["path",{d:"M9.695 4.024A2 2 0 0 1 10.004 4h3.993a2 2 0 0 1 1.76 1.05l.486.9A2 2 0 0 0 18.003 7H20a2 2 0 0 1 2 2v7.344"}]],Q5=[["path",{d:"M13.997 4a2 2 0 0 1 1.76 1.05l.486.9A2 2 0 0 0 18.003 7H20a2 2 0 0 1 2 2v9a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V9a2 2 0 0 1 2-2h1.997a2 2 0 0 0 1.759-1.048l.489-.904A2 2 0 0 1 10.004 4z"}],["circle",{cx:"12",cy:"13",r:"3"}]],J5=[["path",{d:"M5.7 21a2 2 0 0 1-3.5-2l8.6-14a6 6 0 0 1 10.4 6 2 2 0 1 1-3.464-2 2 2 0 1 0-3.464-2Z"}],["path",{d:"M17.75 7 15 2.1"}],["path",{d:"M10.9 4.8 13 9"}],["path",{d:"m7.9 9.7 2 4.4"}],["path",{d:"M4.9 14.7 7 18.9"}]],Y5=[["path",{d:"M10 10v7.9"}],["path",{d:"M11.802 6.145a5 5 0 0 1 6.053 6.053"}],["path",{d:"M14 6.1v2.243"}],["path",{d:"m15.5 15.571-.964.964a5 5 0 0 1-7.071 0 5 5 0 0 1 0-7.07l.964-.965"}],["path",{d:"M16 7V3a1 1 0 0 1 1.707-.707 2.5 2.5 0 0 0 2.152.717 1 1 0 0 1 1.131 1.131 2.5 2.5 0 0 0 .717 2.152A1 1 0 0 1 21 8h-4"}],["path",{d:"m2 2 20 20"}],["path",{d:"M8 17v4a1 1 0 0 1-1.707.707 2.5 2.5 0 0 0-2.152-.717 1 1 0 0 1-1.131-1.131 2.5 2.5 0 0 0-.717-2.152A1 1 0 0 1 3 16h4"}]],_5=[["path",{d:"M10 7v10.9"}],["path",{d:"M14 6.1V17"}],["path",{d:"M16 7V3a1 1 0 0 1 1.707-.707 2.5 2.5 0 0 0 2.152.717 1 1 0 0 1 1.131 1.131 2.5 2.5 0 0 0 .717 2.152A1 1 0 0 1 21 8h-4"}],["path",{d:"M16.536 7.465a5 5 0 0 0-7.072 0l-2 2a5 5 0 0 0 0 7.07 5 5 0 0 0 7.072 0l2-2a5 5 0 0 0 0-7.07"}],["path",{d:"M8 17v4a1 1 0 0 1-1.707.707 2.5 2.5 0 0 0-2.152-.717 1 1 0 0 1-1.131-1.131 2.5 2.5 0 0 0-.717-2.152A1 1 0 0 1 3 16h4"}]],x5=[["path",{d:"M10.5 5H19a2 2 0 0 1 2 2v8.5"}],["path",{d:"M17 11h-.5"}],["path",{d:"M19 19H5a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2"}],["path",{d:"m2 2 20 20"}],["path",{d:"M7 11h4"}],["path",{d:"M7 15h2.5"}]],F=[["rect",{width:"18",height:"14",x:"3",y:"5",rx:"2",ry:"2"}],["path",{d:"M7 15h4M15 15h2M7 11h2M13 11h4"}]],a3=[["path",{d:"M12 22v-4"}],["path",{d:"M7 12c-1.5 0-4.5 1.5-5 3 3.5 1.5 6 1 6 1-1.5 1.5-2 3.5-2 5 2.5 0 4.5-1.5 6-3 1.5 1.5 3.5 3 6 3 0-1.5-.5-3.5-2-5 0 0 2.5.5 6-1-.5-1.5-3.5-3-5-3 1.5-1 4-4 4-6-2.5 0-5.5 1.5-7 3 0-2.5-.5-5-2-7-1.5 2-2 4.5-2 7-1.5-1.5-4.5-3-7-3 0 2 2.5 5 4 6"}]],t3=[["path",{d:"m21 8-2 2-1.5-3.7A2 2 0 0 0 15.646 5H8.4a2 2 0 0 0-1.903 1.257L5 10 3 8"}],["path",{d:"M7 14h.01"}],["path",{d:"M17 14h.01"}],["rect",{width:"18",height:"8",x:"3",y:"10",rx:"2"}],["path",{d:"M5 18v2"}],["path",{d:"M19 18v2"}]],h3=[["path",{d:"M10 2h4"}],["path",{d:"m21 8-2 2-1.5-3.7A2 2 0 0 0 15.646 5H8.4a2 2 0 0 0-1.903 1.257L5 10 3 8"}],["path",{d:"M7 14h.01"}],["path",{d:"M17 14h.01"}],["rect",{width:"18",height:"8",x:"3",y:"10",rx:"2"}],["path",{d:"M5 18v2"}],["path",{d:"M19 18v2"}]],d3=[["path",{d:"M19 17h2c.6 0 1-.4 1-1v-3c0-.9-.7-1.7-1.5-1.9C18.7 10.6 16 10 16 10s-1.3-1.4-2.2-2.3c-.5-.4-1.1-.7-1.8-.7H5c-.6 0-1.1.4-1.4.9l-1.4 2.9A3.7 3.7 0 0 0 2 12v4c0 .6.4 1 1 1h2"}],["circle",{cx:"7",cy:"17",r:"2"}],["path",{d:"M9 17h6"}],["circle",{cx:"17",cy:"17",r:"2"}]],c3=[["path",{d:"M18 19V9a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v8a2 2 0 0 0 2 2h2"}],["path",{d:"M2 9h3a1 1 0 0 1 1 1v2a1 1 0 0 1-1 1H2"}],["path",{d:"M22 17v1a1 1 0 0 1-1 1H10v-9a1 1 0 0 1 1-1h2a1 1 0 0 1 1 1v9"}],["circle",{cx:"8",cy:"19",r:"2"}]],M3=[["path",{d:"M12 14v4"}],["path",{d:"M14.172 2a2 2 0 0 1 1.414.586l3.828 3.828A2 2 0 0 1 20 7.828V20a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2z"}],["path",{d:"M8 14h8"}],["rect",{x:"8",y:"10",width:"8",height:"8",rx:"1"}]],p3=[["path",{d:"M2.27 21.7s9.87-3.5 12.73-6.36a4.5 4.5 0 0 0-6.36-6.37C5.77 11.84 2.27 21.7 2.27 21.7zM8.64 14l-2.05-2.04M15.34 15l-2.46-2.46"}],["path",{d:"M22 9s-1.33-2-3.5-2C16.86 7 15 9 15 9s1.33 2 3.5 2S22 9 22 9z"}],["path",{d:"M15 2s-2 1.33-2 3.5S15 9 15 9s2-1.84 2-3.5C17 3.33 15 2 15 2z"}]],i3=[["path",{d:"M10 9v7"}],["path",{d:"M14 6v10"}],["circle",{cx:"17.5",cy:"12.5",r:"3.5"}],["circle",{cx:"6.5",cy:"12.5",r:"3.5"}]],n3=[["path",{d:"m2 16 4.039-9.69a.5.5 0 0 1 .923 0L11 16"}],["path",{d:"M22 9v7"}],["path",{d:"M3.304 13h6.392"}],["circle",{cx:"18.5",cy:"12.5",r:"3.5"}]],l3=[["path",{d:"M15 11h4.5a1 1 0 0 1 0 5h-4a.5.5 0 0 1-.5-.5v-9a.5.5 0 0 1 .5-.5h3a1 1 0 0 1 0 5"}],["path",{d:"m2 16 4.039-9.69a.5.5 0 0 1 .923 0L11 16"}],["path",{d:"M3.304 13h6.392"}]],e3=[["rect",{width:"20",height:"16",x:"2",y:"4",rx:"2"}],["circle",{cx:"8",cy:"10",r:"2"}],["path",{d:"M8 12h8"}],["circle",{cx:"16",cy:"10",r:"2"}],["path",{d:"m6 20 .7-2.9A1.4 1.4 0 0 1 8.1 16h7.8a1.4 1.4 0 0 1 1.4 1l.7 3"}]],r3=[["path",{d:"M2 8V6a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2h-6"}],["path",{d:"M2 12a9 9 0 0 1 8 8"}],["path",{d:"M2 16a5 5 0 0 1 4 4"}],["line",{x1:"2",x2:"2.01",y1:"20",y2:"20"}]],o3=[["path",{d:"M10 5V3"}],["path",{d:"M14 5V3"}],["path",{d:"M15 21v-3a3 3 0 0 0-6 0v3"}],["path",{d:"M18 3v8"}],["path",{d:"M18 5H6"}],["path",{d:"M22 11H2"}],["path",{d:"M22 9v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V9"}],["path",{d:"M6 3v8"}]],v3=[["path",{d:"M12 5c.67 0 1.35.09 2 .26 1.78-2 5.03-2.84 6.42-2.26 1.4.58-.42 7-.42 7 .57 1.07 1 2.24 1 3.44C21 17.9 16.97 21 12 21s-9-3-9-7.56c0-1.25.5-2.4 1-3.44 0 0-1.89-6.42-.5-7 1.39-.58 4.72.23 6.5 2.23A9.04 9.04 0 0 1 12 5Z"}],["path",{d:"M8 14v.5"}],["path",{d:"M16 14v.5"}],["path",{d:"M11.25 16.25h1.5L12 17l-.75-.75Z"}]],$3=[["path",{d:"M16.75 12h3.632a1 1 0 0 1 .894 1.447l-2.034 4.069a1 1 0 0 1-1.708.134l-2.124-2.97"}],["path",{d:"M17.106 9.053a1 1 0 0 1 .447 1.341l-3.106 6.211a1 1 0 0 1-1.342.447L3.61 12.3a2.92 2.92 0 0 1-1.3-3.91L3.69 5.6a2.92 2.92 0 0 1 3.92-1.3z"}],["path",{d:"M2 19h3.76a2 2 0 0 0 1.8-1.1L9 15"}],["path",{d:"M2 21v-4"}],["path",{d:"M7 9h.01"}]],z=[["path",{d:"M3 3v16a2 2 0 0 0 2 2h16"}],["path",{d:"M7 11.207a.5.5 0 0 1 .146-.353l2-2a.5.5 0 0 1 .708 0l3.292 3.292a.5.5 0 0 0 .708 0l4.292-4.292a.5.5 0 0 1 .854.353V16a1 1 0 0 1-1 1H8a1 1 0 0 1-1-1z"}]],b=[["path",{d:"M3 3v16a2 2 0 0 0 2 2h16"}],["rect",{x:"7",y:"13",width:"9",height:"4",rx:"1"}],["rect",{x:"7",y:"5",width:"12",height:"4",rx:"1"}]],m3=[["path",{d:"M3 3v16a2 2 0 0 0 2 2h16"}],["path",{d:"M7 11h8"}],["path",{d:"M7 16h3"}],["path",{d:"M7 6h12"}]],y3=[["path",{d:"M3 3v16a2 2 0 0 0 2 2h16"}],["path",{d:"M7 11h8"}],["path",{d:"M7 16h12"}],["path",{d:"M7 6h3"}]],s3=[["path",{d:"M11 13v4"}],["path",{d:"M15 5v4"}],["path",{d:"M3 3v16a2 2 0 0 0 2 2h16"}],["rect",{x:"7",y:"13",width:"9",height:"4",rx:"1"}],["rect",{x:"7",y:"5",width:"12",height:"4",rx:"1"}]],R=[["path",{d:"M3 3v16a2 2 0 0 0 2 2h16"}],["path",{d:"M7 16h8"}],["path",{d:"M7 11h12"}],["path",{d:"M7 6h3"}]],T=[["path",{d:"M9 5v4"}],["rect",{width:"4",height:"6",x:"7",y:"9",rx:"1"}],["path",{d:"M9 15v2"}],["path",{d:"M17 3v2"}],["rect",{width:"4",height:"8",x:"15",y:"5",rx:"1"}],["path",{d:"M17 13v3"}],["path",{d:"M3 3v16a2 2 0 0 0 2 2h16"}]],q=[["path",{d:"M3 3v16a2 2 0 0 0 2 2h16"}],["rect",{x:"15",y:"5",width:"4",height:"12",rx:"1"}],["rect",{x:"7",y:"8",width:"4",height:"9",rx:"1"}]],g3=[["path",{d:"M13 17V9"}],["path",{d:"M18 17v-3"}],["path",{d:"M3 3v16a2 2 0 0 0 2 2h16"}],["path",{d:"M8 17V5"}]],U=[["path",{d:"M13 17V9"}],["path",{d:"M18 17V5"}],["path",{d:"M3 3v16a2 2 0 0 0 2 2h16"}],["path",{d:"M8 17v-3"}]],u3=[["path",{d:"M11 13H7"}],["path",{d:"M19 9h-4"}],["path",{d:"M3 3v16a2 2 0 0 0 2 2h16"}],["rect",{x:"15",y:"5",width:"4",height:"12",rx:"1"}],["rect",{x:"7",y:"8",width:"4",height:"9",rx:"1"}]],O=[["path",{d:"M3 3v16a2 2 0 0 0 2 2h16"}],["path",{d:"M18 17V9"}],["path",{d:"M13 17V5"}],["path",{d:"M8 17v-3"}]],C3=[["path",{d:"M10 6h8"}],["path",{d:"M12 16h6"}],["path",{d:"M3 3v16a2 2 0 0 0 2 2h16"}],["path",{d:"M8 11h7"}]],Z=[["path",{d:"M3 3v16a2 2 0 0 0 2 2h16"}],["path",{d:"m19 9-5 5-4-4-3 3"}]],H3=[["path",{d:"m13.11 7.664 1.78 2.672"}],["path",{d:"m14.162 12.788-3.324 1.424"}],["path",{d:"m20 4-6.06 1.515"}],["path",{d:"M3 3v16a2 2 0 0 0 2 2h16"}],["circle",{cx:"12",cy:"6",r:"2"}],["circle",{cx:"16",cy:"12",r:"2"}],["circle",{cx:"9",cy:"15",r:"2"}]],A3=[["path",{d:"M5 21V3"}],["path",{d:"M12 21V9"}],["path",{d:"M19 21v-6"}]],G=[["path",{d:"M5 21v-6"}],["path",{d:"M12 21V9"}],["path",{d:"M19 21V3"}]],I=[["path",{d:"M5 21v-6"}],["path",{d:"M12 21V3"}],["path",{d:"M19 21V9"}]],w3=[["path",{d:"M12 16v5"}],["path",{d:"M16 14v7"}],["path",{d:"M20 10v11"}],["path",{d:"m22 3-8.646 8.646a.5.5 0 0 1-.708 0L9.354 8.354a.5.5 0 0 0-.707 0L2 15"}],["path",{d:"M4 18v3"}],["path",{d:"M8 14v7"}]],W=[["path",{d:"M6 5h12"}],["path",{d:"M4 12h10"}],["path",{d:"M12 19h8"}]],E=[["path",{d:"M21 12c.552 0 1.005-.449.95-.998a10 10 0 0 0-8.953-8.951c-.55-.055-.998.398-.998.95v8a1 1 0 0 0 1 1z"}],["path",{d:"M21.21 15.89A10 10 0 1 1 8 2.83"}]],X=[["circle",{cx:"7.5",cy:"7.5",r:".5",fill:"currentColor"}],["circle",{cx:"18.5",cy:"5.5",r:".5",fill:"currentColor"}],["circle",{cx:"11.5",cy:"11.5",r:".5",fill:"currentColor"}],["circle",{cx:"7.5",cy:"16.5",r:".5",fill:"currentColor"}],["circle",{cx:"17.5",cy:"14.5",r:".5",fill:"currentColor"}],["path",{d:"M3 3v16a2 2 0 0 0 2 2h16"}]],V3=[["path",{d:"M3 3v16a2 2 0 0 0 2 2h16"}],["path",{d:"M7 16c.5-2 1.5-7 4-7 2 0 2 3 4 3 2.5 0 4.5-5 5-7"}]],S3=[["path",{d:"M18 6 7 17l-5-5"}],["path",{d:"m22 10-7.5 7.5L13 16"}]],L3=[["path",{d:"M20 4L9 15"}],["path",{d:"M21 19L3 19"}],["path",{d:"M9 15L4 10"}]],f3=[["path",{d:"M20 6 9 17l-5-5"}]],k3=[["path",{d:"M17 21a1 1 0 0 0 1-1v-5.35c0-.457.316-.844.727-1.041a4 4 0 0 0-2.134-7.589 5 5 0 0 0-9.186 0 4 4 0 0 0-2.134 7.588c.411.198.727.585.727 1.041V20a1 1 0 0 0 1 1Z"}],["path",{d:"M6 17h12"}]],P3=[["path",{d:"M2 17a5 5 0 0 0 10 0c0-2.76-2.5-5-5-3-2.5-2-5 .24-5 3Z"}],["path",{d:"M12 17a5 5 0 0 0 10 0c0-2.76-2.5-5-5-3-2.5-2-5 .24-5 3Z"}],["path",{d:"M7 14c3.22-2.91 4.29-8.75 5-12 1.66 2.38 4.94 9 5 12"}],["path",{d:"M22 9c-4.29 0-7.14-2.33-10-7 5.71 0 10 4.67 10 7Z"}]],B3=[["path",{d:"m17 18-6-6 6-6"}],["path",{d:"M7 6v12"}]],D3=[["path",{d:"m6 9 6 6 6-6"}]],F3=[["path",{d:"m15 18-6-6 6-6"}]],z3=[["path",{d:"m9 18 6-6-6-6"}]],b3=[["path",{d:"m7 18 6-6-6-6"}],["path",{d:"M17 6v12"}]],R3=[["path",{d:"m18 15-6-6-6 6"}]],T3=[["path",{d:"m7 20 5-5 5 5"}],["path",{d:"m7 4 5 5 5-5"}]],q3=[["path",{d:"m7 6 5 5 5-5"}],["path",{d:"m7 13 5 5 5-5"}]],U3=[["path",{d:"M12 12h.01"}],["path",{d:"M16 12h.01"}],["path",{d:"m17 7 5 5-5 5"}],["path",{d:"m7 7-5 5 5 5"}],["path",{d:"M8 12h.01"}]],O3=[["path",{d:"m9 7-5 5 5 5"}],["path",{d:"m15 7 5 5-5 5"}]],Z3=[["path",{d:"m11 17-5-5 5-5"}],["path",{d:"m18 17-5-5 5-5"}]],G3=[["path",{d:"m20 17-5-5 5-5"}],["path",{d:"m4 17 5-5-5-5"}]],I3=[["path",{d:"m6 17 5-5-5-5"}],["path",{d:"m13 17 5-5-5-5"}]],W3=[["path",{d:"m7 15 5 5 5-5"}],["path",{d:"m7 9 5-5 5 5"}]],E3=[["path",{d:"m17 11-5-5-5 5"}],["path",{d:"m17 18-5-5-5 5"}]],j=[["path",{d:"M10.88 21.94 15.46 14"}],["path",{d:"M21.17 8H12"}],["path",{d:"M3.95 6.06 8.54 14"}],["circle",{cx:"12",cy:"12",r:"10"}],["circle",{cx:"12",cy:"12",r:"4"}]],X3=[["path",{d:"M10 9h4"}],["path",{d:"M12 7v5"}],["path",{d:"M14 21v-3a2 2 0 0 0-4 0v3"}],["path",{d:"m18 9 3.52 2.147a1 1 0 0 1 .48.854V19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-6.999a1 1 0 0 1 .48-.854L6 9"}],["path",{d:"M6 21V7a1 1 0 0 1 .376-.782l5-3.999a1 1 0 0 1 1.249.001l5 4A1 1 0 0 1 18 7v14"}]],j3=[["path",{d:"M12 12H3a1 1 0 0 0-1 1v2a1 1 0 0 0 1 1h13"}],["path",{d:"M18 8c0-2.5-2-2.5-2-5"}],["path",{d:"m2 2 20 20"}],["path",{d:"M21 12a1 1 0 0 1 1 1v2a1 1 0 0 1-.5.866"}],["path",{d:"M22 8c0-2.5-2-2.5-2-5"}],["path",{d:"M7 12v4"}]],N3=[["path",{d:"M17 12H3a1 1 0 0 0-1 1v2a1 1 0 0 0 1 1h14"}],["path",{d:"M18 8c0-2.5-2-2.5-2-5"}],["path",{d:"M21 16a1 1 0 0 0 1-1v-2a1 1 0 0 0-1-1"}],["path",{d:"M22 8c0-2.5-2-2.5-2-5"}],["path",{d:"M7 12v4"}]],N=[["circle",{cx:"12",cy:"12",r:"10"}],["line",{x1:"12",x2:"12",y1:"8",y2:"12"}],["line",{x1:"12",x2:"12.01",y1:"16",y2:"16"}]],K=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M12 8v8"}],["path",{d:"m8 12 4 4 4-4"}]],Q=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"m12 8-4 4 4 4"}],["path",{d:"M16 12H8"}]],J=[["path",{d:"M2 12a10 10 0 1 1 10 10"}],["path",{d:"m2 22 10-10"}],["path",{d:"M8 22H2v-6"}]],Y=[["path",{d:"M12 22a10 10 0 1 1 10-10"}],["path",{d:"M22 22 12 12"}],["path",{d:"M22 16v6h-6"}]],_=[["path",{d:"M2 8V2h6"}],["path",{d:"m2 2 10 10"}],["path",{d:"M12 2A10 10 0 1 1 2 12"}]],x=[["path",{d:"M22 12A10 10 0 1 1 12 2"}],["path",{d:"M22 2 12 12"}],["path",{d:"M16 2h6v6"}]],a1=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"m12 16 4-4-4-4"}],["path",{d:"M8 12h8"}]],t1=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"m16 12-4-4-4 4"}],["path",{d:"M12 16V8"}]],h1=[["path",{d:"M21.801 10A10 10 0 1 1 17 3.335"}],["path",{d:"m9 11 3 3L22 4"}]],d1=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"m9 12 2 2 4-4"}]],c1=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"m16 10-4 4-4-4"}]],M1=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"m14 16-4-4 4-4"}]],p1=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"m10 8 4 4-4 4"}]],i1=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"m8 14 4-4 4 4"}]],K3=[["path",{d:"M10.1 2.182a10 10 0 0 1 3.8 0"}],["path",{d:"M13.9 21.818a10 10 0 0 1-3.8 0"}],["path",{d:"M17.609 3.721a10 10 0 0 1 2.69 2.7"}],["path",{d:"M2.182 13.9a10 10 0 0 1 0-3.8"}],["path",{d:"M20.279 17.609a10 10 0 0 1-2.7 2.69"}],["path",{d:"M21.818 10.1a10 10 0 0 1 0 3.8"}],["path",{d:"M3.721 6.391a10 10 0 0 1 2.7-2.69"}],["path",{d:"M6.391 20.279a10 10 0 0 1-2.69-2.7"}]],n1=[["line",{x1:"8",x2:"16",y1:"12",y2:"12"}],["line",{x1:"12",x2:"12",y1:"16",y2:"16"}],["line",{x1:"12",x2:"12",y1:"8",y2:"8"}],["circle",{cx:"12",cy:"12",r:"10"}]],Q3=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M16 8h-6a2 2 0 1 0 0 4h4a2 2 0 1 1 0 4H8"}],["path",{d:"M12 18V6"}]],J3=[["path",{d:"M10.1 2.18a9.93 9.93 0 0 1 3.8 0"}],["path",{d:"M17.6 3.71a9.95 9.95 0 0 1 2.69 2.7"}],["path",{d:"M21.82 10.1a9.93 9.93 0 0 1 0 3.8"}],["path",{d:"M20.29 17.6a9.95 9.95 0 0 1-2.7 2.69"}],["path",{d:"M13.9 21.82a9.94 9.94 0 0 1-3.8 0"}],["path",{d:"M6.4 20.29a9.95 9.95 0 0 1-2.69-2.7"}],["path",{d:"M2.18 13.9a9.93 9.93 0 0 1 0-3.8"}],["path",{d:"M3.71 6.4a9.95 9.95 0 0 1 2.7-2.69"}],["circle",{cx:"12",cy:"12",r:"1"}]],Y3=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M17 12h.01"}],["path",{d:"M12 12h.01"}],["path",{d:"M7 12h.01"}]],_3=[["circle",{cx:"12",cy:"12",r:"10"}],["circle",{cx:"12",cy:"12",r:"1"}]],x3=[["path",{d:"M7 10h10"}],["path",{d:"M7 14h10"}],["circle",{cx:"12",cy:"12",r:"10"}]],ad=[["path",{d:"M12 2a10 10 0 0 1 7.38 16.75"}],["path",{d:"m16 12-4-4-4 4"}],["path",{d:"M12 16V8"}],["path",{d:"M2.5 8.875a10 10 0 0 0-.5 3"}],["path",{d:"M2.83 16a10 10 0 0 0 2.43 3.4"}],["path",{d:"M4.636 5.235a10 10 0 0 1 .891-.857"}],["path",{d:"M8.644 21.42a10 10 0 0 0 7.631-.38"}]],td=[["path",{d:"M12 2a10 10 0 0 1 7.38 16.75"}],["path",{d:"M12 8v8"}],["path",{d:"M16 12H8"}],["path",{d:"M2.5 8.875a10 10 0 0 0-.5 3"}],["path",{d:"M2.83 16a10 10 0 0 0 2.43 3.4"}],["path",{d:"M4.636 5.235a10 10 0 0 1 .891-.857"}],["path",{d:"M8.644 21.42a10 10 0 0 0 7.631-.38"}]],l1=[["path",{d:"M15.6 2.7a10 10 0 1 0 5.7 5.7"}],["circle",{cx:"12",cy:"12",r:"2"}],["path",{d:"M13.4 10.6 19 5"}]],e1=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M8 12h8"}]],hd=[["path",{d:"m2 2 20 20"}],["path",{d:"M8.35 2.69A10 10 0 0 1 21.3 15.65"}],["path",{d:"M19.08 19.08A10 10 0 1 1 4.92 4.92"}]],r1=[["path",{d:"M12.656 7H13a3 3 0 0 1 2.984 3.307"}],["path",{d:"M13 13H9"}],["path",{d:"M19.071 19.071A1 1 0 0 1 4.93 4.93"}],["path",{d:"m2 2 20 20"}],["path",{d:"M8.357 2.687a10 10 0 0 1 12.956 12.956"}],["path",{d:"M9 17V9"}]],o1=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M9 17V7h4a3 3 0 0 1 0 6H9"}]],v1=[["circle",{cx:"12",cy:"12",r:"10"}],["line",{x1:"10",x2:"10",y1:"15",y2:"9"}],["line",{x1:"14",x2:"14",y1:"15",y2:"9"}]],$1=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"m15 9-6 6"}],["path",{d:"M9 9h.01"}],["path",{d:"M15 15h.01"}]],m1=[["path",{d:"M9 9.003a1 1 0 0 1 1.517-.859l4.997 2.997a1 1 0 0 1 0 1.718l-4.997 2.997A1 1 0 0 1 9 14.996z"}],["circle",{cx:"12",cy:"12",r:"10"}]],dd=[["path",{d:"M10 16V9.5a1 1 0 0 1 5 0"}],["path",{d:"M8 12h4"}],["path",{d:"M8 16h7"}],["circle",{cx:"12",cy:"12",r:"10"}]],y1=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M8 12h8"}],["path",{d:"M12 8v8"}]],s1=[["path",{d:"M12 7v4"}],["path",{d:"M7.998 9.003a5 5 0 1 0 8-.005"}],["circle",{cx:"12",cy:"12",r:"10"}]],l=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"}],["path",{d:"M12 17h.01"}]],g1=[["path",{d:"M22 2 2 22"}],["circle",{cx:"12",cy:"12",r:"10"}]],cd=[["circle",{cx:"12",cy:"12",r:"10"}],["line",{x1:"9",x2:"15",y1:"15",y2:"9"}]],Md=[["circle",{cx:"12",cy:"12",r:"6"}]],pd=[["path",{d:"M11.051 7.616a1 1 0 0 1 1.909.024l.737 1.452a1 1 0 0 0 .737.535l1.634.256a1 1 0 0 1 .588 1.806l-1.172 1.168a1 1 0 0 0-.282.866l.259 1.613a1 1 0 0 1-1.541 1.134l-1.465-.75a1 1 0 0 0-.912 0l-1.465.75a1 1 0 0 1-1.539-1.133l.258-1.613a1 1 0 0 0-.282-.867l-1.156-1.152a1 1 0 0 1 .572-1.822l1.633-.256a1 1 0 0 0 .737-.535z"}],["circle",{cx:"12",cy:"12",r:"10"}]],u1=[["circle",{cx:"12",cy:"12",r:"10"}],["rect",{x:"9",y:"9",width:"6",height:"6",rx:"1"}]],C1=[["path",{d:"M18 20a6 6 0 0 0-12 0"}],["circle",{cx:"12",cy:"10",r:"4"}],["circle",{cx:"12",cy:"12",r:"10"}]],H1=[["circle",{cx:"12",cy:"12",r:"10"}],["circle",{cx:"12",cy:"10",r:"3"}],["path",{d:"M7 20.662V19a2 2 0 0 1 2-2h6a2 2 0 0 1 2 2v1.662"}]],A1=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"m15 9-6 6"}],["path",{d:"m9 9 6 6"}]],id=[["circle",{cx:"12",cy:"12",r:"10"}]],nd=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M11 9h4a2 2 0 0 0 2-2V3"}],["circle",{cx:"9",cy:"9",r:"2"}],["path",{d:"M7 21v-4a2 2 0 0 1 2-2h4"}],["circle",{cx:"15",cy:"15",r:"2"}]],ld=[["path",{d:"M21.66 17.67a1.08 1.08 0 0 1-.04 1.6A12 12 0 0 1 4.73 2.38a1.1 1.1 0 0 1 1.61-.04z"}],["path",{d:"M19.65 15.66A8 8 0 0 1 8.35 4.34"}],["path",{d:"m14 10-5.5 5.5"}],["path",{d:"M14 17.85V10H6.15"}]],ed=[["path",{d:"M20.2 6 3 11l-.9-2.4c-.3-1.1.3-2.2 1.3-2.5l13.5-4c1.1-.3 2.2.3 2.5 1.3Z"}],["path",{d:"m6.2 5.3 3.1 3.9"}],["path",{d:"m12.4 3.4 3.1 4"}],["path",{d:"M3 11h18v8a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2Z"}]],rd=[["rect",{width:"8",height:"4",x:"8",y:"2",rx:"1",ry:"1"}],["path",{d:"M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"}],["path",{d:"m9 14 2 2 4-4"}]],od=[["path",{d:"M16 14v2.2l1.6 1"}],["path",{d:"M16 4h2a2 2 0 0 1 2 2v.832"}],["path",{d:"M8 4H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h2"}],["circle",{cx:"16",cy:"16",r:"6"}],["rect",{x:"8",y:"2",width:"8",height:"4",rx:"1"}]],vd=[["rect",{width:"8",height:"4",x:"8",y:"2",rx:"1",ry:"1"}],["path",{d:"M8 4H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-2"}],["path",{d:"M16 4h2a2 2 0 0 1 2 2v4"}],["path",{d:"M21 14H11"}],["path",{d:"m15 10-4 4 4 4"}]],$d=[["rect",{width:"8",height:"4",x:"8",y:"2",rx:"1",ry:"1"}],["path",{d:"M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"}],["path",{d:"M12 11h4"}],["path",{d:"M12 16h4"}],["path",{d:"M8 11h.01"}],["path",{d:"M8 16h.01"}]],md=[["rect",{width:"8",height:"4",x:"8",y:"2",rx:"1",ry:"1"}],["path",{d:"M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"}],["path",{d:"M9 14h6"}]],yd=[["path",{d:"M11 14h10"}],["path",{d:"M16 4h2a2 2 0 0 1 2 2v1.344"}],["path",{d:"m17 18 4-4-4-4"}],["path",{d:"M8 4H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h12a2 2 0 0 0 1.793-1.113"}],["rect",{x:"8",y:"2",width:"8",height:"4",rx:"1"}]],w1=[["rect",{width:"8",height:"4",x:"8",y:"2",rx:"1"}],["path",{d:"M8 4H6a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-.5"}],["path",{d:"M16 4h2a2 2 0 0 1 1.73 1"}],["path",{d:"M8 18h1"}],["path",{d:"M21.378 12.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"}]],V1=[["rect",{width:"8",height:"4",x:"8",y:"2",rx:"1"}],["path",{d:"M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-5.5"}],["path",{d:"M4 13.5V6a2 2 0 0 1 2-2h2"}],["path",{d:"M13.378 15.626a1 1 0 1 0-3.004-3.004l-5.01 5.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"}]],sd=[["rect",{width:"8",height:"4",x:"8",y:"2",rx:"1",ry:"1"}],["path",{d:"M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"}],["path",{d:"M9 14h6"}],["path",{d:"M12 17v-6"}]],gd=[["rect",{width:"8",height:"4",x:"8",y:"2",rx:"1",ry:"1"}],["path",{d:"M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"}],["path",{d:"M9 12v-1h6v1"}],["path",{d:"M11 17h2"}],["path",{d:"M12 11v6"}]],ud=[["rect",{width:"8",height:"4",x:"8",y:"2",rx:"1",ry:"1"}],["path",{d:"M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"}],["path",{d:"m15 11-6 6"}],["path",{d:"m9 11 6 6"}]],Cd=[["rect",{width:"8",height:"4",x:"8",y:"2",rx:"1",ry:"1"}],["path",{d:"M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"}]],Hd=[["path",{d:"M12 6v6l2-4"}],["circle",{cx:"12",cy:"12",r:"10"}]],Ad=[["path",{d:"M12 6v6l-4-2"}],["circle",{cx:"12",cy:"12",r:"10"}]],wd=[["path",{d:"M12 6v6l-2-4"}],["circle",{cx:"12",cy:"12",r:"10"}]],Vd=[["path",{d:"M12 6v6"}],["circle",{cx:"12",cy:"12",r:"10"}]],Sd=[["path",{d:"M12 6v6l4-2"}],["circle",{cx:"12",cy:"12",r:"10"}]],Ld=[["path",{d:"M12 6v6h4"}],["circle",{cx:"12",cy:"12",r:"10"}]],fd=[["path",{d:"M12 6v6l4 2"}],["circle",{cx:"12",cy:"12",r:"10"}]],kd=[["path",{d:"M12 6v6l2 4"}],["circle",{cx:"12",cy:"12",r:"10"}]],Pd=[["path",{d:"M12 6v10"}],["circle",{cx:"12",cy:"12",r:"10"}]],Bd=[["path",{d:"M12 6v6l-2 4"}],["circle",{cx:"12",cy:"12",r:"10"}]],Dd=[["path",{d:"M12 6v6l-4 2"}],["circle",{cx:"12",cy:"12",r:"10"}]],Fd=[["path",{d:"M12 6v6H8"}],["circle",{cx:"12",cy:"12",r:"10"}]],zd=[["path",{d:"M12 6v6l4 2"}],["path",{d:"M20 12v5"}],["path",{d:"M20 21h.01"}],["path",{d:"M21.25 8.2A10 10 0 1 0 16 21.16"}]],bd=[["path",{d:"M12 6v6l2 1"}],["path",{d:"M12.337 21.994a10 10 0 1 1 9.588-8.767"}],["path",{d:"m14 18 4 4 4-4"}],["path",{d:"M18 14v8"}]],Rd=[["path",{d:"M12 6v6l1.56.78"}],["path",{d:"M13.227 21.925a10 10 0 1 1 8.767-9.588"}],["path",{d:"m14 18 4-4 4 4"}],["path",{d:"M18 22v-8"}]],Td=[["path",{d:"M12 2a10 10 0 0 1 7.38 16.75"}],["path",{d:"M12 6v6l4 2"}],["path",{d:"M2.5 8.875a10 10 0 0 0-.5 3"}],["path",{d:"M2.83 16a10 10 0 0 0 2.43 3.4"}],["path",{d:"M4.636 5.235a10 10 0 0 1 .891-.857"}],["path",{d:"M8.644 21.42a10 10 0 0 0 7.631-.38"}]],qd=[["path",{d:"M12 6v6l3.644 1.822"}],["path",{d:"M16 19h6"}],["path",{d:"M19 16v6"}],["path",{d:"M21.92 13.267a10 10 0 1 0-8.653 8.653"}]],Ud=[["path",{d:"M12 6v6l4 2"}],["circle",{cx:"12",cy:"12",r:"10"}]],Od=[["path",{d:"M10 9.17a3 3 0 1 0 0 5.66"}],["path",{d:"M17 9.17a3 3 0 1 0 0 5.66"}],["rect",{x:"2",y:"5",width:"20",height:"14",rx:"2"}]],Zd=[["path",{d:"M12 12v4"}],["path",{d:"M12 20h.01"}],["path",{d:"M17 18h.5a1 1 0 0 0 0-9h-1.79A7 7 0 1 0 7 17.708"}]],Gd=[["path",{d:"m17 15-5.5 5.5L9 18"}],["path",{d:"M5 17.743A7 7 0 1 1 15.71 10h1.79a4.5 4.5 0 0 1 1.5 8.742"}]],Id=[["path",{d:"m10.852 19.772-.383.924"}],["path",{d:"m13.148 14.228.383-.923"}],["path",{d:"M13.148 19.772a3 3 0 1 0-2.296-5.544l-.383-.923"}],["path",{d:"m13.53 20.696-.382-.924a3 3 0 1 1-2.296-5.544"}],["path",{d:"m14.772 15.852.923-.383"}],["path",{d:"m14.772 18.148.923.383"}],["path",{d:"M4.2 15.1a7 7 0 1 1 9.93-9.858A7 7 0 0 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.2"}],["path",{d:"m9.228 15.852-.923-.383"}],["path",{d:"m9.228 18.148-.923.383"}]],S1=[["path",{d:"M12 13v8l-4-4"}],["path",{d:"m12 21 4-4"}],["path",{d:"M4.393 15.269A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.436 8.284"}]],Wd=[["path",{d:"M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242"}],["path",{d:"M8 19v1"}],["path",{d:"M8 14v1"}],["path",{d:"M16 19v1"}],["path",{d:"M16 14v1"}],["path",{d:"M12 21v1"}],["path",{d:"M12 16v1"}]],Ed=[["path",{d:"M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242"}],["path",{d:"M16 17H7"}],["path",{d:"M17 21H9"}]],Xd=[["path",{d:"M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242"}],["path",{d:"M16 14v2"}],["path",{d:"M8 14v2"}],["path",{d:"M16 20h.01"}],["path",{d:"M8 20h.01"}],["path",{d:"M12 16v2"}],["path",{d:"M12 22h.01"}]],jd=[["path",{d:"M6 16.326A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 .5 8.973"}],["path",{d:"m13 12-3 5h4l-3 5"}]],Nd=[["path",{d:"M11 20v2"}],["path",{d:"M18.376 14.512a6 6 0 0 0 3.461-4.127c.148-.625-.659-.97-1.248-.714a4 4 0 0 1-5.259-5.26c.255-.589-.09-1.395-.716-1.248a6 6 0 0 0-4.594 5.36"}],["path",{d:"M3 20a5 5 0 1 1 8.9-4H13a3 3 0 0 1 2 5.24"}],["path",{d:"M7 19v2"}]],Kd=[["path",{d:"m2 2 20 20"}],["path",{d:"M5.782 5.782A7 7 0 0 0 9 19h8.5a4.5 4.5 0 0 0 1.307-.193"}],["path",{d:"M21.532 16.5A4.5 4.5 0 0 0 17.5 10h-1.79A7.008 7.008 0 0 0 10 5.07"}]],Qd=[["path",{d:"M13 16a3 3 0 0 1 0 6H7a5 5 0 1 1 4.9-6z"}],["path",{d:"M18.376 14.512a6 6 0 0 0 3.461-4.127c.148-.625-.659-.97-1.248-.714a4 4 0 0 1-5.259-5.26c.255-.589-.09-1.395-.716-1.248a6 6 0 0 0-4.594 5.36"}]],Jd=[["path",{d:"M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242"}],["path",{d:"m9.2 22 3-7"}],["path",{d:"m9 13-3 7"}],["path",{d:"m17 13-3 7"}]],Yd=[["path",{d:"M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242"}],["path",{d:"M16 14v6"}],["path",{d:"M8 14v6"}],["path",{d:"M12 16v6"}]],_d=[["path",{d:"M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242"}],["path",{d:"M8 15h.01"}],["path",{d:"M8 19h.01"}],["path",{d:"M12 17h.01"}],["path",{d:"M12 21h.01"}],["path",{d:"M16 15h.01"}],["path",{d:"M16 19h.01"}]],xd=[["path",{d:"M12 2v2"}],["path",{d:"m4.93 4.93 1.41 1.41"}],["path",{d:"M20 12h2"}],["path",{d:"m19.07 4.93-1.41 1.41"}],["path",{d:"M15.947 12.65a4 4 0 0 0-5.925-4.128"}],["path",{d:"M3 20a5 5 0 1 1 8.9-4H13a3 3 0 0 1 2 5.24"}],["path",{d:"M11 20v2"}],["path",{d:"M7 19v2"}]],a6=[["path",{d:"M12 2v2"}],["path",{d:"m4.93 4.93 1.41 1.41"}],["path",{d:"M20 12h2"}],["path",{d:"m19.07 4.93-1.41 1.41"}],["path",{d:"M15.947 12.65a4 4 0 0 0-5.925-4.128"}],["path",{d:"M13 22H7a5 5 0 1 1 4.9-6H13a3 3 0 0 1 0 6Z"}]],L1=[["path",{d:"M12 13v8"}],["path",{d:"M4 14.899A7 7 0 1 1 15.71 8h1.79a4.5 4.5 0 0 1 2.5 8.242"}],["path",{d:"m8 17 4-4 4 4"}]],t6=[["path",{d:"M17.5 19H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z"}]],h6=[["path",{d:"M17.5 21H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z"}],["path",{d:"M22 10a3 3 0 0 0-3-3h-2.207a5.502 5.502 0 0 0-10.702.5"}]],d6=[["path",{d:"M16.17 7.83 2 22"}],["path",{d:"M4.02 12a2.827 2.827 0 1 1 3.81-4.17A2.827 2.827 0 1 1 12 4.02a2.827 2.827 0 1 1 4.17 3.81A2.827 2.827 0 1 1 19.98 12a2.827 2.827 0 1 1-3.81 4.17A2.827 2.827 0 1 1 12 19.98a2.827 2.827 0 1 1-4.17-3.81A1 1 0 1 1 4 12"}],["path",{d:"m7.83 7.83 8.34 8.34"}]],c6=[["path",{d:"M17.28 9.05a5.5 5.5 0 1 0-10.56 0A5.5 5.5 0 1 0 12 17.66a5.5 5.5 0 1 0 5.28-8.6Z"}],["path",{d:"M12 17.66L12 22"}]],f1=[["path",{d:"m18 16 4-4-4-4"}],["path",{d:"m6 8-4 4 4 4"}],["path",{d:"m14.5 4-5 16"}]],M6=[["path",{d:"m16 18 6-6-6-6"}],["path",{d:"m8 6-6 6 6 6"}]],p6=[["polygon",{points:"12 2 22 8.5 22 15.5 12 22 2 15.5 2 8.5 12 2"}],["line",{x1:"12",x2:"12",y1:"22",y2:"15.5"}],["polyline",{points:"22 8.5 12 15.5 2 8.5"}],["polyline",{points:"2 15.5 12 8.5 22 15.5"}],["line",{x1:"12",x2:"12",y1:"2",y2:"8.5"}]],i6=[["path",{d:"M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"}],["polyline",{points:"7.5 4.21 12 6.81 16.5 4.21"}],["polyline",{points:"7.5 19.79 7.5 14.6 3 12"}],["polyline",{points:"21 12 16.5 14.6 16.5 19.79"}],["polyline",{points:"3.27 6.96 12 12.01 20.73 6.96"}],["line",{x1:"12",x2:"12",y1:"22.08",y2:"12"}]],n6=[["path",{d:"M10 2v2"}],["path",{d:"M14 2v2"}],["path",{d:"M16 8a1 1 0 0 1 1 1v8a4 4 0 0 1-4 4H7a4 4 0 0 1-4-4V9a1 1 0 0 1 1-1h14a4 4 0 1 1 0 8h-1"}],["path",{d:"M6 2v2"}]],l6=[["path",{d:"M11 10.27 7 3.34"}],["path",{d:"m11 13.73-4 6.93"}],["path",{d:"M12 22v-2"}],["path",{d:"M12 2v2"}],["path",{d:"M14 12h8"}],["path",{d:"m17 20.66-1-1.73"}],["path",{d:"m17 3.34-1 1.73"}],["path",{d:"M2 12h2"}],["path",{d:"m20.66 17-1.73-1"}],["path",{d:"m20.66 7-1.73 1"}],["path",{d:"m3.34 17 1.73-1"}],["path",{d:"m3.34 7 1.73 1"}],["circle",{cx:"12",cy:"12",r:"2"}],["circle",{cx:"12",cy:"12",r:"8"}]],e6=[["circle",{cx:"8",cy:"8",r:"6"}],["path",{d:"M18.09 10.37A6 6 0 1 1 10.34 18"}],["path",{d:"M7 6h1v4"}],["path",{d:"m16.71 13.88.7.71-2.82 2.82"}]],k1=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M12 3v18"}]],e=[["path",{d:"M10.5 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v5.5"}],["path",{d:"m14.3 19.6 1-.4"}],["path",{d:"M15 3v7.5"}],["path",{d:"m15.2 16.9-.9-.3"}],["path",{d:"m16.6 21.7.3-.9"}],["path",{d:"m16.8 15.3-.4-1"}],["path",{d:"m19.1 15.2.3-.9"}],["path",{d:"m19.6 21.7-.4-1"}],["path",{d:"m20.7 16.8 1-.4"}],["path",{d:"m21.7 19.4-.9-.3"}],["path",{d:"M9 3v18"}],["circle",{cx:"18",cy:"18",r:"3"}]],P1=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M9 3v18"}],["path",{d:"M15 3v18"}]],r6=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M7.5 3v18"}],["path",{d:"M12 3v18"}],["path",{d:"M16.5 3v18"}]],o6=[["path",{d:"M10 18H5a3 3 0 0 1-3-3v-1"}],["path",{d:"M14 2a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2"}],["path",{d:"M20 2a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2"}],["path",{d:"m7 21 3-3-3-3"}],["rect",{x:"14",y:"14",width:"8",height:"8",rx:"2"}],["rect",{x:"2",y:"2",width:"8",height:"8",rx:"2"}]],v6=[["path",{d:"m16.24 7.76-1.804 5.411a2 2 0 0 1-1.265 1.265L7.76 16.24l1.804-5.411a2 2 0 0 1 1.265-1.265z"}],["circle",{cx:"12",cy:"12",r:"10"}]],$6=[["path",{d:"M15 6v12a3 3 0 1 0 3-3H6a3 3 0 1 0 3 3V6a3 3 0 1 0-3 3h12a3 3 0 1 0-3-3"}]],m6=[["path",{d:"M15.536 11.293a1 1 0 0 0 0 1.414l2.376 2.377a1 1 0 0 0 1.414 0l2.377-2.377a1 1 0 0 0 0-1.414l-2.377-2.377a1 1 0 0 0-1.414 0z"}],["path",{d:"M2.297 11.293a1 1 0 0 0 0 1.414l2.377 2.377a1 1 0 0 0 1.414 0l2.377-2.377a1 1 0 0 0 0-1.414L6.088 8.916a1 1 0 0 0-1.414 0z"}],["path",{d:"M8.916 17.912a1 1 0 0 0 0 1.415l2.377 2.376a1 1 0 0 0 1.414 0l2.377-2.376a1 1 0 0 0 0-1.415l-2.377-2.376a1 1 0 0 0-1.414 0z"}],["path",{d:"M8.916 4.674a1 1 0 0 0 0 1.414l2.377 2.376a1 1 0 0 0 1.414 0l2.377-2.376a1 1 0 0 0 0-1.414l-2.377-2.377a1 1 0 0 0-1.414 0z"}]],y6=[["rect",{width:"14",height:"8",x:"5",y:"2",rx:"2"}],["rect",{width:"20",height:"8",x:"2",y:"14",rx:"2"}],["path",{d:"M6 18h2"}],["path",{d:"M12 18h6"}]],s6=[["path",{d:"M3 20a1 1 0 0 1-1-1v-1a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v1a1 1 0 0 1-1 1Z"}],["path",{d:"M20 16a8 8 0 1 0-16 0"}],["path",{d:"M12 4v4"}],["path",{d:"M10 4h4"}]],g6=[["path",{d:"m20.9 18.55-8-15.98a1 1 0 0 0-1.8 0l-8 15.98"}],["ellipse",{cx:"12",cy:"19",rx:"9",ry:"3"}]],u6=[["rect",{x:"2",y:"6",width:"20",height:"8",rx:"1"}],["path",{d:"M17 14v7"}],["path",{d:"M7 14v7"}],["path",{d:"M17 3v3"}],["path",{d:"M7 3v3"}],["path",{d:"M10 14 2.3 6.3"}],["path",{d:"m14 6 7.7 7.7"}],["path",{d:"m8 6 8 8"}]],B1=[["path",{d:"M16 2v2"}],["path",{d:"M17.915 22a6 6 0 0 0-12 0"}],["path",{d:"M8 2v2"}],["circle",{cx:"12",cy:"12",r:"4"}],["rect",{x:"3",y:"4",width:"18",height:"18",rx:"2"}]],C6=[["path",{d:"M16 2v2"}],["path",{d:"M7 22v-2a2 2 0 0 1 2-2h6a2 2 0 0 1 2 2v2"}],["path",{d:"M8 2v2"}],["circle",{cx:"12",cy:"11",r:"3"}],["rect",{x:"3",y:"4",width:"18",height:"18",rx:"2"}]],H6=[["path",{d:"M22 7.7c0-.6-.4-1.2-.8-1.5l-6.3-3.9a1.72 1.72 0 0 0-1.7 0l-10.3 6c-.5.2-.9.8-.9 1.4v6.6c0 .5.4 1.2.8 1.5l6.3 3.9a1.72 1.72 0 0 0 1.7 0l10.3-6c.5-.3.9-1 .9-1.5Z"}],["path",{d:"M10 21.9V14L2.1 9.1"}],["path",{d:"m10 14 11.9-6.9"}],["path",{d:"M14 19.8v-8.1"}],["path",{d:"M18 17.5V9.4"}]],A6=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M12 18a6 6 0 0 0 0-12v12z"}]],w6=[["path",{d:"M12 2a10 10 0 1 0 10 10 4 4 0 0 1-5-5 4 4 0 0 1-5-5"}],["path",{d:"M8.5 8.5v.01"}],["path",{d:"M16 15.5v.01"}],["path",{d:"M12 12v.01"}],["path",{d:"M11 17v.01"}],["path",{d:"M7 14v.01"}]],V6=[["path",{d:"M2 12h20"}],["path",{d:"M20 12v8a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-8"}],["path",{d:"m4 8 16-4"}],["path",{d:"m8.86 6.78-.45-1.81a2 2 0 0 1 1.45-2.43l1.94-.48a2 2 0 0 1 2.43 1.46l.45 1.8"}]],S6=[["path",{d:"m12 15 2 2 4-4"}],["rect",{width:"14",height:"14",x:"8",y:"8",rx:"2",ry:"2"}],["path",{d:"M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"}]],L6=[["line",{x1:"12",x2:"18",y1:"15",y2:"15"}],["rect",{width:"14",height:"14",x:"8",y:"8",rx:"2",ry:"2"}],["path",{d:"M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"}]],f6=[["line",{x1:"15",x2:"15",y1:"12",y2:"18"}],["line",{x1:"12",x2:"18",y1:"15",y2:"15"}],["rect",{width:"14",height:"14",x:"8",y:"8",rx:"2",ry:"2"}],["path",{d:"M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"}]],k6=[["line",{x1:"12",x2:"18",y1:"18",y2:"12"}],["rect",{width:"14",height:"14",x:"8",y:"8",rx:"2",ry:"2"}],["path",{d:"M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"}]],P6=[["line",{x1:"12",x2:"18",y1:"12",y2:"18"}],["line",{x1:"12",x2:"18",y1:"18",y2:"12"}],["rect",{width:"14",height:"14",x:"8",y:"8",rx:"2",ry:"2"}],["path",{d:"M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"}]],B6=[["rect",{width:"14",height:"14",x:"8",y:"8",rx:"2",ry:"2"}],["path",{d:"M4 16c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h10c1.1 0 2 .9 2 2"}]],D6=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M14.83 14.83a4 4 0 1 1 0-5.66"}]],F6=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M9.17 14.83a4 4 0 1 0 0-5.66"}]],z6=[["path",{d:"M20 4v7a4 4 0 0 1-4 4H4"}],["path",{d:"m9 10-5 5 5 5"}]],b6=[["path",{d:"m15 10 5 5-5 5"}],["path",{d:"M4 4v7a4 4 0 0 0 4 4h12"}]],R6=[["path",{d:"m14 15-5 5-5-5"}],["path",{d:"M20 4h-7a4 4 0 0 0-4 4v12"}]],T6=[["path",{d:"M14 9 9 4 4 9"}],["path",{d:"M20 20h-7a4 4 0 0 1-4-4V4"}]],q6=[["path",{d:"m10 15 5 5 5-5"}],["path",{d:"M4 4h7a4 4 0 0 1 4 4v12"}]],U6=[["path",{d:"m10 9 5-5 5 5"}],["path",{d:"M4 20h7a4 4 0 0 0 4-4V4"}]],O6=[["path",{d:"M20 20v-7a4 4 0 0 0-4-4H4"}],["path",{d:"M9 14 4 9l5-5"}]],Z6=[["path",{d:"m15 14 5-5-5-5"}],["path",{d:"M4 20v-7a4 4 0 0 1 4-4h12"}]],G6=[["path",{d:"M12 20v2"}],["path",{d:"M12 2v2"}],["path",{d:"M17 20v2"}],["path",{d:"M17 2v2"}],["path",{d:"M2 12h2"}],["path",{d:"M2 17h2"}],["path",{d:"M2 7h2"}],["path",{d:"M20 12h2"}],["path",{d:"M20 17h2"}],["path",{d:"M20 7h2"}],["path",{d:"M7 20v2"}],["path",{d:"M7 2v2"}],["rect",{x:"4",y:"4",width:"16",height:"16",rx:"2"}],["rect",{x:"8",y:"8",width:"8",height:"8",rx:"1"}]],I6=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M10 9.3a2.8 2.8 0 0 0-3.5 1 3.1 3.1 0 0 0 0 3.4 2.7 2.7 0 0 0 3.5 1"}],["path",{d:"M17 9.3a2.8 2.8 0 0 0-3.5 1 3.1 3.1 0 0 0 0 3.4 2.7 2.7 0 0 0 3.5 1"}]],W6=[["rect",{width:"20",height:"14",x:"2",y:"5",rx:"2"}],["line",{x1:"2",x2:"22",y1:"10",y2:"10"}]],E6=[["path",{d:"M10.2 18H4.774a1.5 1.5 0 0 1-1.352-.97 11 11 0 0 1 .132-6.487"}],["path",{d:"M18 10.2V4.774a1.5 1.5 0 0 0-.97-1.352 11 11 0 0 0-6.486.132"}],["path",{d:"M18 5a4 3 0 0 1 4 3 2 2 0 0 1-2 2 10 10 0 0 0-5.139 1.42"}],["path",{d:"M5 18a3 4 0 0 0 3 4 2 2 0 0 0 2-2 10 10 0 0 1 1.42-5.14"}],["path",{d:"M8.709 2.554a10 10 0 0 0-6.155 6.155 1.5 1.5 0 0 0 .676 1.626l9.807 5.42a2 2 0 0 0 2.718-2.718l-5.42-9.807a1.5 1.5 0 0 0-1.626-.676"}]],X6=[["path",{d:"M6 2v14a2 2 0 0 0 2 2h14"}],["path",{d:"M18 22V8a2 2 0 0 0-2-2H2"}]],j6=[["path",{d:"M4 9a2 2 0 0 0-2 2v2a2 2 0 0 0 2 2h4a1 1 0 0 1 1 1v4a2 2 0 0 0 2 2h2a2 2 0 0 0 2-2v-4a1 1 0 0 1 1-1h4a2 2 0 0 0 2-2v-2a2 2 0 0 0-2-2h-4a1 1 0 0 1-1-1V4a2 2 0 0 0-2-2h-2a2 2 0 0 0-2 2v4a1 1 0 0 1-1 1z"}]],N6=[["circle",{cx:"12",cy:"12",r:"10"}],["line",{x1:"22",x2:"18",y1:"12",y2:"12"}],["line",{x1:"6",x2:"2",y1:"12",y2:"12"}],["line",{x1:"12",x2:"12",y1:"6",y2:"2"}],["line",{x1:"12",x2:"12",y1:"22",y2:"18"}]],K6=[["path",{d:"M11.562 3.266a.5.5 0 0 1 .876 0L15.39 8.87a1 1 0 0 0 1.516.294L21.183 5.5a.5.5 0 0 1 .798.519l-2.834 10.246a1 1 0 0 1-.956.734H5.81a1 1 0 0 1-.957-.734L2.02 6.02a.5.5 0 0 1 .798-.519l4.276 3.664a1 1 0 0 0 1.516-.294z"}],["path",{d:"M5 21h14"}]],Q6=[["path",{d:"m21.12 6.4-6.05-4.06a2 2 0 0 0-2.17-.05L2.95 8.41a2 2 0 0 0-.95 1.7v5.82a2 2 0 0 0 .88 1.66l6.05 4.07a2 2 0 0 0 2.17.05l9.95-6.12a2 2 0 0 0 .95-1.7V8.06a2 2 0 0 0-.88-1.66Z"}],["path",{d:"M10 22v-8L2.25 9.15"}],["path",{d:"m10 14 11.77-6.87"}]],J6=[["path",{d:"m6 8 1.75 12.28a2 2 0 0 0 2 1.72h4.54a2 2 0 0 0 2-1.72L18 8"}],["path",{d:"M5 8h14"}],["path",{d:"M7 15a6.47 6.47 0 0 1 5 0 6.47 6.47 0 0 0 5 0"}],["path",{d:"m12 8 1-6h2"}]],Y6=[["circle",{cx:"12",cy:"12",r:"8"}],["line",{x1:"3",x2:"6",y1:"3",y2:"6"}],["line",{x1:"21",x2:"18",y1:"3",y2:"6"}],["line",{x1:"3",x2:"6",y1:"21",y2:"18"}],["line",{x1:"21",x2:"18",y1:"21",y2:"18"}]],_6=[["ellipse",{cx:"12",cy:"5",rx:"9",ry:"3"}],["path",{d:"M3 5v14a9 3 0 0 0 18 0V5"}]],x6=[["path",{d:"M11 11.31c1.17.56 1.54 1.69 3.5 1.69 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"}],["path",{d:"M11.75 18c.35.5 1.45 1 2.75 1 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"}],["path",{d:"M2 10h4"}],["path",{d:"M2 14h4"}],["path",{d:"M2 18h4"}],["path",{d:"M2 6h4"}],["path",{d:"M7 3a1 1 0 0 0-1 1v16a1 1 0 0 0 1 1h4a1 1 0 0 0 1-1L10 4a1 1 0 0 0-1-1z"}]],a8=[["ellipse",{cx:"12",cy:"5",rx:"9",ry:"3"}],["path",{d:"M3 12a9 3 0 0 0 5 2.69"}],["path",{d:"M21 9.3V5"}],["path",{d:"M3 5v14a9 3 0 0 0 6.47 2.88"}],["path",{d:"M12 12v4h4"}],["path",{d:"M13 20a5 5 0 0 0 9-3 4.5 4.5 0 0 0-4.5-4.5c-1.33 0-2.54.54-3.41 1.41L12 16"}]],t8=[["ellipse",{cx:"12",cy:"5",rx:"9",ry:"3"}],["path",{d:"M3 5V19A9 3 0 0 0 15 21.84"}],["path",{d:"M21 5V8"}],["path",{d:"M21 12L18 17H22L19 22"}],["path",{d:"M3 12A9 3 0 0 0 14.59 14.87"}]],h8=[["ellipse",{cx:"12",cy:"5",rx:"9",ry:"3"}],["path",{d:"M3 5V19A9 3 0 0 0 21 19V5"}],["path",{d:"M3 12A9 3 0 0 0 21 12"}]],d8=[["path",{d:"m13 21-3-3 3-3"}],["path",{d:"M20 18H10"}],["path",{d:"M3 11h.01"}],["rect",{x:"6",y:"3",width:"5",height:"8",rx:"2.5"}]],c8=[["path",{d:"M10 18h10"}],["path",{d:"m17 21 3-3-3-3"}],["path",{d:"M3 11h.01"}],["rect",{x:"15",y:"3",width:"5",height:"8",rx:"2.5"}],["rect",{x:"6",y:"3",width:"5",height:"8",rx:"2.5"}]],M8=[["path",{d:"M10 5a2 2 0 0 0-1.344.519l-6.328 5.74a1 1 0 0 0 0 1.481l6.328 5.741A2 2 0 0 0 10 19h10a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2z"}],["path",{d:"m12 9 6 6"}],["path",{d:"m18 9-6 6"}]],p8=[["path",{d:"M10.162 3.167A10 10 0 0 0 2 13a2 2 0 0 0 4 0v-1a2 2 0 0 1 4 0v4a2 2 0 0 0 4 0v-4a2 2 0 0 1 4 0v1a2 2 0 0 0 4-.006 10 10 0 0 0-8.161-9.826"}],["path",{d:"M20.804 14.869a9 9 0 0 1-17.608 0"}],["circle",{cx:"12",cy:"4",r:"2"}]],i8=[["circle",{cx:"19",cy:"19",r:"2"}],["circle",{cx:"5",cy:"5",r:"2"}],["path",{d:"M6.48 3.66a10 10 0 0 1 13.86 13.86"}],["path",{d:"m6.41 6.41 11.18 11.18"}],["path",{d:"M3.66 6.48a10 10 0 0 0 13.86 13.86"}]],n8=[["path",{d:"M2.7 10.3a2.41 2.41 0 0 0 0 3.41l7.59 7.59a2.41 2.41 0 0 0 3.41 0l7.59-7.59a2.41 2.41 0 0 0 0-3.41L13.7 2.71a2.41 2.41 0 0 0-3.41 0z"}],["path",{d:"M8 12h8"}]],D1=[["path",{d:"M2.7 10.3a2.41 2.41 0 0 0 0 3.41l7.59 7.59a2.41 2.41 0 0 0 3.41 0l7.59-7.59a2.41 2.41 0 0 0 0-3.41L13.7 2.71a2.41 2.41 0 0 0-3.41 0Z"}],["path",{d:"M9.2 9.2h.01"}],["path",{d:"m14.5 9.5-5 5"}],["path",{d:"M14.7 14.8h.01"}]],l8=[["path",{d:"M12 8v8"}],["path",{d:"M2.7 10.3a2.41 2.41 0 0 0 0 3.41l7.59 7.59a2.41 2.41 0 0 0 3.41 0l7.59-7.59a2.41 2.41 0 0 0 0-3.41L13.7 2.71a2.41 2.41 0 0 0-3.41 0z"}],["path",{d:"M8 12h8"}]],e8=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2",ry:"2"}],["path",{d:"M12 12h.01"}]],r8=[["path",{d:"M2.7 10.3a2.41 2.41 0 0 0 0 3.41l7.59 7.59a2.41 2.41 0 0 0 3.41 0l7.59-7.59a2.41 2.41 0 0 0 0-3.41l-7.59-7.59a2.41 2.41 0 0 0-3.41 0Z"}]],o8=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2",ry:"2"}],["path",{d:"M15 9h.01"}],["path",{d:"M9 15h.01"}]],v8=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2",ry:"2"}],["path",{d:"M16 8h.01"}],["path",{d:"M12 12h.01"}],["path",{d:"M8 16h.01"}]],$8=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2",ry:"2"}],["path",{d:"M16 8h.01"}],["path",{d:"M8 8h.01"}],["path",{d:"M8 16h.01"}],["path",{d:"M16 16h.01"}]],m8=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2",ry:"2"}],["path",{d:"M16 8h.01"}],["path",{d:"M8 8h.01"}],["path",{d:"M8 16h.01"}],["path",{d:"M16 16h.01"}],["path",{d:"M12 12h.01"}]],y8=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2",ry:"2"}],["path",{d:"M16 8h.01"}],["path",{d:"M16 12h.01"}],["path",{d:"M16 16h.01"}],["path",{d:"M8 8h.01"}],["path",{d:"M8 12h.01"}],["path",{d:"M8 16h.01"}]],s8=[["rect",{width:"12",height:"12",x:"2",y:"10",rx:"2",ry:"2"}],["path",{d:"m17.92 14 3.5-3.5a2.24 2.24 0 0 0 0-3l-5-4.92a2.24 2.24 0 0 0-3 0L10 6"}],["path",{d:"M6 18h.01"}],["path",{d:"M10 14h.01"}],["path",{d:"M15 6h.01"}],["path",{d:"M18 9h.01"}]],g8=[["path",{d:"M12 3v14"}],["path",{d:"M5 10h14"}],["path",{d:"M5 21h14"}]],u8=[["circle",{cx:"12",cy:"12",r:"10"}],["circle",{cx:"12",cy:"12",r:"4"}],["path",{d:"M12 12h.01"}]],C8=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M6 12c0-1.7.7-3.2 1.8-4.2"}],["circle",{cx:"12",cy:"12",r:"2"}],["path",{d:"M18 12c0 1.7-.7 3.2-1.8 4.2"}]],H8=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["circle",{cx:"12",cy:"12",r:"5"}],["path",{d:"M12 12h.01"}]],A8=[["circle",{cx:"12",cy:"12",r:"10"}],["circle",{cx:"12",cy:"12",r:"2"}]],w8=[["circle",{cx:"12",cy:"6",r:"1"}],["line",{x1:"5",x2:"19",y1:"12",y2:"12"}],["circle",{cx:"12",cy:"18",r:"1"}]],V8=[["path",{d:"M15 2c-1.35 1.5-2.092 3-2.5 4.5L14 8"}],["path",{d:"m17 6-2.891-2.891"}],["path",{d:"M2 15c3.333-3 6.667-3 10-3"}],["path",{d:"m2 2 20 20"}],["path",{d:"m20 9 .891.891"}],["path",{d:"M22 9c-1.5 1.35-3 2.092-4.5 2.5l-1-1"}],["path",{d:"M3.109 14.109 4 15"}],["path",{d:"m6.5 12.5 1 1"}],["path",{d:"m7 18 2.891 2.891"}],["path",{d:"M9 22c1.35-1.5 2.092-3 2.5-4.5L10 16"}]],S8=[["path",{d:"m10 16 1.5 1.5"}],["path",{d:"m14 8-1.5-1.5"}],["path",{d:"M15 2c-1.798 1.998-2.518 3.995-2.807 5.993"}],["path",{d:"m16.5 10.5 1 1"}],["path",{d:"m17 6-2.891-2.891"}],["path",{d:"M2 15c6.667-6 13.333 0 20-6"}],["path",{d:"m20 9 .891.891"}],["path",{d:"M3.109 14.109 4 15"}],["path",{d:"m6.5 12.5 1 1"}],["path",{d:"m7 18 2.891 2.891"}],["path",{d:"M9 22c1.798-1.998 2.518-3.995 2.807-5.993"}]],L8=[["path",{d:"M11.25 16.25h1.5L12 17z"}],["path",{d:"M16 14v.5"}],["path",{d:"M4.42 11.247A13.152 13.152 0 0 0 4 14.556C4 18.728 7.582 21 12 21s8-2.272 8-6.444a11.702 11.702 0 0 0-.493-3.309"}],["path",{d:"M8 14v.5"}],["path",{d:"M8.5 8.5c-.384 1.05-1.083 2.028-2.344 2.5-1.931.722-3.576-.297-3.656-1-.113-.994 1.177-6.53 4-7 1.923-.321 3.651.845 3.651 2.235A7.497 7.497 0 0 1 14 5.277c0-1.39 1.844-2.598 3.767-2.277 2.823.47 4.113 6.006 4 7-.08.703-1.725 1.722-3.656 1-1.261-.472-1.855-1.45-2.239-2.5"}]],f8=[["path",{d:"M2 8h20"}],["rect",{width:"20",height:"16",x:"2",y:"4",rx:"2"}],["path",{d:"M6 16h12"}]],k8=[["line",{x1:"12",x2:"12",y1:"2",y2:"22"}],["path",{d:"M17 5H9.5a3.5 3.5 0 0 0 0 7h5a3.5 3.5 0 0 1 0 7H6"}]],P8=[["path",{d:"M20.5 10a2.5 2.5 0 0 1-2.4-3H18a2.95 2.95 0 0 1-2.6-4.4 10 10 0 1 0 6.3 7.1c-.3.2-.8.3-1.2.3"}],["circle",{cx:"12",cy:"12",r:"3"}]],B8=[["path",{d:"M10 12h.01"}],["path",{d:"M18 9V6a2 2 0 0 0-2-2H8a2 2 0 0 0-2 2v14"}],["path",{d:"M2 20h8"}],["path",{d:"M20 17v-2a2 2 0 1 0-4 0v2"}],["rect",{x:"14",y:"17",width:"8",height:"5",rx:"1"}]],D8=[["path",{d:"M10 12h.01"}],["path",{d:"M18 20V6a2 2 0 0 0-2-2H8a2 2 0 0 0-2 2v14"}],["path",{d:"M2 20h20"}]],F8=[["path",{d:"M11 20H2"}],["path",{d:"M11 4.562v16.157a1 1 0 0 0 1.242.97L19 20V5.562a2 2 0 0 0-1.515-1.94l-4-1A2 2 0 0 0 11 4.561z"}],["path",{d:"M11 4H8a2 2 0 0 0-2 2v14"}],["path",{d:"M14 12h.01"}],["path",{d:"M22 20h-3"}]],z8=[["path",{d:"M12 15V3"}],["path",{d:"M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"}],["path",{d:"m7 10 5 5 5-5"}]],b8=[["circle",{cx:"12.1",cy:"12.1",r:"1"}]],R8=[["path",{d:"m12.99 6.74 1.93 3.44"}],["path",{d:"M19.136 12a10 10 0 0 1-14.271 0"}],["path",{d:"m21 21-2.16-3.84"}],["path",{d:"m3 21 8.02-14.26"}],["circle",{cx:"12",cy:"5",r:"2"}]],T8=[["path",{d:"M10 11h.01"}],["path",{d:"M14 6h.01"}],["path",{d:"M18 6h.01"}],["path",{d:"M6.5 13.1h.01"}],["path",{d:"M22 5c0 9-4 12-6 12s-6-3-6-12c0-2 2-3 6-3s6 1 6 3"}],["path",{d:"M17.4 9.9c-.8.8-2 .8-2.8 0"}],["path",{d:"M10.1 7.1C9 7.2 7.7 7.7 6 8.6c-3.5 2-4.7 3.9-3.7 5.6 4.5 7.8 9.5 8.4 11.2 7.4.9-.5 1.9-2.1 1.9-4.7"}],["path",{d:"M9.1 16.5c.3-1.1 1.4-1.7 2.4-1.4"}]],q8=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M19.13 5.09C15.22 9.14 10 10.44 2.25 10.94"}],["path",{d:"M21.75 12.84c-6.62-1.41-12.14 1-16.38 6.32"}],["path",{d:"M8.56 2.75c4.37 6 6 9.42 8 17.72"}]],U8=[["path",{d:"M10 18a1 1 0 0 1 1 1v2a1 1 0 0 1-1 1H5a3 3 0 0 1-3-3 1 1 0 0 1 1-1z"}],["path",{d:"M13 10H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a1 1 0 0 1 1 1v6a1 1 0 0 1-1 1l-.81 3.242a1 1 0 0 1-.97.758H8"}],["path",{d:"M14 4h3a1 1 0 0 1 1 1v2a1 1 0 0 1-1 1h-3"}],["path",{d:"M18 6h4"}],["path",{d:"m5 10-2 8"}],["path",{d:"m7 18 2-8"}]],O8=[["path",{d:"M10 10 7 7"}],["path",{d:"m10 14-3 3"}],["path",{d:"m14 10 3-3"}],["path",{d:"m14 14 3 3"}],["path",{d:"M14.205 4.139a4 4 0 1 1 5.439 5.863"}],["path",{d:"M19.637 14a4 4 0 1 1-5.432 5.868"}],["path",{d:"M4.367 10a4 4 0 1 1 5.438-5.862"}],["path",{d:"M9.795 19.862a4 4 0 1 1-5.429-5.873"}],["rect",{x:"10",y:"8",width:"4",height:"8",rx:"1"}]],Z8=[["path",{d:"M12 22a7 7 0 0 0 7-7c0-2-1-3.9-3-5.5s-3.5-4-4-6.5c-.5 2.5-2 4.9-4 6.5C6 11.1 5 13 5 15a7 7 0 0 0 7 7z"}]],G8=[["path",{d:"M18.715 13.186C18.29 11.858 17.384 10.607 16 9.5c-2-1.6-3.5-4-4-6.5a10.7 10.7 0 0 1-.884 2.586"}],["path",{d:"m2 2 20 20"}],["path",{d:"M8.795 8.797A11 11 0 0 1 8 9.5C6 11.1 5 13 5 15a7 7 0 0 0 13.222 3.208"}]],I8=[["path",{d:"M7 16.3c2.2 0 4-1.83 4-4.05 0-1.16-.57-2.26-1.71-3.19S7.29 6.75 7 5.3c-.29 1.45-1.14 2.84-2.29 3.76S3 11.1 3 12.25c0 2.22 1.8 4.05 4 4.05z"}],["path",{d:"M12.56 6.6A10.97 10.97 0 0 0 14 3.02c.5 2.5 2 4.9 4 6.5s3 3.5 3 5.5a6.98 6.98 0 0 1-11.91 4.97"}]],W8=[["path",{d:"m2 2 8 8"}],["path",{d:"m22 2-8 8"}],["ellipse",{cx:"12",cy:"9",rx:"10",ry:"5"}],["path",{d:"M7 13.4v7.9"}],["path",{d:"M12 14v8"}],["path",{d:"M17 13.4v7.9"}],["path",{d:"M2 9v8a10 5 0 0 0 20 0V9"}]],E8=[["path",{d:"M15.4 15.63a7.875 6 135 1 1 6.23-6.23 4.5 3.43 135 0 0-6.23 6.23"}],["path",{d:"m8.29 12.71-2.6 2.6a2.5 2.5 0 1 0-1.65 4.65A2.5 2.5 0 1 0 8.7 18.3l2.59-2.59"}]],X8=[["path",{d:"M17.596 12.768a2 2 0 1 0 2.829-2.829l-1.768-1.767a2 2 0 0 0 2.828-2.829l-2.828-2.828a2 2 0 0 0-2.829 2.828l-1.767-1.768a2 2 0 1 0-2.829 2.829z"}],["path",{d:"m2.5 21.5 1.4-1.4"}],["path",{d:"m20.1 3.9 1.4-1.4"}],["path",{d:"M5.343 21.485a2 2 0 1 0 2.829-2.828l1.767 1.768a2 2 0 1 0 2.829-2.829l-6.364-6.364a2 2 0 1 0-2.829 2.829l1.768 1.767a2 2 0 0 0-2.828 2.829z"}],["path",{d:"m9.6 14.4 4.8-4.8"}]],j8=[["path",{d:"M6 8.5a6.5 6.5 0 1 1 13 0c0 6-6 6-6 10a3.5 3.5 0 1 1-7 0"}],["path",{d:"M15 8.5a2.5 2.5 0 0 0-5 0v1a2 2 0 1 1 0 4"}]],N8=[["path",{d:"M6 18.5a3.5 3.5 0 1 0 7 0c0-1.57.92-2.52 2.04-3.46"}],["path",{d:"M6 8.5c0-.75.13-1.47.36-2.14"}],["path",{d:"M8.8 3.15A6.5 6.5 0 0 1 19 8.5c0 1.63-.44 2.81-1.09 3.76"}],["path",{d:"M12.5 6A2.5 2.5 0 0 1 15 8.5M10 13a2 2 0 0 0 1.82-1.18"}],["line",{x1:"2",x2:"22",y1:"2",y2:"22"}]],K8=[["path",{d:"M7 3.34V5a3 3 0 0 0 3 3"}],["path",{d:"M11 21.95V18a2 2 0 0 0-2-2 2 2 0 0 1-2-2v-1a2 2 0 0 0-2-2H2.05"}],["path",{d:"M21.54 15H17a2 2 0 0 0-2 2v4.54"}],["path",{d:"M12 2a10 10 0 1 0 9.54 13"}],["path",{d:"M20 6V4a2 2 0 1 0-4 0v2"}],["rect",{width:"8",height:"5",x:"14",y:"6",rx:"1"}]],F1=[["path",{d:"M21.54 15H17a2 2 0 0 0-2 2v4.54"}],["path",{d:"M7 3.34V5a3 3 0 0 0 3 3a2 2 0 0 1 2 2c0 1.1.9 2 2 2a2 2 0 0 0 2-2c0-1.1.9-2 2-2h3.17"}],["path",{d:"M11 21.95V18a2 2 0 0 0-2-2a2 2 0 0 1-2-2v-1a2 2 0 0 0-2-2H2.05"}],["circle",{cx:"12",cy:"12",r:"10"}]],Q8=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M12 2a7 7 0 1 0 10 10"}]],J8=[["circle",{cx:"11.5",cy:"12.5",r:"3.5"}],["path",{d:"M3 8c0-3.5 2.5-6 6.5-6 5 0 4.83 3 7.5 5s5 2 5 6c0 4.5-2.5 6.5-7 6.5-2.5 0-2.5 2.5-6 2.5s-7-2-7-5.5c0-3 1.5-3 1.5-5C3.5 10 3 9 3 8Z"}]],Y8=[["path",{d:"m2 2 20 20"}],["path",{d:"M20 14.347V14c0-6-4-12-8-12-1.078 0-2.157.436-3.157 1.19"}],["path",{d:"M6.206 6.21C4.871 8.4 4 11.2 4 14a8 8 0 0 0 14.568 4.568"}]],_8=[["path",{d:"M12 2C8 2 4 8 4 14a8 8 0 0 0 16 0c0-6-4-12-8-12"}]],z1=[["circle",{cx:"12",cy:"12",r:"1"}],["circle",{cx:"12",cy:"5",r:"1"}],["circle",{cx:"12",cy:"19",r:"1"}]],b1=[["circle",{cx:"12",cy:"12",r:"1"}],["circle",{cx:"19",cy:"12",r:"1"}],["circle",{cx:"5",cy:"12",r:"1"}]],x8=[["path",{d:"M5 15a6.5 6.5 0 0 1 7 0 6.5 6.5 0 0 0 7 0"}],["path",{d:"M5 9a6.5 6.5 0 0 1 7 0 6.5 6.5 0 0 0 7 0"}]],ac=[["line",{x1:"5",x2:"19",y1:"9",y2:"9"}],["line",{x1:"5",x2:"19",y1:"15",y2:"15"}],["line",{x1:"19",x2:"5",y1:"5",y2:"19"}]],tc=[["line",{x1:"5",x2:"19",y1:"9",y2:"9"}],["line",{x1:"5",x2:"19",y1:"15",y2:"15"}]],hc=[["path",{d:"M21 21H8a2 2 0 0 1-1.42-.587l-3.994-3.999a2 2 0 0 1 0-2.828l10-10a2 2 0 0 1 2.829 0l5.999 6a2 2 0 0 1 0 2.828L12.834 21"}],["path",{d:"m5.082 11.09 8.828 8.828"}]],dc=[["path",{d:"m15 20 3-3h2a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h2l3 3z"}],["path",{d:"M6 8v1"}],["path",{d:"M10 8v1"}],["path",{d:"M14 8v1"}],["path",{d:"M18 8v1"}]],cc=[["path",{d:"M4 10h12"}],["path",{d:"M4 14h9"}],["path",{d:"M19 6a7.7 7.7 0 0 0-5.2-2A7.9 7.9 0 0 0 6 12c0 4.4 3.5 8 7.8 8 2 0 3.8-.8 5.2-2"}]],Mc=[["path",{d:"M14 13h2a2 2 0 0 1 2 2v2a2 2 0 0 0 4 0v-6.998a2 2 0 0 0-.59-1.42L18 5"}],["path",{d:"M14 21V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v16"}],["path",{d:"M2 21h13"}],["path",{d:"M3 7h11"}],["path",{d:"m9 11-2 3h3l-2 3"}]],pc=[["path",{d:"m15 15 6 6"}],["path",{d:"m15 9 6-6"}],["path",{d:"M21 16v5h-5"}],["path",{d:"M21 8V3h-5"}],["path",{d:"M3 16v5h5"}],["path",{d:"m3 21 6-6"}],["path",{d:"M3 8V3h5"}],["path",{d:"M9 9 3 3"}]],ic=[["path",{d:"M15 3h6v6"}],["path",{d:"M10 14 21 3"}],["path",{d:"M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"}]],nc=[["path",{d:"m15 18-.722-3.25"}],["path",{d:"M2 8a10.645 10.645 0 0 0 20 0"}],["path",{d:"m20 15-1.726-2.05"}],["path",{d:"m4 15 1.726-2.05"}],["path",{d:"m9 18 .722-3.25"}]],lc=[["path",{d:"M10.733 5.076a10.744 10.744 0 0 1 11.205 6.575 1 1 0 0 1 0 .696 10.747 10.747 0 0 1-1.444 2.49"}],["path",{d:"M14.084 14.158a3 3 0 0 1-4.242-4.242"}],["path",{d:"M17.479 17.499a10.75 10.75 0 0 1-15.417-5.151 1 1 0 0 1 0-.696 10.75 10.75 0 0 1 4.446-5.143"}],["path",{d:"m2 2 20 20"}]],ec=[["path",{d:"M2.062 12.348a1 1 0 0 1 0-.696 10.75 10.75 0 0 1 19.876 0 1 1 0 0 1 0 .696 10.75 10.75 0 0 1-19.876 0"}],["circle",{cx:"12",cy:"12",r:"3"}]],rc=[["path",{d:"M18 2h-3a5 5 0 0 0-5 5v3H7v4h3v8h4v-8h3l1-4h-4V7a1 1 0 0 1 1-1h3z"}]],oc=[["path",{d:"M12 16h.01"}],["path",{d:"M16 16h.01"}],["path",{d:"M3 19a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V8.5a.5.5 0 0 0-.769-.422l-4.462 2.844A.5.5 0 0 1 15 10.5v-2a.5.5 0 0 0-.769-.422L9.77 10.922A.5.5 0 0 1 9 10.5V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2z"}],["path",{d:"M8 16h.01"}]],vc=[["path",{d:"M10.827 16.379a6.082 6.082 0 0 1-8.618-7.002l5.412 1.45a6.082 6.082 0 0 1 7.002-8.618l-1.45 5.412a6.082 6.082 0 0 1 8.618 7.002l-5.412-1.45a6.082 6.082 0 0 1-7.002 8.618l1.45-5.412Z"}],["path",{d:"M12 12v.01"}]],$c=[["path",{d:"M12.67 19a2 2 0 0 0 1.416-.588l6.154-6.172a6 6 0 0 0-8.49-8.49L5.586 9.914A2 2 0 0 0 5 11.328V18a1 1 0 0 0 1 1z"}],["path",{d:"M16 8 2 22"}],["path",{d:"M17.5 15H9"}]],mc=[["path",{d:"M12 6a2 2 0 0 1 3.414-1.414l6 6a2 2 0 0 1 0 2.828l-6 6A2 2 0 0 1 12 18z"}],["path",{d:"M2 6a2 2 0 0 1 3.414-1.414l6 6a2 2 0 0 1 0 2.828l-6 6A2 2 0 0 1 2 18z"}]],yc=[["path",{d:"M4 3 2 5v15c0 .6.4 1 1 1h2c.6 0 1-.4 1-1V5Z"}],["path",{d:"M6 8h4"}],["path",{d:"M6 18h4"}],["path",{d:"m12 3-2 2v15c0 .6.4 1 1 1h2c.6 0 1-.4 1-1V5Z"}],["path",{d:"M14 8h4"}],["path",{d:"M14 18h4"}],["path",{d:"m20 3-2 2v15c0 .6.4 1 1 1h2c.6 0 1-.4 1-1V5Z"}]],sc=[["circle",{cx:"12",cy:"12",r:"2"}],["path",{d:"M12 2v4"}],["path",{d:"m6.8 15-3.5 2"}],["path",{d:"m20.7 7-3.5 2"}],["path",{d:"M6.8 9 3.3 7"}],["path",{d:"m20.7 17-3.5-2"}],["path",{d:"m9 22 3-8 3 8"}],["path",{d:"M8 22h8"}],["path",{d:"M18 18.7a9 9 0 1 0-12 0"}]],gc=[["path",{d:"M5 5.5A3.5 3.5 0 0 1 8.5 2H12v7H8.5A3.5 3.5 0 0 1 5 5.5z"}],["path",{d:"M12 2h3.5a3.5 3.5 0 1 1 0 7H12V2z"}],["path",{d:"M12 12.5a3.5 3.5 0 1 1 7 0 3.5 3.5 0 1 1-7 0z"}],["path",{d:"M5 19.5A3.5 3.5 0 0 1 8.5 16H12v3.5a3.5 3.5 0 1 1-7 0z"}],["path",{d:"M5 12.5A3.5 3.5 0 0 1 8.5 9H12v7H8.5A3.5 3.5 0 0 1 5 12.5z"}]],uc=[["path",{d:"M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v2"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["circle",{cx:"3",cy:"17",r:"1"}],["path",{d:"M2 17v-3a4 4 0 0 1 8 0v3"}],["circle",{cx:"9",cy:"17",r:"1"}]],Cc=[["path",{d:"M10 12v-1"}],["path",{d:"M10 18v-2"}],["path",{d:"M10 7V6"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M15.5 22H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v16a2 2 0 0 0 .274 1.01"}],["circle",{cx:"10",cy:"20",r:"2"}]],Hc=[["path",{d:"M17.5 22h.5a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M2 19a2 2 0 1 1 4 0v1a2 2 0 1 1-4 0v-4a6 6 0 0 1 12 0v4a2 2 0 1 1-4 0v-1a2 2 0 1 1 4 0"}]],R1=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"m8 18 4-4"}],["path",{d:"M8 10v8h8"}]],Ac=[["path",{d:"m13.69 12.479 1.29 4.88a.5.5 0 0 1-.697.591l-1.844-.849a1 1 0 0 0-.88.001l-1.846.85a.5.5 0 0 1-.693-.593l1.29-4.88"}],["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7z"}],["circle",{cx:"12",cy:"10",r:"3"}]],wc=[["path",{d:"M12 22h6a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3.072"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"m6.69 16.479 1.29 4.88a.5.5 0 0 1-.698.591l-1.843-.849a1 1 0 0 0-.88.001l-1.846.85a.5.5 0 0 1-.693-.593l1.29-4.88"}],["circle",{cx:"5",cy:"14",r:"3"}]],Vc=[["path",{d:"M14.5 22H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M3 13.1a2 2 0 0 0-1 1.76v3.24a2 2 0 0 0 .97 1.78L6 21.7a2 2 0 0 0 2.03.01L11 19.9a2 2 0 0 0 1-1.76V14.9a2 2 0 0 0-.97-1.78L8 11.3a2 2 0 0 0-2.03-.01Z"}],["path",{d:"M7 17v5"}],["path",{d:"M11.7 14.2 7 17l-4.7-2.8"}]],T1=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M8 18v-2"}],["path",{d:"M12 18v-4"}],["path",{d:"M16 18v-6"}]],q1=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M8 18v-1"}],["path",{d:"M12 18v-6"}],["path",{d:"M16 18v-3"}]],U1=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"m16 13-3.5 3.5-2-2L8 17"}]],O1=[["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M16 22h2a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3.5"}],["path",{d:"M4.017 11.512a6 6 0 1 0 8.466 8.475"}],["path",{d:"M9 16a1 1 0 0 1-1-1v-4c0-.552.45-1.008.995-.917a6 6 0 0 1 4.922 4.922c.091.544-.365.995-.917.995z"}]],Sc=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"m9 15 2 2 4-4"}]],Lc=[["path",{d:"M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"m3 15 2 2 4-4"}]],fc=[["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M16 22h2a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3"}],["path",{d:"M8 14v2.2l1.6 1"}],["circle",{cx:"8",cy:"16",r:"6"}]],kc=[["path",{d:"M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"m5 12-3 3 3 3"}],["path",{d:"m9 18 3-3-3-3"}]],Pc=[["path",{d:"M10 12.5 8 15l2 2.5"}],["path",{d:"m14 12.5 2 2.5-2 2.5"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7z"}]],Z1=[["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"m2.305 15.53.923-.382"}],["path",{d:"m3.228 12.852-.924-.383"}],["path",{d:"M4.677 21.5a2 2 0 0 0 1.313.5H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v2.5"}],["path",{d:"m4.852 11.228-.383-.923"}],["path",{d:"m4.852 16.772-.383.924"}],["path",{d:"m7.148 11.228.383-.923"}],["path",{d:"m7.53 17.696-.382-.924"}],["path",{d:"m8.772 12.852.923-.383"}],["path",{d:"m8.772 15.148.923.383"}],["circle",{cx:"6",cy:"14",r:"3"}]],Bc=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M9 10h6"}],["path",{d:"M12 13V7"}],["path",{d:"M9 17h6"}]],Dc=[["path",{d:"M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["rect",{width:"4",height:"6",x:"2",y:"12",rx:"2"}],["path",{d:"M10 12h2v6"}],["path",{d:"M10 18h4"}]],Fc=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M12 18v-6"}],["path",{d:"m9 15 3 3 3-3"}]],zc=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["circle",{cx:"10",cy:"12",r:"2"}],["path",{d:"m20 17-1.296-1.296a2.41 2.41 0 0 0-3.408 0L9 22"}]],bc=[["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M2.62 13.8A2.25 2.25 0 1 1 6 10.836a2.25 2.25 0 1 1 3.38 2.966l-2.626 2.856a.998.998 0 0 1-1.507 0z"}],["path",{d:"M4 6.005V4a2 2 0 0 1 2-2h9l5 5v13a2 2 0 0 1-2 2H6a2 2 0 0 1-1.9-1.376"}]],Rc=[["path",{d:"M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M2 15h10"}],["path",{d:"m9 18 3-3-3-3"}]],Tc=[["path",{d:"M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M4 12a1 1 0 0 0-1 1v1a1 1 0 0 1-1 1 1 1 0 0 1 1 1v1a1 1 0 0 0 1 1"}],["path",{d:"M8 18a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1 1 1 0 0 1-1-1v-1a1 1 0 0 0-1-1"}]],qc=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M10 12a1 1 0 0 0-1 1v1a1 1 0 0 1-1 1 1 1 0 0 1 1 1v1a1 1 0 0 0 1 1"}],["path",{d:"M14 18a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1 1 1 0 0 1-1-1v-1a1 1 0 0 0-1-1"}]],Uc=[["path",{d:"M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v6"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["circle",{cx:"4",cy:"16",r:"2"}],["path",{d:"m10 10-4.5 4.5"}],["path",{d:"m9 11 1 1"}]],Oc=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["circle",{cx:"10",cy:"16",r:"2"}],["path",{d:"m16 10-4.5 4.5"}],["path",{d:"m15 11 1 1"}]],Zc=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["rect",{width:"8",height:"6",x:"8",y:"12",rx:"1"}],["path",{d:"M10 12v-2a2 2 0 1 1 4 0v2"}]],Gc=[["path",{d:"M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v1"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["rect",{width:"8",height:"5",x:"2",y:"13",rx:"1"}],["path",{d:"M8 13v-2a2 2 0 1 0-4 0v2"}]],Ic=[["path",{d:"M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M3 15h6"}]],Wc=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M9 15h6"}]],Ec=[["path",{d:"M10.5 22H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v8.4"}],["path",{d:"M8 18v-7.7L16 9v7"}],["circle",{cx:"14",cy:"16",r:"2"}],["circle",{cx:"6",cy:"18",r:"2"}]],Xc=[["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M4 7V4a2 2 0 0 1 2-2 2 2 0 0 0-2 2"}],["path",{d:"M4.063 20.999a2 2 0 0 0 2 1L18 22a2 2 0 0 0 2-2V7l-5-5H6"}],["path",{d:"m5 11-3 3"}],["path",{d:"m5 17-3-3h10"}]],G1=[["path",{d:"m18 5-2.414-2.414A2 2 0 0 0 14.172 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2"}],["path",{d:"M21.378 12.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"}],["path",{d:"M8 18h1"}]],I1=[["path",{d:"M12.5 22H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v9.5"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M13.378 15.626a1 1 0 1 0-3.004-3.004l-5.01 5.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"}]],W1=[["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7z"}],["path",{d:"M15.033 13.44a.647.647 0 0 1 0 1.12l-4.065 2.352a.645.645 0 0 1-.968-.56v-4.704a.645.645 0 0 1 .967-.56z"}]],jc=[["path",{d:"M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M3 15h6"}],["path",{d:"M6 12v6"}]],Nc=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M9 15h6"}],["path",{d:"M12 18v-6"}]],E1=[["path",{d:"M12 17h.01"}],["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7z"}],["path",{d:"M9.1 9a3 3 0 0 1 5.82 1c0 2-3 3-3 3"}]],Kc=[["path",{d:"M20 10V7l-5-5H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h4"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M16 14a2 2 0 0 0-2 2"}],["path",{d:"M20 14a2 2 0 0 1 2 2"}],["path",{d:"M20 22a2 2 0 0 0 2-2"}],["path",{d:"M16 22a2 2 0 0 1-2-2"}]],Qc=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["circle",{cx:"11.5",cy:"14.5",r:"2.5"}],["path",{d:"M13.3 16.3 15 18"}]],Jc=[["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M4.268 21a2 2 0 0 0 1.727 1H18a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v3"}],["path",{d:"m9 18-1.5-1.5"}],["circle",{cx:"5",cy:"14",r:"3"}]],Yc=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M8 12h8"}],["path",{d:"M10 11v2"}],["path",{d:"M8 17h8"}],["path",{d:"M14 16v2"}]],_c=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M8 13h2"}],["path",{d:"M14 13h2"}],["path",{d:"M8 17h2"}],["path",{d:"M14 17h2"}]],xc=[["path",{d:"M11 21a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1v-8a1 1 0 0 1 1-1"}],["path",{d:"M16 16a1 1 0 0 1-1 1H9a1 1 0 0 1-1-1V8a1 1 0 0 1 1-1"}],["path",{d:"M21 6a2 2 0 0 0-.586-1.414l-2-2A2 2 0 0 0 17 2h-3a1 1 0 0 0-1 1v8a1 1 0 0 0 1 1h6a1 1 0 0 0 1-1z"}]],a7=[["path",{d:"m10 18 3-3-3-3"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M4 11V4a2 2 0 0 1 2-2h9l5 5v13a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h7"}]],t7=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"m8 16 2-2-2-2"}],["path",{d:"M12 18h4"}]],h7=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M10 9H8"}],["path",{d:"M16 13H8"}],["path",{d:"M16 17H8"}]],d7=[["path",{d:"M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M2 13v-1h6v1"}],["path",{d:"M5 12v6"}],["path",{d:"M4 18h2"}]],c7=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M9 13v-1h6v1"}],["path",{d:"M12 12v6"}],["path",{d:"M11 18h2"}]],M7=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M12 12v6"}],["path",{d:"m15 15-3-3-3 3"}]],p7=[["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M15 18a3 3 0 1 0-6 0"}],["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7z"}],["circle",{cx:"12",cy:"13",r:"2"}]],X1=[["path",{d:"M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["rect",{width:"8",height:"6",x:"2",y:"12",rx:"1"}],["path",{d:"m10 13.843 3.033-1.755a.645.645 0 0 1 .967.56v4.704a.645.645 0 0 1-.967.56L10 16.157"}]],i7=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M8 15h.01"}],["path",{d:"M11.5 13.5a2.5 2.5 0 0 1 0 3"}],["path",{d:"M15 12a5 5 0 0 1 0 6"}]],n7=[["path",{d:"M11 11a5 5 0 0 1 0 6"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M4 6.765V4a2 2 0 0 1 2-2h9l5 5v13a2 2 0 0 1-2 2H6a2 2 0 0 1-.93-.23"}],["path",{d:"M7 10.51a.5.5 0 0 0-.826-.38l-1.893 1.628A1 1 0 0 1 3.63 12H2.5a.5.5 0 0 0-.5.5v3a.5.5 0 0 0 .5.5h1.129a1 1 0 0 1 .652.242l1.893 1.63a.5.5 0 0 0 .826-.38z"}]],l7=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M12 9v4"}],["path",{d:"M12 17h.01"}]],e7=[["path",{d:"M4 22h14a2 2 0 0 0 2-2V7l-5-5H6a2 2 0 0 0-2 2v4"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"m8 12.5-5 5"}],["path",{d:"m3 12.5 5 5"}]],r7=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"m14.5 12.5-5 5"}],["path",{d:"m9.5 12.5 5 5"}]],o7=[["path",{d:"M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}]],v7=[["path",{d:"M15 2a2 2 0 0 1 1.414.586l4 4A2 2 0 0 1 21 8v7a2 2 0 0 1-2 2h-8a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2z"}],["path",{d:"M15 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M5 7a2 2 0 0 0-2 2v11a2 2 0 0 0 2 2h8a2 2 0 0 0 1.732-1"}]],$7=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M7 3v18"}],["path",{d:"M3 7.5h4"}],["path",{d:"M3 12h18"}],["path",{d:"M3 16.5h4"}],["path",{d:"M17 3v18"}],["path",{d:"M17 7.5h4"}],["path",{d:"M17 16.5h4"}]],m7=[["path",{d:"M12 10a2 2 0 0 0-2 2c0 1.02-.1 2.51-.26 4"}],["path",{d:"M14 13.12c0 2.38 0 6.38-1 8.88"}],["path",{d:"M17.29 21.02c.12-.6.43-2.3.5-3.02"}],["path",{d:"M2 12a10 10 0 0 1 18-6"}],["path",{d:"M2 16h.01"}],["path",{d:"M21.8 16c.2-2 .131-5.354 0-6"}],["path",{d:"M5 19.5C5.5 18 6 15 6 12a6 6 0 0 1 .34-2"}],["path",{d:"M8.65 22c.21-.66.45-1.32.57-2"}],["path",{d:"M9 6.8a6 6 0 0 1 9 5.2v2"}]],y7=[["path",{d:"M15 6.5V3a1 1 0 0 0-1-1h-2a1 1 0 0 0-1 1v3.5"}],["path",{d:"M9 18h8"}],["path",{d:"M18 3h-3"}],["path",{d:"M11 3a6 6 0 0 0-6 6v11"}],["path",{d:"M5 13h4"}],["path",{d:"M17 10a4 4 0 0 0-8 0v10a2 2 0 0 0 2 2h4a2 2 0 0 0 2-2Z"}]],s7=[["path",{d:"M18 12.47v.03m0-.5v.47m-.475 5.056A6.744 6.744 0 0 1 15 18c-3.56 0-7.56-2.53-8.5-6 .348-1.28 1.114-2.433 2.121-3.38m3.444-2.088A8.802 8.802 0 0 1 15 6c3.56 0 6.06 2.54 7 6-.309 1.14-.786 2.177-1.413 3.058"}],["path",{d:"M7 10.67C7 8 5.58 5.97 2.73 5.5c-1 1.5-1 5 .23 6.5-1.24 1.5-1.24 5-.23 6.5C5.58 18.03 7 16 7 13.33m7.48-4.372A9.77 9.77 0 0 1 16 6.07m0 11.86a9.77 9.77 0 0 1-1.728-3.618"}],["path",{d:"m16.01 17.93-.23 1.4A2 2 0 0 1 13.8 21H9.5a5.96 5.96 0 0 0 1.49-3.98M8.53 3h5.27a2 2 0 0 1 1.98 1.67l.23 1.4M2 2l20 20"}]],g7=[["path",{d:"M2 16s9-15 20-4C11 23 2 8 2 8"}]],u7=[["path",{d:"M6.5 12c.94-3.46 4.94-6 8.5-6 3.56 0 6.06 2.54 7 6-.94 3.47-3.44 6-7 6s-7.56-2.53-8.5-6Z"}],["path",{d:"M18 12v.5"}],["path",{d:"M16 17.93a9.77 9.77 0 0 1 0-11.86"}],["path",{d:"M7 10.67C7 8 5.58 5.97 2.73 5.5c-1 1.5-1 5 .23 6.5-1.24 1.5-1.24 5-.23 6.5C5.58 18.03 7 16 7 13.33"}],["path",{d:"M10.46 7.26C10.2 5.88 9.17 4.24 8 3h5.8a2 2 0 0 1 1.98 1.67l.23 1.4"}],["path",{d:"m16.01 17.93-.23 1.4A2 2 0 0 1 13.8 21H9.5a5.96 5.96 0 0 0 1.49-3.98"}]],C7=[["path",{d:"M16 16c-3 0-5-2-8-2a6 6 0 0 0-4 1.528"}],["path",{d:"m2 2 20 20"}],["path",{d:"M4 22V4"}],["path",{d:"M7.656 2H8c3 0 5 2 7.333 2q2 0 3.067-.8A1 1 0 0 1 20 4v10.347"}]],H7=[["path",{d:"M18 22V2.8a.8.8 0 0 0-1.17-.71L5.45 7.78a.8.8 0 0 0 0 1.44L18 15.5"}]],A7=[["path",{d:"M6 22V2.8a.8.8 0 0 1 1.17-.71l11.38 5.69a.8.8 0 0 1 0 1.44L6 15.5"}]],w7=[["path",{d:"M4 22V4a1 1 0 0 1 .4-.8A6 6 0 0 1 8 2c3 0 5 2 7.333 2q2 0 3.067-.8A1 1 0 0 1 20 4v10a1 1 0 0 1-.4.8A6 6 0 0 1 16 16c-3 0-5-2-8-2a6 6 0 0 0-4 1.528"}]],V7=[["path",{d:"M12 2c1 3 2.5 3.5 3.5 4.5A5 5 0 0 1 17 10a5 5 0 1 1-10 0c0-.3 0-.6.1-.9a2 2 0 1 0 3.3-2C8 4.5 11 2 12 2Z"}],["path",{d:"m5 22 14-4"}],["path",{d:"m5 18 14 4"}]],S7=[["path",{d:"M8.5 14.5A2.5 2.5 0 0 0 11 12c0-1.38-.5-2-1-3-1.072-2.143-.224-4.054 2-6 .5 2.5 2 4.9 4 6.5 2 1.6 3 3.5 3 5.5a7 7 0 1 1-14 0c0-1.153.433-2.294 1-3a2.5 2.5 0 0 0 2.5 2.5z"}]],L7=[["path",{d:"M16 16v4a2 2 0 0 1-2 2h-4a2 2 0 0 1-2-2V10c0-2-2-2-2-4"}],["path",{d:"M7 2h11v4c0 2-2 2-2 4v1"}],["line",{x1:"11",x2:"18",y1:"6",y2:"6"}],["line",{x1:"2",x2:"22",y1:"2",y2:"22"}]],f7=[["path",{d:"M18 6c0 2-2 2-2 4v10a2 2 0 0 1-2 2h-4a2 2 0 0 1-2-2V10c0-2-2-2-2-4V2h12z"}],["line",{x1:"6",x2:"18",y1:"6",y2:"6"}],["line",{x1:"12",x2:"12",y1:"12",y2:"12"}]],k7=[["path",{d:"M10 2v2.343"}],["path",{d:"M14 2v6.343"}],["path",{d:"m2 2 20 20"}],["path",{d:"M20 20a2 2 0 0 1-2 2H6a2 2 0 0 1-1.755-2.96l5.227-9.563"}],["path",{d:"M6.453 15H15"}],["path",{d:"M8.5 2h7"}]],P7=[["path",{d:"M14 2v6a2 2 0 0 0 .245.96l5.51 10.08A2 2 0 0 1 18 22H6a2 2 0 0 1-1.755-2.96l5.51-10.08A2 2 0 0 0 10 8V2"}],["path",{d:"M6.453 15h11.094"}],["path",{d:"M8.5 2h7"}]],B7=[["path",{d:"M10 2v6.292a7 7 0 1 0 4 0V2"}],["path",{d:"M5 15h14"}],["path",{d:"M8.5 2h7"}]],D7=[["path",{d:"m3 7 5 5-5 5V7"}],["path",{d:"m21 7-5 5 5 5V7"}],["path",{d:"M12 20v2"}],["path",{d:"M12 14v2"}],["path",{d:"M12 8v2"}],["path",{d:"M12 2v2"}]],F7=[["path",{d:"M8 3H5a2 2 0 0 0-2 2v14c0 1.1.9 2 2 2h3"}],["path",{d:"M16 3h3a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-3"}],["path",{d:"M12 20v2"}],["path",{d:"M12 14v2"}],["path",{d:"M12 8v2"}],["path",{d:"M12 2v2"}]],z7=[["path",{d:"m17 3-5 5-5-5h10"}],["path",{d:"m17 21-5-5-5 5h10"}],["path",{d:"M4 12H2"}],["path",{d:"M10 12H8"}],["path",{d:"M16 12h-2"}],["path",{d:"M22 12h-2"}]],b7=[["path",{d:"M21 8V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v3"}],["path",{d:"M21 16v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-3"}],["path",{d:"M4 12H2"}],["path",{d:"M10 12H8"}],["path",{d:"M16 12h-2"}],["path",{d:"M22 12h-2"}]],R7=[["circle",{cx:"12",cy:"12",r:"3"}],["path",{d:"M12 16.5A4.5 4.5 0 1 1 7.5 12 4.5 4.5 0 1 1 12 7.5a4.5 4.5 0 1 1 4.5 4.5 4.5 4.5 0 1 1-4.5 4.5"}],["path",{d:"M12 7.5V9"}],["path",{d:"M7.5 12H9"}],["path",{d:"M16.5 12H15"}],["path",{d:"M12 16.5V15"}],["path",{d:"m8 8 1.88 1.88"}],["path",{d:"M14.12 9.88 16 8"}],["path",{d:"m8 16 1.88-1.88"}],["path",{d:"M14.12 14.12 16 16"}]],T7=[["path",{d:"M12 5a3 3 0 1 1 3 3m-3-3a3 3 0 1 0-3 3m3-3v1M9 8a3 3 0 1 0 3 3M9 8h1m5 0a3 3 0 1 1-3 3m3-3h-1m-2 3v-1"}],["circle",{cx:"12",cy:"8",r:"2"}],["path",{d:"M12 10v12"}],["path",{d:"M12 22c4.2 0 7-1.667 7-5-4.2 0-7 1.667-7 5Z"}],["path",{d:"M12 22c-4.2 0-7-1.667-7-5 4.2 0 7 1.667 7 5Z"}]],q7=[["circle",{cx:"12",cy:"12",r:"3"}],["path",{d:"M3 7V5a2 2 0 0 1 2-2h2"}],["path",{d:"M17 3h2a2 2 0 0 1 2 2v2"}],["path",{d:"M21 17v2a2 2 0 0 1-2 2h-2"}],["path",{d:"M7 21H5a2 2 0 0 1-2-2v-2"}]],U7=[["path",{d:"M2 12h6"}],["path",{d:"M22 12h-6"}],["path",{d:"M12 2v2"}],["path",{d:"M12 8v2"}],["path",{d:"M12 14v2"}],["path",{d:"M12 20v2"}],["path",{d:"m19 9-3 3 3 3"}],["path",{d:"m5 15 3-3-3-3"}]],O7=[["path",{d:"M12 22v-6"}],["path",{d:"M12 8V2"}],["path",{d:"M4 12H2"}],["path",{d:"M10 12H8"}],["path",{d:"M16 12h-2"}],["path",{d:"M22 12h-2"}],["path",{d:"m15 19-3-3-3 3"}],["path",{d:"m15 5-3 3-3-3"}]],Z7=[["circle",{cx:"15",cy:"19",r:"2"}],["path",{d:"M20.9 19.8A2 2 0 0 0 22 18V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2h5.1"}],["path",{d:"M15 11v-1"}],["path",{d:"M15 17v-2"}]],G7=[["path",{d:"M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"}],["path",{d:"m9 13 2 2 4-4"}]],I7=[["path",{d:"M16 14v2.2l1.6 1"}],["path",{d:"M7 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2"}],["circle",{cx:"16",cy:"16",r:"6"}]],W7=[["path",{d:"M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"}],["path",{d:"M2 10h20"}]],E7=[["path",{d:"M10 10.5 8 13l2 2.5"}],["path",{d:"m14 10.5 2 2.5-2 2.5"}],["path",{d:"M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2z"}]],j1=[["path",{d:"M10.3 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.98a2 2 0 0 1 1.69.9l.66 1.2A2 2 0 0 0 12 6h8a2 2 0 0 1 2 2v3.3"}],["path",{d:"m14.305 19.53.923-.382"}],["path",{d:"m15.228 16.852-.923-.383"}],["path",{d:"m16.852 15.228-.383-.923"}],["path",{d:"m16.852 20.772-.383.924"}],["path",{d:"m19.148 15.228.383-.923"}],["path",{d:"m19.53 21.696-.382-.924"}],["path",{d:"m20.772 16.852.924-.383"}],["path",{d:"m20.772 19.148.924.383"}],["circle",{cx:"18",cy:"18",r:"3"}]],X7=[["path",{d:"M4 20h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.93a2 2 0 0 1-1.66-.9l-.82-1.2A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13c0 1.1.9 2 2 2Z"}],["circle",{cx:"12",cy:"13",r:"1"}]],j7=[["path",{d:"M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"}],["path",{d:"M12 10v6"}],["path",{d:"m15 13-3 3-3-3"}]],N7=[["path",{d:"M9 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v5"}],["circle",{cx:"13",cy:"12",r:"2"}],["path",{d:"M18 19c-2.8 0-5-2.2-5-5v8"}],["circle",{cx:"20",cy:"19",r:"2"}]],K7=[["path",{d:"M10.638 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v3.417"}],["path",{d:"M14.62 18.8A2.25 2.25 0 1 1 18 15.836a2.25 2.25 0 1 1 3.38 2.966l-2.626 2.856a.998.998 0 0 1-1.507 0z"}]],Q7=[["circle",{cx:"12",cy:"13",r:"2"}],["path",{d:"M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"}],["path",{d:"M14 13h3"}],["path",{d:"M7 13h3"}]],J7=[["path",{d:"M4 20h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.93a2 2 0 0 1-1.66-.9l-.82-1.2A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13c0 1.1.9 2 2 2Z"}],["path",{d:"M8 10v4"}],["path",{d:"M12 10v2"}],["path",{d:"M16 10v6"}]],Y7=[["path",{d:"M2 9V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-1"}],["path",{d:"M2 13h10"}],["path",{d:"m9 16 3-3-3-3"}]],_7=[["circle",{cx:"16",cy:"20",r:"2"}],["path",{d:"M10 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v2"}],["path",{d:"m22 14-4.5 4.5"}],["path",{d:"m21 15 1 1"}]],x7=[["rect",{width:"8",height:"5",x:"14",y:"17",rx:"1"}],["path",{d:"M10 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v2.5"}],["path",{d:"M20 17v-2a2 2 0 1 0-4 0v2"}]],aM=[["path",{d:"M9 13h6"}],["path",{d:"M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"}]],tM=[["path",{d:"m6 14 1.45-2.9A2 2 0 0 1 9.24 10H20a2 2 0 0 1 1.94 2.5l-1.55 6a2 2 0 0 1-1.94 1.5H4a2 2 0 0 1-2-2V5c0-1.1.9-2 2-2h3.93a2 2 0 0 1 1.66.9l.82 1.2a2 2 0 0 0 1.66.9H18a2 2 0 0 1 2 2v2"}],["circle",{cx:"14",cy:"15",r:"1"}]],hM=[["path",{d:"m6 14 1.5-2.9A2 2 0 0 1 9.24 10H20a2 2 0 0 1 1.94 2.5l-1.54 6a2 2 0 0 1-1.95 1.5H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H18a2 2 0 0 1 2 2v2"}]],dM=[["path",{d:"M2 7.5V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-1.5"}],["path",{d:"M2 13h10"}],["path",{d:"m5 10-3 3 3 3"}]],N1=[["path",{d:"M2 11.5V5a2 2 0 0 1 2-2h3.9c.7 0 1.3.3 1.7.9l.8 1.2c.4.6 1 .9 1.7.9H20a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-9.5"}],["path",{d:"M11.378 13.626a1 1 0 1 0-3.004-3.004l-5.01 5.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"}]],cM=[["path",{d:"M4 20h16a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.93a2 2 0 0 1-1.66-.9l-.82-1.2A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13c0 1.1.9 2 2 2Z"}],["circle",{cx:"12",cy:"13",r:"2"}],["path",{d:"M12 15v5"}]],MM=[["path",{d:"M12 10v6"}],["path",{d:"M9 13h6"}],["path",{d:"M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"}]],pM=[["circle",{cx:"11.5",cy:"12.5",r:"2.5"}],["path",{d:"M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"}],["path",{d:"M13.3 14.3 15 16"}]],iM=[["path",{d:"M10.7 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v4.1"}],["path",{d:"m21 21-1.9-1.9"}],["circle",{cx:"17",cy:"17",r:"3"}]],nM=[["path",{d:"M2 9.35V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h7"}],["path",{d:"m8 16 3-3-3-3"}]],lM=[["path",{d:"M9 20H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h3.9a2 2 0 0 1 1.69.9l.81 1.2a2 2 0 0 0 1.67.9H20a2 2 0 0 1 2 2v.5"}],["path",{d:"M12 10v4h4"}],["path",{d:"m12 14 1.535-1.605a5 5 0 0 1 8 1.5"}],["path",{d:"M22 22v-4h-4"}],["path",{d:"m22 18-1.535 1.605a5 5 0 0 1-8-1.5"}]],eM=[["path",{d:"M20 10a1 1 0 0 0 1-1V6a1 1 0 0 0-1-1h-2.5a1 1 0 0 1-.8-.4l-.9-1.2A1 1 0 0 0 15 3h-2a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1Z"}],["path",{d:"M20 21a1 1 0 0 0 1-1v-3a1 1 0 0 0-1-1h-2.9a1 1 0 0 1-.88-.55l-.42-.85a1 1 0 0 0-.92-.6H13a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1Z"}],["path",{d:"M3 5a2 2 0 0 0 2 2h3"}],["path",{d:"M3 3v13a2 2 0 0 0 2 2h3"}]],rM=[["path",{d:"M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"}],["path",{d:"m9.5 10.5 5 5"}],["path",{d:"m14.5 10.5-5 5"}]],oM=[["path",{d:"M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"}],["path",{d:"M12 10v6"}],["path",{d:"m9 13 3-3 3 3"}]],vM=[["path",{d:"M20 20a2 2 0 0 0 2-2V8a2 2 0 0 0-2-2h-7.9a2 2 0 0 1-1.69-.9L9.6 3.9A2 2 0 0 0 7.93 3H4a2 2 0 0 0-2 2v13a2 2 0 0 0 2 2Z"}]],$M=[["path",{d:"M20 5a2 2 0 0 1 2 2v7a2 2 0 0 1-2 2H9a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h2.5a1.5 1.5 0 0 1 1.2.6l.6.8a1.5 1.5 0 0 0 1.2.6z"}],["path",{d:"M3 8.268a2 2 0 0 0-1 1.738V19a2 2 0 0 0 2 2h11a2 2 0 0 0 1.732-1"}]],mM=[["path",{d:"M4 16v-2.38C4 11.5 2.97 10.5 3 8c.03-2.72 1.49-6 4.5-6C9.37 2 10 3.8 10 5.5c0 3.11-2 5.66-2 8.68V16a2 2 0 1 1-4 0Z"}],["path",{d:"M20 20v-2.38c0-2.12 1.03-3.12 1-5.62-.03-2.72-1.49-6-4.5-6C14.63 6 14 7.8 14 9.5c0 3.11 2 5.66 2 8.68V20a2 2 0 1 0 4 0Z"}],["path",{d:"M16 17h4"}],["path",{d:"M4 13h4"}]],yM=[["path",{d:"M12 12H5a2 2 0 0 0-2 2v5"}],["circle",{cx:"13",cy:"19",r:"2"}],["circle",{cx:"5",cy:"19",r:"2"}],["path",{d:"M8 19h3m5-17v17h6M6 12V7c0-1.1.9-2 2-2h3l5 5"}]],sM=[["line",{x1:"22",x2:"2",y1:"6",y2:"6"}],["line",{x1:"22",x2:"2",y1:"18",y2:"18"}],["line",{x1:"6",x2:"6",y1:"2",y2:"22"}],["line",{x1:"18",x2:"18",y1:"2",y2:"22"}]],gM=[["path",{d:"m15 17 5-5-5-5"}],["path",{d:"M4 18v-2a4 4 0 0 1 4-4h12"}]],uM=[["path",{d:"M5 16V9h14V2H5l14 14h-7m-7 0 7 7v-7m-7 0h7"}]],CM=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M16 16s-1.5-2-4-2-4 2-4 2"}],["line",{x1:"9",x2:"9.01",y1:"9",y2:"9"}],["line",{x1:"15",x2:"15.01",y1:"9",y2:"9"}]],HM=[["path",{d:"M14 13h2a2 2 0 0 1 2 2v2a2 2 0 0 0 4 0v-6.998a2 2 0 0 0-.59-1.42L18 5"}],["path",{d:"M14 21V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v16"}],["path",{d:"M2 21h13"}],["path",{d:"M3 9h11"}]],AM=[["path",{d:"M3 7V5a2 2 0 0 1 2-2h2"}],["path",{d:"M17 3h2a2 2 0 0 1 2 2v2"}],["path",{d:"M21 17v2a2 2 0 0 1-2 2h-2"}],["path",{d:"M7 21H5a2 2 0 0 1-2-2v-2"}],["rect",{width:"10",height:"8",x:"7",y:"8",rx:"1"}]],wM=[["path",{d:"M13.354 3H3a1 1 0 0 0-.742 1.67l7.225 7.989A2 2 0 0 1 10 14v6a1 1 0 0 0 .553.895l2 1A1 1 0 0 0 14 21v-7a2 2 0 0 1 .517-1.341l1.218-1.348"}],["path",{d:"M16 6h6"}],["path",{d:"M19 3v6"}]],K1=[["path",{d:"M12.531 3H3a1 1 0 0 0-.742 1.67l7.225 7.989A2 2 0 0 1 10 14v6a1 1 0 0 0 .553.895l2 1A1 1 0 0 0 14 21v-7a2 2 0 0 1 .517-1.341l.427-.473"}],["path",{d:"m16.5 3.5 5 5"}],["path",{d:"m21.5 3.5-5 5"}]],Q1=[["path",{d:"M10 20a1 1 0 0 0 .553.895l2 1A1 1 0 0 0 14 21v-7a2 2 0 0 1 .517-1.341L21.74 4.67A1 1 0 0 0 21 3H3a1 1 0 0 0-.742 1.67l7.225 7.989A2 2 0 0 1 10 14z"}]],VM=[["path",{d:"M2 7v10"}],["path",{d:"M6 5v14"}],["rect",{width:"12",height:"18",x:"10",y:"3",rx:"2"}]],SM=[["path",{d:"M2 3v18"}],["rect",{width:"12",height:"18",x:"6",y:"3",rx:"2"}],["path",{d:"M22 3v18"}]],LM=[["path",{d:"M7 2h10"}],["path",{d:"M5 6h14"}],["rect",{width:"18",height:"12",x:"3",y:"10",rx:"2"}]],fM=[["rect",{width:"18",height:"14",x:"3",y:"3",rx:"2"}],["path",{d:"M4 21h1"}],["path",{d:"M9 21h1"}],["path",{d:"M14 21h1"}],["path",{d:"M19 21h1"}]],kM=[["path",{d:"M3 2h18"}],["rect",{width:"18",height:"12",x:"3",y:"6",rx:"2"}],["path",{d:"M3 22h18"}]],PM=[["line",{x1:"6",x2:"10",y1:"11",y2:"11"}],["line",{x1:"8",x2:"8",y1:"9",y2:"13"}],["line",{x1:"15",x2:"15.01",y1:"12",y2:"12"}],["line",{x1:"18",x2:"18.01",y1:"10",y2:"10"}],["path",{d:"M17.32 5H6.68a4 4 0 0 0-3.978 3.59c-.006.052-.01.101-.017.152C2.604 9.416 2 14.456 2 16a3 3 0 0 0 3 3c1 0 1.5-.5 2-1l1.414-1.414A2 2 0 0 1 9.828 16h4.344a2 2 0 0 1 1.414.586L17 18c.5.5 1 1 2 1a3 3 0 0 0 3-3c0-1.545-.604-6.584-.685-7.258-.007-.05-.011-.1-.017-.151A4 4 0 0 0 17.32 5z"}]],BM=[["line",{x1:"6",x2:"10",y1:"12",y2:"12"}],["line",{x1:"8",x2:"8",y1:"10",y2:"14"}],["line",{x1:"15",x2:"15.01",y1:"13",y2:"13"}],["line",{x1:"18",x2:"18.01",y1:"11",y2:"11"}],["rect",{width:"20",height:"12",x:"2",y:"6",rx:"2"}]],DM=[["path",{d:"m12 14 4-4"}],["path",{d:"M3.34 19a10 10 0 1 1 17.32 0"}]],FM=[["path",{d:"m14 13-8.381 8.38a1 1 0 0 1-3.001-3l8.384-8.381"}],["path",{d:"m16 16 6-6"}],["path",{d:"m21.5 10.5-8-8"}],["path",{d:"m8 8 6-6"}],["path",{d:"m8.5 7.5 8 8"}]],zM=[["path",{d:"M10.5 3 8 9l4 13 4-13-2.5-6"}],["path",{d:"M17 3a2 2 0 0 1 1.6.8l3 4a2 2 0 0 1 .013 2.382l-7.99 10.986a2 2 0 0 1-3.247 0l-7.99-10.986A2 2 0 0 1 2.4 7.8l2.998-3.997A2 2 0 0 1 7 3z"}],["path",{d:"M2 9h20"}]],bM=[["path",{d:"M11.5 21a7.5 7.5 0 1 1 7.35-9"}],["path",{d:"M13 12V3"}],["path",{d:"M4 21h16"}],["path",{d:"M9 12V3"}]],RM=[["path",{d:"M9 10h.01"}],["path",{d:"M15 10h.01"}],["path",{d:"M12 2a8 8 0 0 0-8 8v12l3-3 2.5 2.5L12 19l2.5 2.5L17 19l3 3V10a8 8 0 0 0-8-8z"}]],TM=[["rect",{x:"3",y:"8",width:"18",height:"4",rx:"1"}],["path",{d:"M12 8v13"}],["path",{d:"M19 12v7a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2v-7"}],["path",{d:"M7.5 8a2.5 2.5 0 0 1 0-5A4.8 8 0 0 1 12 8a4.8 8 0 0 1 4.5-5 2.5 2.5 0 0 1 0 5"}]],qM=[["path",{d:"M6 3v12"}],["path",{d:"M18 9a3 3 0 1 0 0-6 3 3 0 0 0 0 6z"}],["path",{d:"M6 21a3 3 0 1 0 0-6 3 3 0 0 0 0 6z"}],["path",{d:"M15 6a9 9 0 0 0-9 9"}],["path",{d:"M18 15v6"}],["path",{d:"M21 18h-6"}]],UM=[["line",{x1:"6",x2:"6",y1:"3",y2:"15"}],["circle",{cx:"18",cy:"6",r:"3"}],["circle",{cx:"6",cy:"18",r:"3"}],["path",{d:"M18 9a9 9 0 0 1-9 9"}]],J1=[["circle",{cx:"12",cy:"12",r:"3"}],["line",{x1:"3",x2:"9",y1:"12",y2:"12"}],["line",{x1:"15",x2:"21",y1:"12",y2:"12"}]],OM=[["path",{d:"M12 3v6"}],["circle",{cx:"12",cy:"12",r:"3"}],["path",{d:"M12 15v6"}]],ZM=[["circle",{cx:"5",cy:"6",r:"3"}],["path",{d:"M12 6h5a2 2 0 0 1 2 2v7"}],["path",{d:"m15 9-3-3 3-3"}],["circle",{cx:"19",cy:"18",r:"3"}],["path",{d:"M12 18H7a2 2 0 0 1-2-2V9"}],["path",{d:"m9 15 3 3-3 3"}]],GM=[["circle",{cx:"18",cy:"18",r:"3"}],["circle",{cx:"6",cy:"6",r:"3"}],["path",{d:"M13 6h3a2 2 0 0 1 2 2v7"}],["path",{d:"M11 18H8a2 2 0 0 1-2-2V9"}]],IM=[["circle",{cx:"12",cy:"18",r:"3"}],["circle",{cx:"6",cy:"6",r:"3"}],["circle",{cx:"18",cy:"6",r:"3"}],["path",{d:"M18 9v2c0 .6-.4 1-1 1H7c-.6 0-1-.4-1-1V9"}],["path",{d:"M12 12v3"}]],WM=[["circle",{cx:"5",cy:"6",r:"3"}],["path",{d:"M5 9v6"}],["circle",{cx:"5",cy:"18",r:"3"}],["path",{d:"M12 3v18"}],["circle",{cx:"19",cy:"6",r:"3"}],["path",{d:"M16 15.7A9 9 0 0 0 19 9"}]],EM=[["circle",{cx:"18",cy:"18",r:"3"}],["circle",{cx:"6",cy:"6",r:"3"}],["path",{d:"M6 21V9a9 9 0 0 0 9 9"}]],XM=[["circle",{cx:"5",cy:"6",r:"3"}],["path",{d:"M5 9v12"}],["circle",{cx:"19",cy:"18",r:"3"}],["path",{d:"m15 9-3-3 3-3"}],["path",{d:"M12 6h5a2 2 0 0 1 2 2v7"}]],jM=[["circle",{cx:"6",cy:"6",r:"3"}],["path",{d:"M6 9v12"}],["path",{d:"m21 3-6 6"}],["path",{d:"m21 9-6-6"}],["path",{d:"M18 11.5V15"}],["circle",{cx:"18",cy:"18",r:"3"}]],NM=[["circle",{cx:"5",cy:"6",r:"3"}],["path",{d:"M5 9v12"}],["path",{d:"m15 9-3-3 3-3"}],["path",{d:"M12 6h5a2 2 0 0 1 2 2v3"}],["path",{d:"M19 15v6"}],["path",{d:"M22 18h-6"}]],KM=[["circle",{cx:"6",cy:"6",r:"3"}],["path",{d:"M6 9v12"}],["path",{d:"M13 6h3a2 2 0 0 1 2 2v3"}],["path",{d:"M18 15v6"}],["path",{d:"M21 18h-6"}]],QM=[["circle",{cx:"18",cy:"18",r:"3"}],["circle",{cx:"6",cy:"6",r:"3"}],["path",{d:"M18 6V5"}],["path",{d:"M18 11v-1"}],["line",{x1:"6",x2:"6",y1:"9",y2:"21"}]],JM=[["circle",{cx:"18",cy:"18",r:"3"}],["circle",{cx:"6",cy:"6",r:"3"}],["path",{d:"M13 6h3a2 2 0 0 1 2 2v7"}],["line",{x1:"6",x2:"6",y1:"9",y2:"21"}]],YM=[["path",{d:"M15 22v-4a4.8 4.8 0 0 0-1-3.5c3 0 6-2 6-5.5.08-1.25-.27-2.48-1-3.5.28-1.15.28-2.35 0-3.5 0 0-1 0-3 1.5-2.64-.5-5.36-.5-8 0C6 2 5 2 5 2c-.3 1.15-.3 2.35 0 3.5A5.403 5.403 0 0 0 4 9c0 3.5 3 5.5 6 5.5-.39.49-.68 1.05-.85 1.65-.17.6-.22 1.23-.15 1.85v4"}],["path",{d:"M9 18c-4.51 2-5-2-7-2"}]],_M=[["path",{d:"m22 13.29-3.33-10a.42.42 0 0 0-.14-.18.38.38 0 0 0-.22-.11.39.39 0 0 0-.23.07.42.42 0 0 0-.14.18l-2.26 6.67H8.32L6.1 3.26a.42.42 0 0 0-.1-.18.38.38 0 0 0-.26-.08.39.39 0 0 0-.23.07.42.42 0 0 0-.14.18L2 13.29a.74.74 0 0 0 .27.83L12 21l9.69-6.88a.71.71 0 0 0 .31-.83Z"}]],xM=[["path",{d:"M5.116 4.104A1 1 0 0 1 6.11 3h11.78a1 1 0 0 1 .994 1.105L17.19 20.21A2 2 0 0 1 15.2 22H8.8a2 2 0 0 1-2-1.79z"}],["path",{d:"M6 12a5 5 0 0 1 6 0 5 5 0 0 0 6 0"}]],a9=[["circle",{cx:"6",cy:"15",r:"4"}],["circle",{cx:"18",cy:"15",r:"4"}],["path",{d:"M14 15a2 2 0 0 0-2-2 2 2 0 0 0-2 2"}],["path",{d:"M2.5 13 5 7c.7-1.3 1.4-2 3-2"}],["path",{d:"M21.5 13 19 7c-.7-1.3-1.5-2-3-2"}]],t9=[["path",{d:"M15.686 15A14.5 14.5 0 0 1 12 22a14.5 14.5 0 0 1 0-20 10 10 0 1 0 9.542 13"}],["path",{d:"M2 12h8.5"}],["path",{d:"M20 6V4a2 2 0 1 0-4 0v2"}],["rect",{width:"8",height:"5",x:"14",y:"6",rx:"1"}]],h9=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"}],["path",{d:"M2 12h20"}]],d9=[["path",{d:"M12 13V2l8 4-8 4"}],["path",{d:"M20.561 10.222a9 9 0 1 1-12.55-5.29"}],["path",{d:"M8.002 9.997a5 5 0 1 0 8.9 2.02"}]],c9=[["path",{d:"M21.42 10.922a1 1 0 0 0-.019-1.838L12.83 5.18a2 2 0 0 0-1.66 0L2.6 9.08a1 1 0 0 0 0 1.832l8.57 3.908a2 2 0 0 0 1.66 0z"}],["path",{d:"M22 10v6"}],["path",{d:"M6 12.5V16a6 3 0 0 0 12 0v-3.5"}]],M9=[["path",{d:"M2 21V3"}],["path",{d:"M2 5h18a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H2.26"}],["path",{d:"M7 17v3a1 1 0 0 0 1 1h5a1 1 0 0 0 1-1v-3"}],["circle",{cx:"16",cy:"11",r:"2"}],["circle",{cx:"8",cy:"11",r:"2"}]],p9=[["path",{d:"M22 5V2l-5.89 5.89"}],["circle",{cx:"16.6",cy:"15.89",r:"3"}],["circle",{cx:"8.11",cy:"7.4",r:"3"}],["circle",{cx:"12.35",cy:"11.65",r:"3"}],["circle",{cx:"13.91",cy:"5.85",r:"3"}],["circle",{cx:"18.15",cy:"10.09",r:"3"}],["circle",{cx:"6.56",cy:"13.2",r:"3"}],["circle",{cx:"10.8",cy:"17.44",r:"3"}],["circle",{cx:"5",cy:"19",r:"3"}]],Y1=[["path",{d:"M12 3v17a1 1 0 0 1-1 1H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v6a1 1 0 0 1-1 1H3"}],["path",{d:"m16 19 2 2 4-4"}]],_1=[["path",{d:"M12 3v17a1 1 0 0 1-1 1H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v6a1 1 0 0 1-1 1H3"}],["path",{d:"M16 19h6"}],["path",{d:"M19 22v-6"}]],x1=[["path",{d:"M12 3v17a1 1 0 0 1-1 1H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v6a1 1 0 0 1-1 1H3"}],["path",{d:"m16 16 5 5"}],["path",{d:"m16 21 5-5"}]],a2=[["path",{d:"M12 3v18"}],["path",{d:"M3 12h18"}],["rect",{x:"3",y:"3",width:"18",height:"18",rx:"2"}]],i9=[["path",{d:"M15 3v18"}],["path",{d:"M3 12h18"}],["path",{d:"M9 3v18"}],["rect",{x:"3",y:"3",width:"18",height:"18",rx:"2"}]],r=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M3 9h18"}],["path",{d:"M3 15h18"}],["path",{d:"M9 3v18"}],["path",{d:"M15 3v18"}]],n9=[["circle",{cx:"12",cy:"9",r:"1"}],["circle",{cx:"19",cy:"9",r:"1"}],["circle",{cx:"5",cy:"9",r:"1"}],["circle",{cx:"12",cy:"15",r:"1"}],["circle",{cx:"19",cy:"15",r:"1"}],["circle",{cx:"5",cy:"15",r:"1"}]],l9=[["circle",{cx:"9",cy:"12",r:"1"}],["circle",{cx:"9",cy:"5",r:"1"}],["circle",{cx:"9",cy:"19",r:"1"}],["circle",{cx:"15",cy:"12",r:"1"}],["circle",{cx:"15",cy:"5",r:"1"}],["circle",{cx:"15",cy:"19",r:"1"}]],e9=[["circle",{cx:"12",cy:"5",r:"1"}],["circle",{cx:"19",cy:"5",r:"1"}],["circle",{cx:"5",cy:"5",r:"1"}],["circle",{cx:"12",cy:"12",r:"1"}],["circle",{cx:"19",cy:"12",r:"1"}],["circle",{cx:"5",cy:"12",r:"1"}],["circle",{cx:"12",cy:"19",r:"1"}],["circle",{cx:"19",cy:"19",r:"1"}],["circle",{cx:"5",cy:"19",r:"1"}]],r9=[["path",{d:"M3 7V5c0-1.1.9-2 2-2h2"}],["path",{d:"M17 3h2c1.1 0 2 .9 2 2v2"}],["path",{d:"M21 17v2c0 1.1-.9 2-2 2h-2"}],["path",{d:"M7 21H5c-1.1 0-2-.9-2-2v-2"}],["rect",{width:"7",height:"5",x:"7",y:"7",rx:"1"}],["rect",{width:"7",height:"5",x:"10",y:"12",rx:"1"}]],o9=[["path",{d:"m11.9 12.1 4.514-4.514"}],["path",{d:"M20.1 2.3a1 1 0 0 0-1.4 0l-1.114 1.114A2 2 0 0 0 17 4.828v1.344a2 2 0 0 1-.586 1.414A2 2 0 0 1 17.828 7h1.344a2 2 0 0 0 1.414-.586L21.7 5.3a1 1 0 0 0 0-1.4z"}],["path",{d:"m6 16 2 2"}],["path",{d:"M8.23 9.85A3 3 0 0 1 11 8a5 5 0 0 1 5 5 3 3 0 0 1-1.85 2.77l-.92.38A2 2 0 0 0 12 18a4 4 0 0 1-4 4 6 6 0 0 1-6-6 4 4 0 0 1 4-4 2 2 0 0 0 1.85-1.23z"}]],v9=[["path",{d:"M13.144 21.144A7.274 10.445 45 1 0 2.856 10.856"}],["path",{d:"M13.144 21.144A7.274 4.365 45 0 0 2.856 10.856a7.274 4.365 45 0 0 10.288 10.288"}],["path",{d:"M16.565 10.435 18.6 8.4a2.501 2.501 0 1 0 1.65-4.65 2.5 2.5 0 1 0-4.66 1.66l-2.024 2.025"}],["path",{d:"m8.5 16.5-1-1"}]],$9=[["path",{d:"M12 16H4a2 2 0 1 1 0-4h16a2 2 0 1 1 0 4h-4.25"}],["path",{d:"M5 12a2 2 0 0 1-2-2 9 7 0 0 1 18 0 2 2 0 0 1-2 2"}],["path",{d:"M5 16a2 2 0 0 0-2 2 3 3 0 0 0 3 3h12a3 3 0 0 0 3-3 2 2 0 0 0-2-2q0 0 0 0"}],["path",{d:"m6.67 12 6.13 4.6a2 2 0 0 0 2.8-.4l3.15-4.2"}]],m9=[["path",{d:"m15 12-9.373 9.373a1 1 0 0 1-3.001-3L12 9"}],["path",{d:"m18 15 4-4"}],["path",{d:"m21.5 11.5-1.914-1.914A2 2 0 0 1 19 8.172v-.344a2 2 0 0 0-.586-1.414l-1.657-1.657A6 6 0 0 0 12.516 3H9l1.243 1.243A6 6 0 0 1 12 8.485V10l2 2h1.172a2 2 0 0 1 1.414.586L18.5 14.5"}]],y9=[["path",{d:"M11 15h2a2 2 0 1 0 0-4h-3c-.6 0-1.1.2-1.4.6L3 17"}],["path",{d:"m7 21 1.6-1.4c.3-.4.8-.6 1.4-.6h4c1.1 0 2.1-.4 2.8-1.2l4.6-4.4a2 2 0 0 0-2.75-2.91l-4.2 3.9"}],["path",{d:"m2 16 6 6"}],["circle",{cx:"16",cy:"9",r:"2.9"}],["circle",{cx:"6",cy:"5",r:"3"}]],s9=[["path",{d:"M12.035 17.012a3 3 0 0 0-3-3l-.311-.002a.72.72 0 0 1-.505-1.229l1.195-1.195A2 2 0 0 1 10.828 11H12a2 2 0 0 0 0-4H9.243a3 3 0 0 0-2.122.879l-2.707 2.707A4.83 4.83 0 0 0 3 14a8 8 0 0 0 8 8h2a8 8 0 0 0 8-8V7a2 2 0 1 0-4 0v2a2 2 0 1 0 4 0"}],["path",{d:"M13.888 9.662A2 2 0 0 0 17 8V5A2 2 0 1 0 13 5"}],["path",{d:"M9 5A2 2 0 1 0 5 5V10"}],["path",{d:"M9 7V4A2 2 0 1 1 13 4V7.268"}]],g9=[["path",{d:"M11 14h2a2 2 0 0 0 0-4h-3c-.6 0-1.1.2-1.4.6L3 16"}],["path",{d:"m14.45 13.39 5.05-4.694C20.196 8 21 6.85 21 5.75a2.75 2.75 0 0 0-4.797-1.837.276.276 0 0 1-.406 0A2.75 2.75 0 0 0 11 5.75c0 1.2.802 2.248 1.5 2.946L16 11.95"}],["path",{d:"m2 15 6 6"}],["path",{d:"m7 20 1.6-1.4c.3-.4.8-.6 1.4-.6h4c1.1 0 2.1-.4 2.8-1.2l4.6-4.4a1 1 0 0 0-2.75-2.91"}]],t2=[["path",{d:"M18 11.5V9a2 2 0 0 0-2-2a2 2 0 0 0-2 2v1.4"}],["path",{d:"M14 10V8a2 2 0 0 0-2-2a2 2 0 0 0-2 2v2"}],["path",{d:"M10 9.9V9a2 2 0 0 0-2-2a2 2 0 0 0-2 2v5"}],["path",{d:"M6 14a2 2 0 0 0-2-2a2 2 0 0 0-2 2"}],["path",{d:"M18 11a2 2 0 1 1 4 0v3a8 8 0 0 1-8 8h-4a8 8 0 0 1-8-8 2 2 0 1 1 4 0"}]],h2=[["path",{d:"M11 12h2a2 2 0 1 0 0-4h-3c-.6 0-1.1.2-1.4.6L3 14"}],["path",{d:"m7 18 1.6-1.4c.3-.4.8-.6 1.4-.6h4c1.1 0 2.1-.4 2.8-1.2l4.6-4.4a2 2 0 0 0-2.75-2.91l-4.2 3.9"}],["path",{d:"m2 13 6 6"}]],u9=[["path",{d:"M18 12.5V10a2 2 0 0 0-2-2a2 2 0 0 0-2 2v1.4"}],["path",{d:"M14 11V9a2 2 0 1 0-4 0v2"}],["path",{d:"M10 10.5V5a2 2 0 1 0-4 0v9"}],["path",{d:"m7 15-1.76-1.76a2 2 0 0 0-2.83 2.82l3.6 3.6C7.5 21.14 9.2 22 12 22h2a8 8 0 0 0 8-8V7a2 2 0 1 0-4 0v5"}]],C9=[["path",{d:"M12 3V2"}],["path",{d:"m15.4 17.4 3.2-2.8a2 2 0 1 1 2.8 2.9l-3.6 3.3c-.7.8-1.7 1.2-2.8 1.2h-4c-1.1 0-2.1-.4-2.8-1.2l-1.302-1.464A1 1 0 0 0 6.151 19H5"}],["path",{d:"M2 14h12a2 2 0 0 1 0 4h-2"}],["path",{d:"M4 10h16"}],["path",{d:"M5 10a7 7 0 0 1 14 0"}],["path",{d:"M5 14v6a1 1 0 0 1-1 1H2"}]],H9=[["path",{d:"M18 11V6a2 2 0 0 0-2-2a2 2 0 0 0-2 2"}],["path",{d:"M14 10V4a2 2 0 0 0-2-2a2 2 0 0 0-2 2v2"}],["path",{d:"M10 10.5V6a2 2 0 0 0-2-2a2 2 0 0 0-2 2v8"}],["path",{d:"M18 8a2 2 0 1 1 4 0v6a8 8 0 0 1-8 8h-2c-2.8 0-4.5-.86-5.99-2.34l-3.6-3.6a2 2 0 0 1 2.83-2.82L7 15"}]],A9=[["path",{d:"m11 17 2 2a1 1 0 1 0 3-3"}],["path",{d:"m14 14 2.5 2.5a1 1 0 1 0 3-3l-3.88-3.88a3 3 0 0 0-4.24 0l-.88.88a1 1 0 1 1-3-3l2.81-2.81a5.79 5.79 0 0 1 7.06-.87l.47.28a2 2 0 0 0 1.42.25L21 4"}],["path",{d:"m21 3 1 11h-2"}],["path",{d:"M3 3 2 14l6.5 6.5a1 1 0 1 0 3-3"}],["path",{d:"M3 4h8"}]],w9=[["path",{d:"M2.048 18.566A2 2 0 0 0 4 21h16a2 2 0 0 0 1.952-2.434l-2-9A2 2 0 0 0 18 8H6a2 2 0 0 0-1.952 1.566z"}],["path",{d:"M8 11V6a4 4 0 0 1 8 0v5"}]],V9=[["path",{d:"M12 2v8"}],["path",{d:"m16 6-4 4-4-4"}],["rect",{width:"20",height:"8",x:"2",y:"14",rx:"2"}],["path",{d:"M6 18h.01"}],["path",{d:"M10 18h.01"}]],S9=[["path",{d:"m16 6-4-4-4 4"}],["path",{d:"M12 2v8"}],["rect",{width:"20",height:"8",x:"2",y:"14",rx:"2"}],["path",{d:"M6 18h.01"}],["path",{d:"M10 18h.01"}]],L9=[["line",{x1:"22",x2:"2",y1:"12",y2:"12"}],["path",{d:"M5.45 5.11 2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z"}],["line",{x1:"6",x2:"6.01",y1:"16",y2:"16"}],["line",{x1:"10",x2:"10.01",y1:"16",y2:"16"}]],f9=[["path",{d:"M10 10V5a1 1 0 0 1 1-1h2a1 1 0 0 1 1 1v5"}],["path",{d:"M14 6a6 6 0 0 1 6 6v3"}],["path",{d:"M4 15v-3a6 6 0 0 1 6-6"}],["rect",{x:"2",y:"15",width:"20",height:"4",rx:"1"}]],k9=[["line",{x1:"4",x2:"20",y1:"9",y2:"9"}],["line",{x1:"4",x2:"20",y1:"15",y2:"15"}],["line",{x1:"10",x2:"8",y1:"3",y2:"21"}],["line",{x1:"16",x2:"14",y1:"3",y2:"21"}]],P9=[["path",{d:"M14 18a2 2 0 0 0-4 0"}],["path",{d:"m19 11-2.11-6.657a2 2 0 0 0-2.752-1.148l-1.276.61A2 2 0 0 1 12 4H8.5a2 2 0 0 0-1.925 1.456L5 11"}],["path",{d:"M2 11h20"}],["circle",{cx:"17",cy:"18",r:"3"}],["circle",{cx:"7",cy:"18",r:"3"}]],B9=[["path",{d:"m5.2 6.2 1.4 1.4"}],["path",{d:"M2 13h2"}],["path",{d:"M20 13h2"}],["path",{d:"m17.4 7.6 1.4-1.4"}],["path",{d:"M22 17H2"}],["path",{d:"M22 21H2"}],["path",{d:"M16 13a4 4 0 0 0-8 0"}],["path",{d:"M12 5V2.5"}]],D9=[["path",{d:"M22 9a1 1 0 0 0-1-1H3a1 1 0 0 0-1 1v4a1 1 0 0 0 1 1h1l2 2h12l2-2h1a1 1 0 0 0 1-1Z"}],["path",{d:"M7.5 12h9"}]],F9=[["path",{d:"M4 12h8"}],["path",{d:"M4 18V6"}],["path",{d:"M12 18V6"}],["path",{d:"m17 12 3-2v8"}]],z9=[["path",{d:"M4 12h8"}],["path",{d:"M4 18V6"}],["path",{d:"M12 18V6"}],["path",{d:"M21 18h-4c0-4 4-3 4-6 0-1.5-2-2.5-4-1"}]],b9=[["path",{d:"M4 12h8"}],["path",{d:"M4 18V6"}],["path",{d:"M12 18V6"}],["path",{d:"M17.5 10.5c1.7-1 3.5 0 3.5 1.5a2 2 0 0 1-2 2"}],["path",{d:"M17 17.5c2 1.5 4 .3 4-1.5a2 2 0 0 0-2-2"}]],R9=[["path",{d:"M12 18V6"}],["path",{d:"M17 10v3a1 1 0 0 0 1 1h3"}],["path",{d:"M21 10v8"}],["path",{d:"M4 12h8"}],["path",{d:"M4 18V6"}]],T9=[["path",{d:"M4 12h8"}],["path",{d:"M4 18V6"}],["path",{d:"M12 18V6"}],["path",{d:"M17 13v-3h4"}],["path",{d:"M17 17.7c.4.2.8.3 1.3.3 1.5 0 2.7-1.1 2.7-2.5S19.8 13 18.3 13H17"}]],q9=[["path",{d:"M4 12h8"}],["path",{d:"M4 18V6"}],["path",{d:"M12 18V6"}],["circle",{cx:"19",cy:"16",r:"2"}],["path",{d:"M20 10c-2 2-3 3.5-3 6"}]],U9=[["path",{d:"M6 12h12"}],["path",{d:"M6 20V4"}],["path",{d:"M18 20V4"}]],O9=[["path",{d:"M21 14h-1.343"}],["path",{d:"M9.128 3.47A9 9 0 0 1 21 12v3.343"}],["path",{d:"m2 2 20 20"}],["path",{d:"M20.414 20.414A2 2 0 0 1 19 21h-1a2 2 0 0 1-2-2v-3"}],["path",{d:"M3 14h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-7a9 9 0 0 1 2.636-6.364"}]],Z9=[["path",{d:"M3 14h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-7a9 9 0 0 1 18 0v7a2 2 0 0 1-2 2h-1a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h3"}]],G9=[["path",{d:"M3 11h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-5Zm0 0a9 9 0 1 1 18 0m0 0v5a2 2 0 0 1-2 2h-1a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h3Z"}],["path",{d:"M21 16v2a4 4 0 0 1-4 4h-5"}]],I9=[["path",{d:"M12.409 5.824c-.702.792-1.15 1.496-1.415 2.166l2.153 2.156a.5.5 0 0 1 0 .707l-2.293 2.293a.5.5 0 0 0 0 .707L12 15"}],["path",{d:"M13.508 20.313a2 2 0 0 1-3 .019L5 15c-1.5-1.5-3-3.2-3-5.5a5.5 5.5 0 0 1 9.591-3.677.6.6 0 0 0 .818.001A5.5 5.5 0 0 1 22 9.5c0 2.29-1.5 4-3 5.5z"}]],W9=[["path",{d:"M19.414 14.414C21 12.828 22 11.5 22 9.5a5.5 5.5 0 0 0-9.591-3.676.6.6 0 0 1-.818.001A5.5 5.5 0 0 0 2 9.5c0 2.3 1.5 4 3 5.5l5.535 5.362a2 2 0 0 0 2.879.052 2.12 2.12 0 0 0-.004-3 2.124 2.124 0 1 0 3-3 2.124 2.124 0 0 0 3.004 0 2 2 0 0 0 0-2.828l-1.881-1.882a2.41 2.41 0 0 0-3.409 0l-1.71 1.71a2 2 0 0 1-2.828 0 2 2 0 0 1 0-2.828l2.823-2.762"}]],E9=[["path",{d:"m14.876 18.99-1.368 1.323a2 2 0 0 1-3 .019L5 15c-1.5-1.5-3-3.2-3-5.5a5.5 5.5 0 0 1 9.591-3.676.56.56 0 0 0 .818 0A5.49 5.49 0 0 1 22 9.5a5.2 5.2 0 0 1-.244 1.572"}],["path",{d:"M15 15h6"}]],X9=[["path",{d:"M10.5 4.893a5.5 5.5 0 0 1 1.091.931.56.56 0 0 0 .818 0A5.49 5.49 0 0 1 22 9.5c0 1.872-1.002 3.356-2.187 4.655"}],["path",{d:"m16.967 16.967-3.459 3.346a2 2 0 0 1-3 .019L5 15c-1.5-1.5-3-3.2-3-5.5a5.5 5.5 0 0 1 2.747-4.761"}],["path",{d:"m2 2 20 20"}]],j9=[["path",{d:"m14.479 19.374-.971.939a2 2 0 0 1-3 .019L5 15c-1.5-1.5-3-3.2-3-5.5a5.5 5.5 0 0 1 9.591-3.676.56.56 0 0 0 .818 0A5.49 5.49 0 0 1 22 9.5a5.2 5.2 0 0 1-.219 1.49"}],["path",{d:"M15 15h6"}],["path",{d:"M18 12v6"}]],N9=[["path",{d:"M2 9.5a5.5 5.5 0 0 1 9.591-3.676.56.56 0 0 0 .818 0A5.49 5.49 0 0 1 22 9.5c0 2.29-1.5 4-3 5.5l-5.492 5.313a2 2 0 0 1-3 .019L5 15c-1.5-1.5-3-3.2-3-5.5"}],["path",{d:"M3.22 13H9.5l.5-1 2 4.5 2-7 1.5 3.5h5.27"}]],K9=[["path",{d:"M2 9.5a5.5 5.5 0 0 1 9.591-3.676.56.56 0 0 0 .818 0A5.49 5.49 0 0 1 22 9.5c0 2.29-1.5 4-3 5.5l-5.492 5.313a2 2 0 0 1-3 .019L5 15c-1.5-1.5-3-3.2-3-5.5"}]],Q9=[["path",{d:"M11 8c2-3-2-3 0-6"}],["path",{d:"M15.5 8c2-3-2-3 0-6"}],["path",{d:"M6 10h.01"}],["path",{d:"M6 14h.01"}],["path",{d:"M10 16v-4"}],["path",{d:"M14 16v-4"}],["path",{d:"M18 16v-4"}],["path",{d:"M20 6a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h3"}],["path",{d:"M5 20v2"}],["path",{d:"M19 20v2"}]],J9=[["path",{d:"M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z"}]],Y9=[["path",{d:"m9 11-6 6v3h9l3-3"}],["path",{d:"m22 12-4.6 4.6a2 2 0 0 1-2.8 0l-5.2-5.2a2 2 0 0 1 0-2.8L14 4"}]],_9=[["path",{d:"M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"}],["path",{d:"M3 3v5h5"}],["path",{d:"M12 7v5l4 2"}]],x9=[["path",{d:"M10.82 16.12c1.69.6 3.91.79 5.18.85.28.01.53-.09.7-.27"}],["path",{d:"M11.14 20.57c.52.24 2.44 1.12 4.08 1.37.46.06.86-.25.9-.71.12-1.52-.3-3.43-.5-4.28"}],["path",{d:"M16.13 21.05c1.65.63 3.68.84 4.87.91a.9.9 0 0 0 .7-.26"}],["path",{d:"M17.99 5.52a20.83 20.83 0 0 1 3.15 4.5.8.8 0 0 1-.68 1.13c-1.17.1-2.5.02-3.9-.25"}],["path",{d:"M20.57 11.14c.24.52 1.12 2.44 1.37 4.08.04.3-.08.59-.31.75"}],["path",{d:"M4.93 4.93a10 10 0 0 0-.67 13.4c.35.43.96.4 1.17-.12.69-1.71 1.07-5.07 1.07-6.71 1.34.45 3.1.9 4.88.62a.85.85 0 0 0 .48-.24"}],["path",{d:"M5.52 17.99c1.05.95 2.91 2.42 4.5 3.15a.8.8 0 0 0 1.13-.68c.2-2.34-.33-5.3-1.57-8.28"}],["path",{d:"M8.35 2.68a10 10 0 0 1 9.98 1.58c.43.35.4.96-.12 1.17-1.5.6-4.3.98-6.07 1.05"}],["path",{d:"m2 2 20 20"}]],ap=[["path",{d:"M10.82 16.12c1.69.6 3.91.79 5.18.85.55.03 1-.42.97-.97-.06-1.27-.26-3.5-.85-5.18"}],["path",{d:"M11.5 6.5c1.64 0 5-.38 6.71-1.07.52-.2.55-.82.12-1.17A10 10 0 0 0 4.26 18.33c.35.43.96.4 1.17-.12.69-1.71 1.07-5.07 1.07-6.71 1.34.45 3.1.9 4.88.62a.88.88 0 0 0 .73-.74c.3-2.14-.15-3.5-.61-4.88"}],["path",{d:"M15.62 16.95c.2.85.62 2.76.5 4.28a.77.77 0 0 1-.9.7 16.64 16.64 0 0 1-4.08-1.36"}],["path",{d:"M16.13 21.05c1.65.63 3.68.84 4.87.91a.9.9 0 0 0 .96-.96 17.68 17.68 0 0 0-.9-4.87"}],["path",{d:"M16.94 15.62c.86.2 2.77.62 4.29.5a.77.77 0 0 0 .7-.9 16.64 16.64 0 0 0-1.36-4.08"}],["path",{d:"M17.99 5.52a20.82 20.82 0 0 1 3.15 4.5.8.8 0 0 1-.68 1.13c-2.33.2-5.3-.32-8.27-1.57"}],["path",{d:"M4.93 4.93 3 3a.7.7 0 0 1 0-1"}],["path",{d:"M9.58 12.18c1.24 2.98 1.77 5.95 1.57 8.28a.8.8 0 0 1-1.13.68 20.82 20.82 0 0 1-4.5-3.15"}]],tp=[["path",{d:"M12 7v4"}],["path",{d:"M14 21v-3a2 2 0 0 0-4 0v3"}],["path",{d:"M14 9h-4"}],["path",{d:"M18 11h2a2 2 0 0 1 2 2v6a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-9a2 2 0 0 1 2-2h2"}],["path",{d:"M18 21V5a2 2 0 0 0-2-2H8a2 2 0 0 0-2 2v16"}]],hp=[["path",{d:"M10 22v-6.57"}],["path",{d:"M12 11h.01"}],["path",{d:"M12 7h.01"}],["path",{d:"M14 15.43V22"}],["path",{d:"M15 16a5 5 0 0 0-6 0"}],["path",{d:"M16 11h.01"}],["path",{d:"M16 7h.01"}],["path",{d:"M8 11h.01"}],["path",{d:"M8 7h.01"}],["rect",{x:"4",y:"2",width:"16",height:"20",rx:"2"}]],dp=[["path",{d:"M5 22h14"}],["path",{d:"M5 2h14"}],["path",{d:"M17 22v-4.172a2 2 0 0 0-.586-1.414L12 12l-4.414 4.414A2 2 0 0 0 7 17.828V22"}],["path",{d:"M7 2v4.172a2 2 0 0 0 .586 1.414L12 12l4.414-4.414A2 2 0 0 0 17 6.172V2"}]],cp=[["path",{d:"M8.62 13.8A2.25 2.25 0 1 1 12 10.836a2.25 2.25 0 1 1 3.38 2.966l-2.626 2.856a.998.998 0 0 1-1.507 0z"}],["path",{d:"M3 10a2 2 0 0 1 .709-1.528l7-6a2 2 0 0 1 2.582 0l7 6A2 2 0 0 1 21 10v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"}]],Mp=[["path",{d:"M10 12V8.964"}],["path",{d:"M14 12V8.964"}],["path",{d:"M15 12a1 1 0 0 1 1 1v2a2 2 0 0 1-2 2h-4a2 2 0 0 1-2-2v-2a1 1 0 0 1 1-1z"}],["path",{d:"M8.5 21H5a2 2 0 0 1-2-2v-9a2 2 0 0 1 .709-1.528l7-6a2 2 0 0 1 2.582 0l7 6A2 2 0 0 1 21 10v9a2 2 0 0 1-2 2h-5a2 2 0 0 1-2-2v-2"}]],pp=[["path",{d:"M12.35 21H5a2 2 0 0 1-2-2v-9a2 2 0 0 1 .71-1.53l7-6a2 2 0 0 1 2.58 0l7 6A2 2 0 0 1 21 10v2.35"}],["path",{d:"M14.8 12.4A1 1 0 0 0 14 12h-4a1 1 0 0 0-1 1v8"}],["path",{d:"M15 18h6"}],["path",{d:"M18 15v6"}]],d2=[["path",{d:"M15 21v-8a1 1 0 0 0-1-1h-4a1 1 0 0 0-1 1v8"}],["path",{d:"M3 10a2 2 0 0 1 .709-1.528l7-6a2 2 0 0 1 2.582 0l7 6A2 2 0 0 1 21 10v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"}]],ip=[["path",{d:"M9.5 13.866a4 4 0 0 1 5 .01"}],["path",{d:"M12 17h.01"}],["path",{d:"M3 10a2 2 0 0 1 .709-1.528l7-6a2 2 0 0 1 2.582 0l7 6A2 2 0 0 1 21 10v9a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"}],["path",{d:"M7 10.754a8 8 0 0 1 10 0"}]],c2=[["path",{d:"M12 17c5 0 8-2.69 8-6H4c0 3.31 3 6 8 6m-4 4h8m-4-3v3M5.14 11a3.5 3.5 0 1 1 6.71 0"}],["path",{d:"M12.14 11a3.5 3.5 0 1 1 6.71 0"}],["path",{d:"M15.5 6.5a3.5 3.5 0 1 0-7 0"}]],M2=[["path",{d:"m7 11 4.08 10.35a1 1 0 0 0 1.84 0L17 11"}],["path",{d:"M17 7A5 5 0 0 0 7 7"}],["path",{d:"M17 7a2 2 0 0 1 0 4H7a2 2 0 0 1 0-4"}]],np=[["path",{d:"M13.5 8h-3"}],["path",{d:"m15 2-1 2h3a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h3"}],["path",{d:"M16.899 22A5 5 0 0 0 7.1 22"}],["path",{d:"m9 2 3 6"}],["circle",{cx:"12",cy:"15",r:"3"}]],lp=[["path",{d:"M16 10h2"}],["path",{d:"M16 14h2"}],["path",{d:"M6.17 15a3 3 0 0 1 5.66 0"}],["circle",{cx:"9",cy:"11",r:"2"}],["rect",{x:"2",y:"5",width:"20",height:"14",rx:"2"}]],ep=[["path",{d:"M10.3 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v10l-3.1-3.1a2 2 0 0 0-2.814.014L6 21"}],["path",{d:"m14 19 3 3v-5.5"}],["path",{d:"m17 22 3-3"}],["circle",{cx:"9",cy:"9",r:"2"}]],rp=[["line",{x1:"2",x2:"22",y1:"2",y2:"22"}],["path",{d:"M10.41 10.41a2 2 0 1 1-2.83-2.83"}],["line",{x1:"13.5",x2:"6",y1:"13.5",y2:"21"}],["line",{x1:"18",x2:"21",y1:"12",y2:"15"}],["path",{d:"M3.59 3.59A1.99 1.99 0 0 0 3 5v14a2 2 0 0 0 2 2h14c.55 0 1.052-.22 1.41-.59"}],["path",{d:"M21 15V5a2 2 0 0 0-2-2H9"}]],op=[["path",{d:"M21 9v10a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h7"}],["line",{x1:"16",x2:"22",y1:"5",y2:"5"}],["circle",{cx:"9",cy:"9",r:"2"}],["path",{d:"m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21"}]],vp=[["path",{d:"M15 15.003a1 1 0 0 1 1.517-.859l4.997 2.997a1 1 0 0 1 0 1.718l-4.997 2.997a1 1 0 0 1-1.517-.86z"}],["path",{d:"M21 12.17V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h6"}],["path",{d:"m6 21 5-5"}],["circle",{cx:"9",cy:"9",r:"2"}]],$p=[["path",{d:"M16 5h6"}],["path",{d:"M19 2v6"}],["path",{d:"M21 11.5V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h7.5"}],["path",{d:"m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21"}],["circle",{cx:"9",cy:"9",r:"2"}]],mp=[["path",{d:"M10.3 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v10l-3.1-3.1a2 2 0 0 0-2.814.014L6 21"}],["path",{d:"m14 19.5 3-3 3 3"}],["path",{d:"M17 22v-5.5"}],["circle",{cx:"9",cy:"9",r:"2"}]],yp=[["path",{d:"M16 3h5v5"}],["path",{d:"M17 21h2a2 2 0 0 0 2-2"}],["path",{d:"M21 12v3"}],["path",{d:"m21 3-5 5"}],["path",{d:"M3 7V5a2 2 0 0 1 2-2"}],["path",{d:"m5 21 4.144-4.144a1.21 1.21 0 0 1 1.712 0L13 19"}],["path",{d:"M9 3h3"}],["rect",{x:"3",y:"11",width:"10",height:"10",rx:"1"}]],sp=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2",ry:"2"}],["circle",{cx:"9",cy:"9",r:"2"}],["path",{d:"m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21"}]],gp=[["path",{d:"m22 11-1.296-1.296a2.4 2.4 0 0 0-3.408 0L11 16"}],["path",{d:"M4 8a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2"}],["circle",{cx:"13",cy:"7",r:"1",fill:"currentColor"}],["rect",{x:"8",y:"2",width:"14",height:"14",rx:"2"}]],up=[["path",{d:"M12 3v12"}],["path",{d:"m8 11 4 4 4-4"}],["path",{d:"M8 5H4a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2h-4"}]],Cp=[["polyline",{points:"22 12 16 12 14 15 10 15 8 12 2 12"}],["path",{d:"M5.45 5.11 2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z"}]],Hp=[["path",{d:"M6 3h12"}],["path",{d:"M6 8h12"}],["path",{d:"m6 13 8.5 8"}],["path",{d:"M6 13h3"}],["path",{d:"M9 13c6.667 0 6.667-10 0-10"}]],Ap=[["path",{d:"M6 16c5 0 7-8 12-8a4 4 0 0 1 0 8c-5 0-7-8-12-8a4 4 0 1 0 0 8"}]],wp=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M12 16v-4"}],["path",{d:"M12 8h.01"}]],Vp=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M7 7h.01"}],["path",{d:"M17 7h.01"}],["path",{d:"M7 17h.01"}],["path",{d:"M17 17h.01"}]],Sp=[["rect",{width:"20",height:"20",x:"2",y:"2",rx:"5",ry:"5"}],["path",{d:"M16 11.37A4 4 0 1 1 12.63 8 4 4 0 0 1 16 11.37z"}],["line",{x1:"17.5",x2:"17.51",y1:"6.5",y2:"6.5"}]],Lp=[["line",{x1:"19",x2:"10",y1:"4",y2:"4"}],["line",{x1:"14",x2:"5",y1:"20",y2:"20"}],["line",{x1:"15",x2:"9",y1:"4",y2:"20"}]],fp=[["path",{d:"m16 14 4 4-4 4"}],["path",{d:"M20 10a8 8 0 1 0-8 8h8"}]],kp=[["path",{d:"M4 10a8 8 0 1 1 8 8H4"}],["path",{d:"m8 22-4-4 4-4"}]],Pp=[["path",{d:"M12 9.5V21m0-11.5L6 3m6 6.5L18 3"}],["path",{d:"M6 15h12"}],["path",{d:"M6 11h12"}]],Bp=[["path",{d:"M21 17a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v2a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-2Z"}],["path",{d:"M6 15v-2"}],["path",{d:"M12 15V9"}],["circle",{cx:"12",cy:"6",r:"3"}]],Dp=[["path",{d:"M5 3v14"}],["path",{d:"M12 3v8"}],["path",{d:"M19 3v18"}]],Fp=[["path",{d:"M18 17a1 1 0 0 0-1 1v1a2 2 0 1 0 2-2z"}],["path",{d:"M20.97 3.61a.45.45 0 0 0-.58-.58C10.2 6.6 6.6 10.2 3.03 20.39a.45.45 0 0 0 .58.58C13.8 17.4 17.4 13.8 20.97 3.61"}],["path",{d:"m6.707 6.707 10.586 10.586"}],["path",{d:"M7 5a2 2 0 1 0-2 2h1a1 1 0 0 0 1-1z"}]],zp=[["path",{d:"M2.586 17.414A2 2 0 0 0 2 18.828V21a1 1 0 0 0 1 1h3a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h1a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h.172a2 2 0 0 0 1.414-.586l.814-.814a6.5 6.5 0 1 0-4-4z"}],["circle",{cx:"16.5",cy:"7.5",r:".5",fill:"currentColor"}]],bp=[["path",{d:"M12.4 2.7a2.5 2.5 0 0 1 3.4 0l5.5 5.5a2.5 2.5 0 0 1 0 3.4l-3.7 3.7a2.5 2.5 0 0 1-3.4 0L8.7 9.8a2.5 2.5 0 0 1 0-3.4z"}],["path",{d:"m14 7 3 3"}],["path",{d:"m9.4 10.6-6.814 6.814A2 2 0 0 0 2 18.828V21a1 1 0 0 0 1 1h3a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h1a1 1 0 0 0 1-1v-1a1 1 0 0 1 1-1h.172a2 2 0 0 0 1.414-.586l.814-.814"}]],Rp=[["path",{d:"m15.5 7.5 2.3 2.3a1 1 0 0 0 1.4 0l2.1-2.1a1 1 0 0 0 0-1.4L19 4"}],["path",{d:"m21 2-9.6 9.6"}],["circle",{cx:"7.5",cy:"15.5",r:"5.5"}]],Tp=[["rect",{width:"20",height:"16",x:"2",y:"4",rx:"2"}],["path",{d:"M6 8h4"}],["path",{d:"M14 8h.01"}],["path",{d:"M18 8h.01"}],["path",{d:"M2 12h20"}],["path",{d:"M6 12v4"}],["path",{d:"M10 12v4"}],["path",{d:"M14 12v4"}],["path",{d:"M18 12v4"}]],qp=[["path",{d:"M 20 4 A2 2 0 0 1 22 6"}],["path",{d:"M 22 6 L 22 16.41"}],["path",{d:"M 7 16 L 16 16"}],["path",{d:"M 9.69 4 L 20 4"}],["path",{d:"M14 8h.01"}],["path",{d:"M18 8h.01"}],["path",{d:"m2 2 20 20"}],["path",{d:"M20 20H4a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2"}],["path",{d:"M6 8h.01"}],["path",{d:"M8 12h.01"}]],Up=[["path",{d:"M10 8h.01"}],["path",{d:"M12 12h.01"}],["path",{d:"M14 8h.01"}],["path",{d:"M16 12h.01"}],["path",{d:"M18 8h.01"}],["path",{d:"M6 8h.01"}],["path",{d:"M7 16h10"}],["path",{d:"M8 12h.01"}],["rect",{width:"20",height:"16",x:"2",y:"4",rx:"2"}]],Op=[["path",{d:"M12 2v5"}],["path",{d:"M14.829 15.998a3 3 0 1 1-5.658 0"}],["path",{d:"M20.92 14.606A1 1 0 0 1 20 16H4a1 1 0 0 1-.92-1.394l3-7A1 1 0 0 1 7 7h10a1 1 0 0 1 .92.606z"}]],Zp=[["path",{d:"M10.293 2.293a1 1 0 0 1 1.414 0l2.5 2.5 5.994 1.227a1 1 0 0 1 .506 1.687l-7 7a1 1 0 0 1-1.687-.506l-1.227-5.994-2.5-2.5a1 1 0 0 1 0-1.414z"}],["path",{d:"m14.207 4.793-3.414 3.414"}],["path",{d:"M3 20a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v1a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1z"}],["path",{d:"m9.086 6.5-4.793 4.793a1 1 0 0 0-.18 1.17L7 18"}]],Gp=[["path",{d:"M12 10v12"}],["path",{d:"M17.929 7.629A1 1 0 0 1 17 9H7a1 1 0 0 1-.928-1.371l2-5A1 1 0 0 1 9 2h6a1 1 0 0 1 .928.629z"}],["path",{d:"M9 22h6"}]],Ip=[["path",{d:"M19.929 18.629A1 1 0 0 1 19 20H9a1 1 0 0 1-.928-1.371l2-5A1 1 0 0 1 11 13h6a1 1 0 0 1 .928.629z"}],["path",{d:"M6 3a2 2 0 0 1 2 2v2a2 2 0 0 1-2 2H5a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1z"}],["path",{d:"M8 6h4a2 2 0 0 1 2 2v5"}]],Wp=[["path",{d:"M19.929 9.629A1 1 0 0 1 19 11H9a1 1 0 0 1-.928-1.371l2-5A1 1 0 0 1 11 4h6a1 1 0 0 1 .928.629z"}],["path",{d:"M6 15a2 2 0 0 1 2 2v2a2 2 0 0 1-2 2H5a1 1 0 0 1-1-1v-4a1 1 0 0 1 1-1z"}],["path",{d:"M8 18h4a2 2 0 0 0 2-2v-5"}]],Ep=[["path",{d:"M12 12v6"}],["path",{d:"M4.077 10.615A1 1 0 0 0 5 12h14a1 1 0 0 0 .923-1.385l-3.077-7.384A2 2 0 0 0 15 2H9a2 2 0 0 0-1.846 1.23Z"}],["path",{d:"M8 20a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v1a1 1 0 0 1-1 1H9a1 1 0 0 1-1-1z"}]],Xp=[["path",{d:"m12 8 6-3-6-3v10"}],["path",{d:"m8 11.99-5.5 3.14a1 1 0 0 0 0 1.74l8.5 4.86a2 2 0 0 0 2 0l8.5-4.86a1 1 0 0 0 0-1.74L16 12"}],["path",{d:"m6.49 12.85 11.02 6.3"}],["path",{d:"M17.51 12.85 6.5 19.15"}]],jp=[["path",{d:"M10 18v-7"}],["path",{d:"M11.12 2.198a2 2 0 0 1 1.76.006l7.866 3.847c.476.233.31.949-.22.949H3.474c-.53 0-.695-.716-.22-.949z"}],["path",{d:"M14 18v-7"}],["path",{d:"M18 18v-7"}],["path",{d:"M3 22h18"}],["path",{d:"M6 18v-7"}]],Np=[["path",{d:"m5 8 6 6"}],["path",{d:"m4 14 6-6 2-3"}],["path",{d:"M2 5h12"}],["path",{d:"M7 2h1"}],["path",{d:"m22 22-5-10-5 10"}],["path",{d:"M14 18h6"}]],Kp=[["path",{d:"M2 20h20"}],["path",{d:"m9 10 2 2 4-4"}],["rect",{x:"3",y:"4",width:"18",height:"12",rx:"2"}]],p2=[["rect",{width:"18",height:"12",x:"3",y:"4",rx:"2",ry:"2"}],["line",{x1:"2",x2:"22",y1:"20",y2:"20"}]],Qp=[["path",{d:"M18 5a2 2 0 0 1 2 2v8.526a2 2 0 0 0 .212.897l1.068 2.127a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45l1.068-2.127A2 2 0 0 0 4 15.526V7a2 2 0 0 1 2-2z"}],["path",{d:"M20.054 15.987H3.946"}]],Jp=[["path",{d:"M7 22a5 5 0 0 1-2-4"}],["path",{d:"M7 16.93c.96.43 1.96.74 2.99.91"}],["path",{d:"M3.34 14A6.8 6.8 0 0 1 2 10c0-4.42 4.48-8 10-8s10 3.58 10 8a7.19 7.19 0 0 1-.33 2"}],["path",{d:"M5 18a2 2 0 1 0 0-4 2 2 0 0 0 0 4z"}],["path",{d:"M14.33 22h-.09a.35.35 0 0 1-.24-.32v-10a.34.34 0 0 1 .33-.34c.08 0 .15.03.21.08l7.34 6a.33.33 0 0 1-.21.59h-4.49l-2.57 3.85a.35.35 0 0 1-.28.14z"}]],Yp=[["path",{d:"M3.704 14.467A10 8 0 0 1 2 10a10 8 0 0 1 20 0 10 8 0 0 1-10 8 10 8 0 0 1-5.181-1.158"}],["path",{d:"M7 22a5 5 0 0 1-2-3.994"}],["circle",{cx:"5",cy:"16",r:"2"}]],_p=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M18 13a6 6 0 0 1-6 5 6 6 0 0 1-6-5h12Z"}],["line",{x1:"9",x2:"9.01",y1:"9",y2:"9"}],["line",{x1:"15",x2:"15.01",y1:"9",y2:"9"}]],xp=[["path",{d:"M13 13.74a2 2 0 0 1-2 0L2.5 8.87a1 1 0 0 1 0-1.74L11 2.26a2 2 0 0 1 2 0l8.5 4.87a1 1 0 0 1 0 1.74z"}],["path",{d:"m20 14.285 1.5.845a1 1 0 0 1 0 1.74L13 21.74a2 2 0 0 1-2 0l-8.5-4.87a1 1 0 0 1 0-1.74l1.5-.845"}]],i2=[["path",{d:"M12.83 2.18a2 2 0 0 0-1.66 0L2.6 6.08a1 1 0 0 0 0 1.83l8.58 3.91a2 2 0 0 0 1.66 0l8.58-3.9a1 1 0 0 0 0-1.83z"}],["path",{d:"M2 12a1 1 0 0 0 .58.91l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9A1 1 0 0 0 22 12"}],["path",{d:"M2 17a1 1 0 0 0 .58.91l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9A1 1 0 0 0 22 17"}]],ai=[["rect",{width:"7",height:"9",x:"3",y:"3",rx:"1"}],["rect",{width:"7",height:"5",x:"14",y:"3",rx:"1"}],["rect",{width:"7",height:"9",x:"14",y:"12",rx:"1"}],["rect",{width:"7",height:"5",x:"3",y:"16",rx:"1"}]],ti=[["rect",{width:"7",height:"7",x:"3",y:"3",rx:"1"}],["rect",{width:"7",height:"7",x:"14",y:"3",rx:"1"}],["rect",{width:"7",height:"7",x:"14",y:"14",rx:"1"}],["rect",{width:"7",height:"7",x:"3",y:"14",rx:"1"}]],hi=[["rect",{width:"7",height:"7",x:"3",y:"3",rx:"1"}],["rect",{width:"7",height:"7",x:"3",y:"14",rx:"1"}],["path",{d:"M14 4h7"}],["path",{d:"M14 9h7"}],["path",{d:"M14 15h7"}],["path",{d:"M14 20h7"}]],di=[["rect",{width:"7",height:"18",x:"3",y:"3",rx:"1"}],["rect",{width:"7",height:"7",x:"14",y:"3",rx:"1"}],["rect",{width:"7",height:"7",x:"14",y:"14",rx:"1"}]],ci=[["rect",{width:"18",height:"7",x:"3",y:"3",rx:"1"}],["rect",{width:"7",height:"7",x:"3",y:"14",rx:"1"}],["rect",{width:"7",height:"7",x:"14",y:"14",rx:"1"}]],Mi=[["rect",{width:"18",height:"7",x:"3",y:"3",rx:"1"}],["rect",{width:"9",height:"7",x:"3",y:"14",rx:"1"}],["rect",{width:"5",height:"7",x:"16",y:"14",rx:"1"}]],pi=[["path",{d:"M11 20A7 7 0 0 1 9.8 6.1C15.5 5 17 4.48 19 2c1 2 2 4.18 2 8 0 5.5-4.78 10-10 10Z"}],["path",{d:"M2 21c0-3 1.85-5.36 5.08-6C9.5 14.52 12 13 13 12"}]],ii=[["path",{d:"M2 22c1.25-.987 2.27-1.975 3.9-2.2a5.56 5.56 0 0 1 3.8 1.5 4 4 0 0 0 6.187-2.353 3.5 3.5 0 0 0 3.69-5.116A3.5 3.5 0 0 0 20.95 8 3.5 3.5 0 1 0 16 3.05a3.5 3.5 0 0 0-5.831 1.373 3.5 3.5 0 0 0-5.116 3.69 4 4 0 0 0-2.348 6.155C3.499 15.42 4.409 16.712 4.2 18.1 3.926 19.743 3.014 20.732 2 22"}],["path",{d:"M2 22 17 7"}]],ni=[["path",{d:"M16 12h3a2 2 0 0 0 1.902-1.38l1.056-3.333A1 1 0 0 0 21 6H3a1 1 0 0 0-.958 1.287l1.056 3.334A2 2 0 0 0 5 12h3"}],["path",{d:"M18 6V3a1 1 0 0 0-1-1h-3"}],["rect",{width:"8",height:"12",x:"8",y:"10",rx:"1"}]],li=[["rect",{width:"8",height:"18",x:"3",y:"3",rx:"1"}],["path",{d:"M7 3v18"}],["path",{d:"M20.4 18.9c.2.5-.1 1.1-.6 1.3l-1.9.7c-.5.2-1.1-.1-1.3-.6L11.1 5.1c-.2-.5.1-1.1.6-1.3l1.9-.7c.5-.2 1.1.1 1.3.6Z"}]],ei=[["path",{d:"m16 6 4 14"}],["path",{d:"M12 6v14"}],["path",{d:"M8 8v12"}],["path",{d:"M4 4v16"}]],ri=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"m4.93 4.93 4.24 4.24"}],["path",{d:"m14.83 9.17 4.24-4.24"}],["path",{d:"m14.83 14.83 4.24 4.24"}],["path",{d:"m9.17 14.83-4.24 4.24"}],["circle",{cx:"12",cy:"12",r:"4"}]],oi=[["path",{d:"M14 12h2v8"}],["path",{d:"M14 20h4"}],["path",{d:"M6 12h4"}],["path",{d:"M6 20h4"}],["path",{d:"M8 20V8a4 4 0 0 1 7.464-2"}]],vi=[["path",{d:"M16.8 11.2c.8-.9 1.2-2 1.2-3.2a6 6 0 0 0-9.3-5"}],["path",{d:"m2 2 20 20"}],["path",{d:"M6.3 6.3a4.67 4.67 0 0 0 1.2 5.2c.7.7 1.3 1.5 1.5 2.5"}],["path",{d:"M9 18h6"}],["path",{d:"M10 22h4"}]],$i=[["path",{d:"M15 14c.2-1 .7-1.7 1.5-2.5 1-.9 1.5-2.2 1.5-3.5A6 6 0 0 0 6 8c0 1 .2 2.2 1.5 3.5.7.7 1.3 1.5 1.5 2.5"}],["path",{d:"M9 18h6"}],["path",{d:"M10 22h4"}]],mi=[["path",{d:"M7 3.5c5-2 7 2.5 3 4C1.5 10 2 15 5 16c5 2 9-10 14-7s.5 13.5-4 12c-5-2.5.5-11 6-2"}]],yi=[["path",{d:"M9 17H7A5 5 0 0 1 7 7"}],["path",{d:"M15 7h2a5 5 0 0 1 4 8"}],["line",{x1:"8",x2:"12",y1:"12",y2:"12"}],["line",{x1:"2",x2:"22",y1:"2",y2:"22"}]],si=[["path",{d:"M9 17H7A5 5 0 0 1 7 7h2"}],["path",{d:"M15 7h2a5 5 0 1 1 0 10h-2"}],["line",{x1:"8",x2:"16",y1:"12",y2:"12"}]],gi=[["path",{d:"M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71"}],["path",{d:"M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71"}]],ui=[["path",{d:"M16 8a6 6 0 0 1 6 6v7h-4v-7a2 2 0 0 0-2-2 2 2 0 0 0-2 2v7h-4v-7a6 6 0 0 1 6-6z"}],["rect",{width:"4",height:"12",x:"2",y:"9"}],["circle",{cx:"4",cy:"4",r:"2"}]],Ci=[["path",{d:"M16 5H3"}],["path",{d:"M16 12H3"}],["path",{d:"M11 19H3"}],["path",{d:"m15 18 2 2 4-4"}]],Hi=[["path",{d:"M13 5h8"}],["path",{d:"M13 12h8"}],["path",{d:"M13 19h8"}],["path",{d:"m3 17 2 2 4-4"}],["path",{d:"m3 7 2 2 4-4"}]],Ai=[["path",{d:"M3 5h8"}],["path",{d:"M3 12h8"}],["path",{d:"M3 19h8"}],["path",{d:"m15 5 3 3 3-3"}],["path",{d:"m15 19 3-3 3 3"}]],wi=[["path",{d:"M3 5h8"}],["path",{d:"M3 12h8"}],["path",{d:"M3 19h8"}],["path",{d:"m15 8 3-3 3 3"}],["path",{d:"m15 16 3 3 3-3"}]],Vi=[["path",{d:"M10 5h11"}],["path",{d:"M10 12h11"}],["path",{d:"M10 19h11"}],["path",{d:"m3 10 3-3-3-3"}],["path",{d:"m3 20 3-3-3-3"}]],Si=[["path",{d:"M16 5H3"}],["path",{d:"M16 12H3"}],["path",{d:"M9 19H3"}],["path",{d:"m16 16-3 3 3 3"}],["path",{d:"M21 5v12a2 2 0 0 1-2 2h-6"}]],Li=[["path",{d:"M2 5h20"}],["path",{d:"M6 12h12"}],["path",{d:"M9 19h6"}]],fi=[["path",{d:"M12 5H2"}],["path",{d:"M6 12h12"}],["path",{d:"M9 19h6"}],["path",{d:"M16 5h6"}],["path",{d:"M19 8V2"}]],o=[["path",{d:"M21 5H11"}],["path",{d:"M21 12H11"}],["path",{d:"M21 19H11"}],["path",{d:"m7 8-4 4 4 4"}]],v=[["path",{d:"M21 5H11"}],["path",{d:"M21 12H11"}],["path",{d:"M21 19H11"}],["path",{d:"m3 8 4 4-4 4"}]],ki=[["path",{d:"M16 5H3"}],["path",{d:"M11 12H3"}],["path",{d:"M16 19H3"}],["path",{d:"M21 12h-6"}]],Pi=[["path",{d:"M11 5h10"}],["path",{d:"M11 12h10"}],["path",{d:"M11 19h10"}],["path",{d:"M4 4h1v5"}],["path",{d:"M4 9h2"}],["path",{d:"M6.5 20H3.4c0-1 2.6-1.925 2.6-3.5a1.5 1.5 0 0 0-2.6-1.02"}]],Bi=[["path",{d:"M16 5H3"}],["path",{d:"M11 12H3"}],["path",{d:"M11 19H3"}],["path",{d:"M21 16V5"}],["circle",{cx:"18",cy:"16",r:"3"}]],Di=[["path",{d:"M16 5H3"}],["path",{d:"M11 12H3"}],["path",{d:"M16 19H3"}],["path",{d:"M18 9v6"}],["path",{d:"M21 12h-6"}]],Fi=[["path",{d:"M21 5H3"}],["path",{d:"M7 12H3"}],["path",{d:"M7 19H3"}],["path",{d:"M12 18a5 5 0 0 0 9-3 4.5 4.5 0 0 0-4.5-4.5c-1.33 0-2.54.54-3.41 1.41L11 14"}],["path",{d:"M11 10v4h4"}]],zi=[["path",{d:"M3 5h6"}],["path",{d:"M3 12h13"}],["path",{d:"M3 19h13"}],["path",{d:"m16 8-3-3 3-3"}],["path",{d:"M21 19V7a2 2 0 0 0-2-2h-6"}]],bi=[["path",{d:"M13 5h8"}],["path",{d:"M13 12h8"}],["path",{d:"M13 19h8"}],["path",{d:"m3 17 2 2 4-4"}],["rect",{x:"3",y:"4",width:"6",height:"6",rx:"1"}]],Ri=[["path",{d:"M8 5h13"}],["path",{d:"M13 12h8"}],["path",{d:"M13 19h8"}],["path",{d:"M3 10a2 2 0 0 0 2 2h3"}],["path",{d:"M3 5v12a2 2 0 0 0 2 2h3"}]],Ti=[["path",{d:"M21 5H3"}],["path",{d:"M10 12H3"}],["path",{d:"M10 19H3"}],["path",{d:"M15 12.003a1 1 0 0 1 1.517-.859l4.997 2.997a1 1 0 0 1 0 1.718l-4.997 2.997a1 1 0 0 1-1.517-.86z"}]],qi=[["path",{d:"M16 5H3"}],["path",{d:"M11 12H3"}],["path",{d:"M16 19H3"}],["path",{d:"m15.5 9.5 5 5"}],["path",{d:"m20.5 9.5-5 5"}]],Ui=[["path",{d:"M3 5h.01"}],["path",{d:"M3 12h.01"}],["path",{d:"M3 19h.01"}],["path",{d:"M8 5h13"}],["path",{d:"M8 12h13"}],["path",{d:"M8 19h13"}]],n2=[["path",{d:"M21 12a9 9 0 1 1-6.219-8.56"}]],Oi=[["path",{d:"M22 12a1 1 0 0 1-10 0 1 1 0 0 0-10 0"}],["path",{d:"M7 20.7a1 1 0 1 1 5-8.7 1 1 0 1 0 5-8.6"}],["path",{d:"M7 3.3a1 1 0 1 1 5 8.6 1 1 0 1 0 5 8.6"}],["circle",{cx:"12",cy:"12",r:"10"}]],Zi=[["path",{d:"M12 2v4"}],["path",{d:"m16.2 7.8 2.9-2.9"}],["path",{d:"M18 12h4"}],["path",{d:"m16.2 16.2 2.9 2.9"}],["path",{d:"M12 18v4"}],["path",{d:"m4.9 19.1 2.9-2.9"}],["path",{d:"M2 12h4"}],["path",{d:"m4.9 4.9 2.9 2.9"}]],Gi=[["line",{x1:"2",x2:"5",y1:"12",y2:"12"}],["line",{x1:"19",x2:"22",y1:"12",y2:"12"}],["line",{x1:"12",x2:"12",y1:"2",y2:"5"}],["line",{x1:"12",x2:"12",y1:"19",y2:"22"}],["circle",{cx:"12",cy:"12",r:"7"}],["circle",{cx:"12",cy:"12",r:"3"}]],Ii=[["path",{d:"M12 19v3"}],["path",{d:"M12 2v3"}],["path",{d:"M18.89 13.24a7 7 0 0 0-8.13-8.13"}],["path",{d:"M19 12h3"}],["path",{d:"M2 12h3"}],["path",{d:"m2 2 20 20"}],["path",{d:"M7.05 7.05a7 7 0 0 0 9.9 9.9"}]],Wi=[["line",{x1:"2",x2:"5",y1:"12",y2:"12"}],["line",{x1:"19",x2:"22",y1:"12",y2:"12"}],["line",{x1:"12",x2:"12",y1:"2",y2:"5"}],["line",{x1:"12",x2:"12",y1:"19",y2:"22"}],["circle",{cx:"12",cy:"12",r:"7"}]],l2=[["circle",{cx:"12",cy:"16",r:"1"}],["rect",{width:"18",height:"12",x:"3",y:"10",rx:"2"}],["path",{d:"M7 10V7a5 5 0 0 1 9.33-2.5"}]],Ei=[["circle",{cx:"12",cy:"16",r:"1"}],["rect",{x:"3",y:"10",width:"18",height:"12",rx:"2"}],["path",{d:"M7 10V7a5 5 0 0 1 10 0v3"}]],e2=[["rect",{width:"18",height:"11",x:"3",y:"11",rx:"2",ry:"2"}],["path",{d:"M7 11V7a5 5 0 0 1 9.9-1"}]],Xi=[["rect",{width:"18",height:"11",x:"3",y:"11",rx:"2",ry:"2"}],["path",{d:"M7 11V7a5 5 0 0 1 10 0v4"}]],ji=[["path",{d:"m10 17 5-5-5-5"}],["path",{d:"M15 12H3"}],["path",{d:"M15 3h4a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-4"}]],Ni=[["path",{d:"m16 17 5-5-5-5"}],["path",{d:"M21 12H9"}],["path",{d:"M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4"}]],Ki=[["path",{d:"M3 5h1"}],["path",{d:"M3 12h1"}],["path",{d:"M3 19h1"}],["path",{d:"M8 5h1"}],["path",{d:"M8 12h1"}],["path",{d:"M8 19h1"}],["path",{d:"M13 5h8"}],["path",{d:"M13 12h8"}],["path",{d:"M13 19h8"}]],Qi=[["circle",{cx:"11",cy:"11",r:"8"}],["path",{d:"m21 21-4.3-4.3"}],["path",{d:"M11 11a2 2 0 0 0 4 0 4 4 0 0 0-8 0 6 6 0 0 0 12 0"}]],Ji=[["path",{d:"M6 20a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2"}],["path",{d:"M8 18V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v14"}],["path",{d:"M10 20h4"}],["circle",{cx:"16",cy:"20",r:"2"}],["circle",{cx:"8",cy:"20",r:"2"}]],Yi=[["path",{d:"m12 15 4 4"}],["path",{d:"M2.352 10.648a1.205 1.205 0 0 0 0 1.704l2.296 2.296a1.205 1.205 0 0 0 1.704 0l6.029-6.029a1 1 0 1 1 3 3l-6.029 6.029a1.205 1.205 0 0 0 0 1.704l2.296 2.296a1.205 1.205 0 0 0 1.704 0l6.365-6.367A1 1 0 0 0 8.716 4.282z"}],["path",{d:"m5 8 4 4"}]],_i=[["path",{d:"M22 13V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h8"}],["path",{d:"m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"}],["path",{d:"m16 19 2 2 4-4"}]],xi=[["path",{d:"M22 15V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h8"}],["path",{d:"m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"}],["path",{d:"M16 19h6"}]],an=[["path",{d:"M21.2 8.4c.5.38.8.97.8 1.6v10a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V10a2 2 0 0 1 .8-1.6l8-6a2 2 0 0 1 2.4 0l8 6Z"}],["path",{d:"m22 10-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 10"}]],tn=[["path",{d:"M22 13V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h8"}],["path",{d:"m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"}],["path",{d:"M19 16v6"}],["path",{d:"M16 19h6"}]],r2=[["path",{d:"M22 10.5V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h12.5"}],["path",{d:"m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"}],["path",{d:"M18 15.28c.2-.4.5-.8.9-1a2.1 2.1 0 0 1 2.6.4c.3.4.5.8.5 1.3 0 1.3-2 2-2 2"}],["path",{d:"M20 22v.01"}]],hn=[["path",{d:"M22 12.5V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h7.5"}],["path",{d:"m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"}],["path",{d:"M18 21a3 3 0 1 0 0-6 3 3 0 0 0 0 6Z"}],["circle",{cx:"18",cy:"18",r:"3"}],["path",{d:"m22 22-1.5-1.5"}]],dn=[["path",{d:"M22 10.5V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h12.5"}],["path",{d:"m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"}],["path",{d:"M20 14v4"}],["path",{d:"M20 22v.01"}]],cn=[["path",{d:"M22 13V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v12c0 1.1.9 2 2 2h9"}],["path",{d:"m22 7-8.97 5.7a1.94 1.94 0 0 1-2.06 0L2 7"}],["path",{d:"m17 17 4 4"}],["path",{d:"m21 17-4 4"}]],Mn=[["path",{d:"m22 7-8.991 5.727a2 2 0 0 1-2.009 0L2 7"}],["rect",{x:"2",y:"4",width:"20",height:"16",rx:"2"}]],pn=[["path",{d:"M22 17a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V9.5C2 7 4 5 6.5 5H18c2.2 0 4 1.8 4 4v8Z"}],["polyline",{points:"15,9 18,9 18,11"}],["path",{d:"M6.5 5C9 5 11 7 11 9.5V17a2 2 0 0 1-2 2"}],["line",{x1:"6",x2:"7",y1:"10",y2:"10"}]],nn=[["path",{d:"M17 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-8a2 2 0 0 1 1-1.732"}],["path",{d:"m22 5.5-6.419 4.179a2 2 0 0 1-2.162 0L7 5.5"}],["rect",{x:"7",y:"3",width:"15",height:"12",rx:"2"}]],ln=[["path",{d:"m11 19-1.106-.552a2 2 0 0 0-1.788 0l-3.659 1.83A1 1 0 0 1 3 19.381V6.618a1 1 0 0 1 .553-.894l4.553-2.277a2 2 0 0 1 1.788 0l4.212 2.106a2 2 0 0 0 1.788 0l3.659-1.83A1 1 0 0 1 21 4.619V14"}],["path",{d:"M15 5.764V14"}],["path",{d:"M21 18h-6"}],["path",{d:"M9 3.236v15"}]],en=[["path",{d:"M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"}],["path",{d:"m9 10 2 2 4-4"}]],rn=[["path",{d:"M19.43 12.935c.357-.967.57-1.955.57-2.935a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 1.202 0 32.197 32.197 0 0 0 .813-.728"}],["circle",{cx:"12",cy:"10",r:"3"}],["path",{d:"m16 18 2 2 4-4"}]],on=[["path",{d:"M15 22a1 1 0 0 1-1-1v-4a1 1 0 0 1 .445-.832l3-2a1 1 0 0 1 1.11 0l3 2A1 1 0 0 1 22 17v4a1 1 0 0 1-1 1z"}],["path",{d:"M18 10a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 .601.2"}],["path",{d:"M18 22v-3"}],["circle",{cx:"10",cy:"10",r:"3"}]],vn=[["path",{d:"M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"}],["path",{d:"M9 10h6"}]],$n=[["path",{d:"M18.977 14C19.6 12.701 20 11.343 20 10a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 1.202 0 32 32 0 0 0 .824-.738"}],["circle",{cx:"12",cy:"10",r:"3"}],["path",{d:"M16 18h6"}]],mn=[["path",{d:"M12.75 7.09a3 3 0 0 1 2.16 2.16"}],["path",{d:"M17.072 17.072c-1.634 2.17-3.527 3.912-4.471 4.727a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 1.432-4.568"}],["path",{d:"m2 2 20 20"}],["path",{d:"M8.475 2.818A8 8 0 0 1 20 10c0 1.183-.31 2.377-.81 3.533"}],["path",{d:"M9.13 9.13a3 3 0 0 0 3.74 3.74"}]],o2=[["path",{d:"M17.97 9.304A8 8 0 0 0 2 10c0 4.69 4.887 9.562 7.022 11.468"}],["path",{d:"M21.378 16.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"}],["circle",{cx:"10",cy:"10",r:"3"}]],yn=[["path",{d:"M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"}],["path",{d:"M12 7v6"}],["path",{d:"M9 10h6"}]],sn=[["path",{d:"M19.914 11.105A7.298 7.298 0 0 0 20 10a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 1.202 0 32 32 0 0 0 .824-.738"}],["circle",{cx:"12",cy:"10",r:"3"}],["path",{d:"M16 18h6"}],["path",{d:"M19 15v6"}]],gn=[["path",{d:"M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"}],["path",{d:"m14.5 7.5-5 5"}],["path",{d:"m9.5 7.5 5 5"}]],un=[["path",{d:"M19.752 11.901A7.78 7.78 0 0 0 20 10a8 8 0 0 0-16 0c0 4.993 5.539 10.193 7.399 11.799a1 1 0 0 0 1.202 0 19 19 0 0 0 .09-.077"}],["circle",{cx:"12",cy:"10",r:"3"}],["path",{d:"m21.5 15.5-5 5"}],["path",{d:"m21.5 20.5-5-5"}]],Cn=[["path",{d:"M20 10c0 4.993-5.539 10.193-7.399 11.799a1 1 0 0 1-1.202 0C9.539 20.193 4 14.993 4 10a8 8 0 0 1 16 0"}],["circle",{cx:"12",cy:"10",r:"3"}]],Hn=[["path",{d:"M18 8c0 3.613-3.869 7.429-5.393 8.795a1 1 0 0 1-1.214 0C9.87 15.429 6 11.613 6 8a6 6 0 0 1 12 0"}],["circle",{cx:"12",cy:"8",r:"2"}],["path",{d:"M8.714 14h-3.71a1 1 0 0 0-.948.683l-2.004 6A1 1 0 0 0 3 22h18a1 1 0 0 0 .948-1.316l-2-6a1 1 0 0 0-.949-.684h-3.712"}]],An=[["path",{d:"m11 19-1.106-.552a2 2 0 0 0-1.788 0l-3.659 1.83A1 1 0 0 1 3 19.381V6.618a1 1 0 0 1 .553-.894l4.553-2.277a2 2 0 0 1 1.788 0l4.212 2.106a2 2 0 0 0 1.788 0l3.659-1.83A1 1 0 0 1 21 4.619V12"}],["path",{d:"M15 5.764V12"}],["path",{d:"M18 15v6"}],["path",{d:"M21 18h-6"}],["path",{d:"M9 3.236v15"}]],wn=[["path",{d:"M14.106 5.553a2 2 0 0 0 1.788 0l3.659-1.83A1 1 0 0 1 21 4.619v12.764a1 1 0 0 1-.553.894l-4.553 2.277a2 2 0 0 1-1.788 0l-4.212-2.106a2 2 0 0 0-1.788 0l-3.659 1.83A1 1 0 0 1 3 19.381V6.618a1 1 0 0 1 .553-.894l4.553-2.277a2 2 0 0 1 1.788 0z"}],["path",{d:"M15 5.764v15"}],["path",{d:"M9 3.236v15"}]],Vn=[["path",{d:"m14 6 4 4"}],["path",{d:"M17 3h4v4"}],["path",{d:"m21 3-7.75 7.75"}],["circle",{cx:"9",cy:"15",r:"6"}]],Sn=[["path",{d:"M16 3h5v5"}],["path",{d:"m21 3-6.75 6.75"}],["circle",{cx:"10",cy:"14",r:"6"}]],Ln=[["path",{d:"M8 22h8"}],["path",{d:"M12 11v11"}],["path",{d:"m19 3-7 8-7-8Z"}]],fn=[["path",{d:"M15 3h6v6"}],["path",{d:"m21 3-7 7"}],["path",{d:"m3 21 7-7"}],["path",{d:"M9 21H3v-6"}]],kn=[["path",{d:"M8 3H5a2 2 0 0 0-2 2v3"}],["path",{d:"M21 8V5a2 2 0 0 0-2-2h-3"}],["path",{d:"M3 16v3a2 2 0 0 0 2 2h3"}],["path",{d:"M16 21h3a2 2 0 0 0 2-2v-3"}]],Pn=[["path",{d:"M7.21 15 2.66 7.14a2 2 0 0 1 .13-2.2L4.4 2.8A2 2 0 0 1 6 2h12a2 2 0 0 1 1.6.8l1.6 2.14a2 2 0 0 1 .14 2.2L16.79 15"}],["path",{d:"M11 12 5.12 2.2"}],["path",{d:"m13 12 5.88-9.8"}],["path",{d:"M8 7h8"}],["circle",{cx:"12",cy:"17",r:"5"}],["path",{d:"M12 18v-2h-.5"}]],Bn=[["path",{d:"M11.636 6A13 13 0 0 0 19.4 3.2 1 1 0 0 1 21 4v11.344"}],["path",{d:"M14.378 14.357A13 13 0 0 0 11 14H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h1"}],["path",{d:"m2 2 20 20"}],["path",{d:"M6 14a12 12 0 0 0 2.4 7.2 2 2 0 0 0 3.2-2.4A8 8 0 0 1 10 14"}],["path",{d:"M8 8v6"}]],Dn=[["path",{d:"M11 6a13 13 0 0 0 8.4-2.8A1 1 0 0 1 21 4v12a1 1 0 0 1-1.6.8A13 13 0 0 0 11 14H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2z"}],["path",{d:"M6 14a12 12 0 0 0 2.4 7.2 2 2 0 0 0 3.2-2.4A8 8 0 0 1 10 14"}],["path",{d:"M8 6v8"}]],Fn=[["circle",{cx:"12",cy:"12",r:"10"}],["line",{x1:"8",x2:"16",y1:"15",y2:"15"}],["line",{x1:"9",x2:"9.01",y1:"9",y2:"9"}],["line",{x1:"15",x2:"15.01",y1:"9",y2:"9"}]],zn=[["path",{d:"M6 19v-3"}],["path",{d:"M10 19v-3"}],["path",{d:"M14 19v-3"}],["path",{d:"M18 19v-3"}],["path",{d:"M8 11V9"}],["path",{d:"M16 11V9"}],["path",{d:"M12 11V9"}],["path",{d:"M2 15h20"}],["path",{d:"M2 7a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v1.1a2 2 0 0 0 0 3.837V17a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-5.1a2 2 0 0 0 0-3.837Z"}]],bn=[["path",{d:"M4 5h16"}],["path",{d:"M4 12h16"}],["path",{d:"M4 19h16"}]],Rn=[["path",{d:"m8 6 4-4 4 4"}],["path",{d:"M12 2v10.3a4 4 0 0 1-1.172 2.872L4 22"}],["path",{d:"m20 22-5-5"}]],Tn=[["path",{d:"m10 9-3 3 3 3"}],["path",{d:"m14 15 3-3-3-3"}],["path",{d:"M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719"}]],qn=[["path",{d:"M10.1 2.182a10 10 0 0 1 3.8 0"}],["path",{d:"M13.9 21.818a10 10 0 0 1-3.8 0"}],["path",{d:"M17.609 3.72a10 10 0 0 1 2.69 2.7"}],["path",{d:"M2.182 13.9a10 10 0 0 1 0-3.8"}],["path",{d:"M20.28 17.61a10 10 0 0 1-2.7 2.69"}],["path",{d:"M21.818 10.1a10 10 0 0 1 0 3.8"}],["path",{d:"M3.721 6.391a10 10 0 0 1 2.7-2.69"}],["path",{d:"m6.163 21.117-2.906.85a1 1 0 0 1-1.236-1.169l.965-2.98"}]],Un=[["path",{d:"M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719"}],["path",{d:"M7.828 13.07A3 3 0 0 1 12 8.764a3 3 0 0 1 5.004 2.224 3 3 0 0 1-.832 2.083l-3.447 3.62a1 1 0 0 1-1.45-.001z"}]],On=[["path",{d:"M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719"}],["path",{d:"M8 12h.01"}],["path",{d:"M12 12h.01"}],["path",{d:"M16 12h.01"}]],Zn=[["path",{d:"m2 2 20 20"}],["path",{d:"M4.93 4.929a10 10 0 0 0-1.938 11.412 2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 0 0 11.302-1.989"}],["path",{d:"M8.35 2.69A10 10 0 0 1 21.3 15.65"}]],Gn=[["path",{d:"M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719"}],["path",{d:"M8 12h8"}],["path",{d:"M12 8v8"}]],v2=[["path",{d:"M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719"}],["path",{d:"M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"}],["path",{d:"M12 17h.01"}]],In=[["path",{d:"M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719"}],["path",{d:"m10 15-3-3 3-3"}],["path",{d:"M7 12h8a2 2 0 0 1 2 2v1"}]],Wn=[["path",{d:"M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719"}],["path",{d:"M12 8v4"}],["path",{d:"M12 16h.01"}]],En=[["path",{d:"M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719"}],["path",{d:"m15 9-6 6"}],["path",{d:"m9 9 6 6"}]],Xn=[["path",{d:"M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z"}],["path",{d:"m10 8-3 3 3 3"}],["path",{d:"m14 14 3-3-3-3"}]],jn=[["path",{d:"M2.992 16.342a2 2 0 0 1 .094 1.167l-1.065 3.29a1 1 0 0 0 1.236 1.168l3.413-.998a2 2 0 0 1 1.099.092 10 10 0 1 0-4.777-4.719"}]],Nn=[["path",{d:"M12 19h.01"}],["path",{d:"M12 3h.01"}],["path",{d:"M16 19h.01"}],["path",{d:"M16 3h.01"}],["path",{d:"M2 13h.01"}],["path",{d:"M2 17v4.286a.71.71 0 0 0 1.212.502l2.202-2.202A2 2 0 0 1 6.828 19H8"}],["path",{d:"M2 5a2 2 0 0 1 2-2"}],["path",{d:"M2 9h.01"}],["path",{d:"M20 3a2 2 0 0 1 2 2"}],["path",{d:"M22 13h.01"}],["path",{d:"M22 17a2 2 0 0 1-2 2"}],["path",{d:"M22 9h.01"}],["path",{d:"M8 3h.01"}]],Kn=[["path",{d:"M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z"}],["path",{d:"M10 15h4"}],["path",{d:"M10 9h4"}],["path",{d:"M12 7v4"}]],Qn=[["path",{d:"M12.7 3H4a2 2 0 0 0-2 2v16.286a.71.71 0 0 0 1.212.502l2.202-2.202A2 2 0 0 1 6.828 19H20a2 2 0 0 0 2-2v-4.7"}],["circle",{cx:"19",cy:"6",r:"3"}]],Jn=[["path",{d:"M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z"}],["path",{d:"M7.5 9.5c0 .687.265 1.383.697 1.844l3.009 3.264a1.14 1.14 0 0 0 .407.314 1 1 0 0 0 .783-.004 1.14 1.14 0 0 0 .398-.31l3.008-3.264A2.77 2.77 0 0 0 16.5 9.5 2.5 2.5 0 0 0 12 8a2.5 2.5 0 0 0-4.5 1.5"}]],Yn=[["path",{d:"M22 8.5V5a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v16.286a.71.71 0 0 0 1.212.502l2.202-2.202A2 2 0 0 1 6.828 19H10"}],["path",{d:"M20 15v-2a2 2 0 0 0-4 0v2"}],["rect",{x:"14",y:"15",width:"8",height:"5",rx:"1"}]],_n=[["path",{d:"M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z"}],["path",{d:"M12 11h.01"}],["path",{d:"M16 11h.01"}],["path",{d:"M8 11h.01"}]],xn=[["path",{d:"M19 19H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.7.7 0 0 1 2 21.286V5a2 2 0 0 1 1.184-1.826"}],["path",{d:"m2 2 20 20"}],["path",{d:"M8.656 3H20a2 2 0 0 1 2 2v11.344"}]],al=[["path",{d:"M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z"}],["path",{d:"M12 8v6"}],["path",{d:"M9 11h6"}]],tl=[["path",{d:"M14 14a2 2 0 0 0 2-2V8h-2"}],["path",{d:"M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z"}],["path",{d:"M8 14a2 2 0 0 0 2-2V8H8"}]],hl=[["path",{d:"M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z"}],["path",{d:"m10 8-3 3 3 3"}],["path",{d:"M17 14v-1a2 2 0 0 0-2-2H7"}]],dl=[["path",{d:"M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z"}],["path",{d:"M7 11h10"}],["path",{d:"M7 15h6"}],["path",{d:"M7 7h8"}]],cl=[["path",{d:"M12 3H4a2 2 0 0 0-2 2v16.286a.71.71 0 0 0 1.212.502l2.202-2.202A2 2 0 0 1 6.828 19H20a2 2 0 0 0 2-2v-4"}],["path",{d:"M16 3h6v6"}],["path",{d:"m16 9 6-6"}]],Ml=[["path",{d:"M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z"}],["path",{d:"M12 15h.01"}],["path",{d:"M12 7v4"}]],pl=[["path",{d:"M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z"}]],il=[["path",{d:"M22 17a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 21.286V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2z"}],["path",{d:"m14.5 8.5-5 5"}],["path",{d:"m9.5 8.5 5 5"}]],nl=[["path",{d:"M16 10a2 2 0 0 1-2 2H6.828a2 2 0 0 0-1.414.586l-2.202 2.202A.71.71 0 0 1 2 14.286V4a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z"}],["path",{d:"M20 9a2 2 0 0 1 2 2v10.286a.71.71 0 0 1-1.212.502l-2.202-2.202A2 2 0 0 0 17.172 19H10a2 2 0 0 1-2-2v-1"}]],ll=[["path",{d:"M12 19v3"}],["path",{d:"M15 9.34V5a3 3 0 0 0-5.68-1.33"}],["path",{d:"M16.95 16.95A7 7 0 0 1 5 12v-2"}],["path",{d:"M18.89 13.23A7 7 0 0 0 19 12v-2"}],["path",{d:"m2 2 20 20"}],["path",{d:"M9 9v3a3 3 0 0 0 5.12 2.12"}]],el=[["path",{d:"M12 19v3"}],["path",{d:"M19 10v2a7 7 0 0 1-14 0v-2"}],["rect",{x:"9",y:"2",width:"6",height:"13",rx:"3"}]],rl=[["path",{d:"M18 12h2"}],["path",{d:"M18 16h2"}],["path",{d:"M18 20h2"}],["path",{d:"M18 4h2"}],["path",{d:"M18 8h2"}],["path",{d:"M4 12h2"}],["path",{d:"M4 16h2"}],["path",{d:"M4 20h2"}],["path",{d:"M4 4h2"}],["path",{d:"M4 8h2"}],["path",{d:"M8 2a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V4a2 2 0 0 0-2-2h-1.5c-.276 0-.494.227-.562.495a2 2 0 0 1-3.876 0C9.994 2.227 9.776 2 9.5 2z"}]],$2=[["path",{d:"m11 7.601-5.994 8.19a1 1 0 0 0 .1 1.298l.817.818a1 1 0 0 0 1.314.087L15.09 12"}],["path",{d:"M16.5 21.174C15.5 20.5 14.372 20 13 20c-2.058 0-3.928 2.356-6 2-2.072-.356-2.775-3.369-1.5-4.5"}],["circle",{cx:"16",cy:"7",r:"5"}]],ol=[["path",{d:"M6 18h8"}],["path",{d:"M3 22h18"}],["path",{d:"M14 22a7 7 0 1 0 0-14h-1"}],["path",{d:"M9 14h2"}],["path",{d:"M9 12a2 2 0 0 1-2-2V6h6v4a2 2 0 0 1-2 2Z"}],["path",{d:"M12 6V3a1 1 0 0 0-1-1H9a1 1 0 0 0-1 1v3"}]],vl=[["path",{d:"M12 13v8"}],["path",{d:"M12 3v3"}],["path",{d:"M4 6a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1h13a2 2 0 0 0 1.152-.365l3.424-2.317a1 1 0 0 0 0-1.635l-3.424-2.318A2 2 0 0 0 17 6z"}]],$l=[["path",{d:"M8 2h8"}],["path",{d:"M9 2v1.343M15 2v2.789a4 4 0 0 0 .672 2.219l.656.984a4 4 0 0 1 .672 2.22v1.131M7.8 7.8l-.128.192A4 4 0 0 0 7 10.212V20a2 2 0 0 0 2 2h6a2 2 0 0 0 2-2v-3"}],["path",{d:"M7 15a6.47 6.47 0 0 1 5 0 6.472 6.472 0 0 0 3.435.435"}],["line",{x1:"2",x2:"22",y1:"2",y2:"22"}]],ml=[["rect",{width:"20",height:"15",x:"2",y:"4",rx:"2"}],["rect",{width:"8",height:"7",x:"6",y:"8",rx:"1"}],["path",{d:"M18 8v7"}],["path",{d:"M6 19v2"}],["path",{d:"M18 19v2"}]],yl=[["path",{d:"m14 10 7-7"}],["path",{d:"M20 10h-6V4"}],["path",{d:"m3 21 7-7"}],["path",{d:"M4 14h6v6"}]],sl=[["path",{d:"M8 3v3a2 2 0 0 1-2 2H3"}],["path",{d:"M21 8h-3a2 2 0 0 1-2-2V3"}],["path",{d:"M3 16h3a2 2 0 0 1 2 2v3"}],["path",{d:"M16 21v-3a2 2 0 0 1 2-2h3"}]],gl=[["path",{d:"M8 2h8"}],["path",{d:"M9 2v2.789a4 4 0 0 1-.672 2.219l-.656.984A4 4 0 0 0 7 10.212V20a2 2 0 0 0 2 2h6a2 2 0 0 0 2-2v-9.789a4 4 0 0 0-.672-2.219l-.656-.984A4 4 0 0 1 15 4.788V2"}],["path",{d:"M7 15a6.472 6.472 0 0 1 5 0 6.47 6.47 0 0 0 5 0"}]],ul=[["path",{d:"M5 12h14"}]],Cl=[["path",{d:"m9 10 2 2 4-4"}],["rect",{width:"20",height:"14",x:"2",y:"3",rx:"2"}],["path",{d:"M12 17v4"}],["path",{d:"M8 21h8"}]],Hl=[["path",{d:"M12 17v4"}],["path",{d:"m14.305 7.53.923-.382"}],["path",{d:"m15.228 4.852-.923-.383"}],["path",{d:"m16.852 3.228-.383-.924"}],["path",{d:"m16.852 8.772-.383.923"}],["path",{d:"m19.148 3.228.383-.924"}],["path",{d:"m19.53 9.696-.382-.924"}],["path",{d:"m20.772 4.852.924-.383"}],["path",{d:"m20.772 7.148.924.383"}],["path",{d:"M22 13v2a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h7"}],["path",{d:"M8 21h8"}],["circle",{cx:"18",cy:"6",r:"3"}]],Al=[["path",{d:"M12 17v4"}],["path",{d:"M22 12.307V15a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h8.693"}],["path",{d:"M8 21h8"}],["circle",{cx:"19",cy:"6",r:"3"}]],wl=[["path",{d:"M12 13V7"}],["path",{d:"m15 10-3 3-3-3"}],["rect",{width:"20",height:"14",x:"2",y:"3",rx:"2"}],["path",{d:"M12 17v4"}],["path",{d:"M8 21h8"}]],Vl=[["path",{d:"M17 17H4a2 2 0 0 1-2-2V5c0-1.5 1-2 1-2"}],["path",{d:"M22 15V5a2 2 0 0 0-2-2H9"}],["path",{d:"M8 21h8"}],["path",{d:"M12 17v4"}],["path",{d:"m2 2 20 20"}]],Sl=[["path",{d:"M15.033 9.44a.647.647 0 0 1 0 1.12l-4.065 2.352a.645.645 0 0 1-.968-.56V7.648a.645.645 0 0 1 .967-.56z"}],["path",{d:"M12 17v4"}],["path",{d:"M8 21h8"}],["rect",{x:"2",y:"3",width:"20",height:"14",rx:"2"}]],Ll=[["path",{d:"M10 13V7"}],["path",{d:"M14 13V7"}],["rect",{width:"20",height:"14",x:"2",y:"3",rx:"2"}],["path",{d:"M12 17v4"}],["path",{d:"M8 21h8"}]],fl=[["path",{d:"M18 8V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v7a2 2 0 0 0 2 2h8"}],["path",{d:"M10 19v-3.96 3.15"}],["path",{d:"M7 19h5"}],["rect",{width:"6",height:"10",x:"16",y:"12",rx:"2"}]],kl=[["path",{d:"M5.5 20H8"}],["path",{d:"M17 9h.01"}],["rect",{width:"10",height:"16",x:"12",y:"4",rx:"2"}],["path",{d:"M8 6H4a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2h4"}],["circle",{cx:"17",cy:"15",r:"1"}]],Pl=[["path",{d:"M12 17v4"}],["path",{d:"M8 21h8"}],["rect",{x:"2",y:"3",width:"20",height:"14",rx:"2"}],["rect",{x:"9",y:"7",width:"6",height:"6",rx:"1"}]],Bl=[["path",{d:"m9 10 3-3 3 3"}],["path",{d:"M12 13V7"}],["rect",{width:"20",height:"14",x:"2",y:"3",rx:"2"}],["path",{d:"M12 17v4"}],["path",{d:"M8 21h8"}]],Dl=[["path",{d:"m14.5 12.5-5-5"}],["path",{d:"m9.5 12.5 5-5"}],["rect",{width:"20",height:"14",x:"2",y:"3",rx:"2"}],["path",{d:"M12 17v4"}],["path",{d:"M8 21h8"}]],Fl=[["rect",{width:"20",height:"14",x:"2",y:"3",rx:"2"}],["line",{x1:"8",x2:"16",y1:"21",y2:"21"}],["line",{x1:"12",x2:"12",y1:"17",y2:"21"}]],zl=[["path",{d:"M18 5h4"}],["path",{d:"M20 3v4"}],["path",{d:"M20.985 12.486a9 9 0 1 1-9.473-9.472c.405-.022.617.46.402.803a6 6 0 0 0 8.268 8.268c.344-.215.825-.004.803.401"}]],bl=[["path",{d:"M20.985 12.486a9 9 0 1 1-9.473-9.472c.405-.022.617.46.402.803a6 6 0 0 0 8.268 8.268c.344-.215.825-.004.803.401"}]],Rl=[["path",{d:"m8 3 4 8 5-5 5 15H2L8 3z"}],["path",{d:"M4.14 15.08c2.62-1.57 5.24-1.43 7.86.42 2.74 1.94 5.49 2 8.23.19"}]],Tl=[["path",{d:"m8 3 4 8 5-5 5 15H2L8 3z"}]],ql=[["path",{d:"M12 6v.343"}],["path",{d:"M18.218 18.218A7 7 0 0 1 5 15V9a7 7 0 0 1 .782-3.218"}],["path",{d:"M19 13.343V9A7 7 0 0 0 8.56 2.902"}],["path",{d:"M22 22 2 2"}]],Ul=[["path",{d:"M4.037 4.688a.495.495 0 0 1 .651-.651l16 6.5a.5.5 0 0 1-.063.947l-6.124 1.58a2 2 0 0 0-1.438 1.435l-1.579 6.126a.5.5 0 0 1-.947.063z"}]],Ol=[["path",{d:"M2.034 2.681a.498.498 0 0 1 .647-.647l9 3.5a.5.5 0 0 1-.033.944L8.204 7.545a1 1 0 0 0-.66.66l-1.066 3.443a.5.5 0 0 1-.944.033z"}],["circle",{cx:"16",cy:"16",r:"6"}],["path",{d:"m11.8 11.8 8.4 8.4"}]],Zl=[["path",{d:"M14 4.1 12 6"}],["path",{d:"m5.1 8-2.9-.8"}],["path",{d:"m6 12-1.9 2"}],["path",{d:"M7.2 2.2 8 5.1"}],["path",{d:"M9.037 9.69a.498.498 0 0 1 .653-.653l11 4.5a.5.5 0 0 1-.074.949l-4.349 1.041a1 1 0 0 0-.74.739l-1.04 4.35a.5.5 0 0 1-.95.074z"}]],Gl=[["path",{d:"M12.586 12.586 19 19"}],["path",{d:"M3.688 3.037a.497.497 0 0 0-.651.651l6.5 15.999a.501.501 0 0 0 .947-.062l1.569-6.083a2 2 0 0 1 1.448-1.479l6.124-1.579a.5.5 0 0 0 .063-.947z"}]],Il=[["rect",{x:"5",y:"2",width:"14",height:"20",rx:"7"}],["path",{d:"M12 6v4"}]],m2=[["path",{d:"M5 3v16h16"}],["path",{d:"m5 19 6-6"}],["path",{d:"m2 6 3-3 3 3"}],["path",{d:"m18 16 3 3-3 3"}]],Wl=[["path",{d:"M19 13v6h-6"}],["path",{d:"M5 11V5h6"}],["path",{d:"m5 5 14 14"}]],El=[["path",{d:"M11 19H5v-6"}],["path",{d:"M13 5h6v6"}],["path",{d:"M19 5 5 19"}]],Xl=[["path",{d:"M11 19H5V13"}],["path",{d:"M19 5L5 19"}]],jl=[["path",{d:"M19 13V19H13"}],["path",{d:"M5 5L19 19"}]],Nl=[["path",{d:"M8 18L12 22L16 18"}],["path",{d:"M12 2V22"}]],Kl=[["path",{d:"m18 8 4 4-4 4"}],["path",{d:"M2 12h20"}],["path",{d:"m6 8-4 4 4 4"}]],Ql=[["path",{d:"M6 8L2 12L6 16"}],["path",{d:"M2 12H22"}]],Jl=[["path",{d:"M18 8L22 12L18 16"}],["path",{d:"M2 12H22"}]],Yl=[["path",{d:"M5 11V5H11"}],["path",{d:"M5 5L19 19"}]],_l=[["path",{d:"M13 5H19V11"}],["path",{d:"M19 5L5 19"}]],xl=[["path",{d:"M8 6L12 2L16 6"}],["path",{d:"M12 2V22"}]],ae=[["path",{d:"M12 2v20"}],["path",{d:"m8 18 4 4 4-4"}],["path",{d:"m8 6 4-4 4 4"}]],te=[["path",{d:"M12 2v20"}],["path",{d:"m15 19-3 3-3-3"}],["path",{d:"m19 9 3 3-3 3"}],["path",{d:"M2 12h20"}],["path",{d:"m5 9-3 3 3 3"}],["path",{d:"m9 5 3-3 3 3"}]],he=[["circle",{cx:"8",cy:"18",r:"4"}],["path",{d:"M12 18V2l7 4"}]],de=[["circle",{cx:"12",cy:"18",r:"4"}],["path",{d:"M16 18V2"}]],ce=[["path",{d:"M9 18V5l12-2v13"}],["path",{d:"m9 9 12-2"}],["circle",{cx:"6",cy:"18",r:"3"}],["circle",{cx:"18",cy:"16",r:"3"}]],Me=[["path",{d:"M9 18V5l12-2v13"}],["circle",{cx:"6",cy:"18",r:"3"}],["circle",{cx:"18",cy:"16",r:"3"}]],pe=[["path",{d:"M9.31 9.31 5 21l7-4 7 4-1.17-3.17"}],["path",{d:"M14.53 8.88 12 2l-1.17 3.17"}],["line",{x1:"2",x2:"22",y1:"2",y2:"22"}]],ie=[["polygon",{points:"12 2 19 21 12 17 5 21 12 2"}]],ne=[["path",{d:"M8.43 8.43 3 11l8 2 2 8 2.57-5.43"}],["path",{d:"M17.39 11.73 22 2l-9.73 4.61"}],["line",{x1:"2",x2:"22",y1:"2",y2:"22"}]],le=[["polygon",{points:"3 11 22 2 13 21 11 13 3 11"}]],ee=[["rect",{x:"16",y:"16",width:"6",height:"6",rx:"1"}],["rect",{x:"2",y:"16",width:"6",height:"6",rx:"1"}],["rect",{x:"9",y:"2",width:"6",height:"6",rx:"1"}],["path",{d:"M5 16v-3a1 1 0 0 1 1-1h12a1 1 0 0 1 1 1v3"}],["path",{d:"M12 12V8"}]],re=[["path",{d:"M15 18h-5"}],["path",{d:"M18 14h-8"}],["path",{d:"M4 22h16a2 2 0 0 0 2-2V4a2 2 0 0 0-2-2H8a2 2 0 0 0-2 2v16a2 2 0 0 1-4 0v-9a2 2 0 0 1 2-2h2"}],["rect",{width:"8",height:"4",x:"10",y:"6",rx:"1"}]],oe=[["path",{d:"M6 8.32a7.43 7.43 0 0 1 0 7.36"}],["path",{d:"M9.46 6.21a11.76 11.76 0 0 1 0 11.58"}],["path",{d:"M12.91 4.1a15.91 15.91 0 0 1 .01 15.8"}],["path",{d:"M16.37 2a20.16 20.16 0 0 1 0 20"}]],ve=[["path",{d:"M12 2v10"}],["path",{d:"m8.5 4 7 4"}],["path",{d:"m8.5 8 7-4"}],["circle",{cx:"12",cy:"17",r:"5"}]],$e=[["path",{d:"M13.4 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-7.4"}],["path",{d:"M2 6h4"}],["path",{d:"M2 10h4"}],["path",{d:"M2 14h4"}],["path",{d:"M2 18h4"}],["path",{d:"M21.378 5.626a1 1 0 1 0-3.004-3.004l-5.01 5.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"}]],me=[["path",{d:"M2 6h4"}],["path",{d:"M2 10h4"}],["path",{d:"M2 14h4"}],["path",{d:"M2 18h4"}],["rect",{width:"16",height:"20",x:"4",y:"2",rx:"2"}],["path",{d:"M15 2v20"}],["path",{d:"M15 7h5"}],["path",{d:"M15 12h5"}],["path",{d:"M15 17h5"}]],ye=[["path",{d:"M2 6h4"}],["path",{d:"M2 10h4"}],["path",{d:"M2 14h4"}],["path",{d:"M2 18h4"}],["rect",{width:"16",height:"20",x:"4",y:"2",rx:"2"}],["path",{d:"M9.5 8h5"}],["path",{d:"M9.5 12H16"}],["path",{d:"M9.5 16H14"}]],se=[["path",{d:"M8 2v4"}],["path",{d:"M12 2v4"}],["path",{d:"M16 2v4"}],["path",{d:"M16 4h2a2 2 0 0 1 2 2v2"}],["path",{d:"M20 12v2"}],["path",{d:"M20 18v2a2 2 0 0 1-2 2h-1"}],["path",{d:"M13 22h-2"}],["path",{d:"M7 22H6a2 2 0 0 1-2-2v-2"}],["path",{d:"M4 14v-2"}],["path",{d:"M4 8V6a2 2 0 0 1 2-2h2"}],["path",{d:"M8 10h6"}],["path",{d:"M8 14h8"}],["path",{d:"M8 18h5"}]],ge=[["path",{d:"M2 6h4"}],["path",{d:"M2 10h4"}],["path",{d:"M2 14h4"}],["path",{d:"M2 18h4"}],["rect",{width:"16",height:"20",x:"4",y:"2",rx:"2"}],["path",{d:"M16 2v20"}]],ue=[["path",{d:"M8 2v4"}],["path",{d:"M12 2v4"}],["path",{d:"M16 2v4"}],["rect",{width:"16",height:"18",x:"4",y:"4",rx:"2"}],["path",{d:"M8 10h6"}],["path",{d:"M8 14h8"}],["path",{d:"M8 18h5"}]],Ce=[["path",{d:"M12 4V2"}],["path",{d:"M5 10v4a7.004 7.004 0 0 0 5.277 6.787c.412.104.802.292 1.102.592L12 22l.621-.621c.3-.3.69-.488 1.102-.592a7.01 7.01 0 0 0 4.125-2.939"}],["path",{d:"M19 10v3.343"}],["path",{d:"M12 12c-1.349-.573-1.905-1.005-2.5-2-.546.902-1.048 1.353-2.5 2-1.018-.644-1.46-1.08-2-2-1.028.71-1.69.918-3 1 1.081-1.048 1.757-2.03 2-3 .194-.776.84-1.551 1.79-2.21m11.654 5.997c.887-.457 1.28-.891 1.556-1.787 1.032.916 1.683 1.157 3 1-1.297-1.036-1.758-2.03-2-3-.5-2-4-4-8-4-.74 0-1.461.068-2.15.192"}],["line",{x1:"2",x2:"22",y1:"2",y2:"22"}]],He=[["path",{d:"M12 4V2"}],["path",{d:"M5 10v4a7.004 7.004 0 0 0 5.277 6.787c.412.104.802.292 1.102.592L12 22l.621-.621c.3-.3.69-.488 1.102-.592A7.003 7.003 0 0 0 19 14v-4"}],["path",{d:"M12 4C8 4 4.5 6 4 8c-.243.97-.919 1.952-2 3 1.31-.082 1.972-.29 3-1 .54.92.982 1.356 2 2 1.452-.647 1.954-1.098 2.5-2 .595.995 1.151 1.427 2.5 2 1.31-.621 1.862-1.058 2.5-2 .629.977 1.162 1.423 2.5 2 1.209-.548 1.68-.967 2-2 1.032.916 1.683 1.157 3 1-1.297-1.036-1.758-2.03-2-3-.5-2-4-4-8-4Z"}]],y2=[["path",{d:"M12 16h.01"}],["path",{d:"M12 8v4"}],["path",{d:"M15.312 2a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586l-4.688-4.688A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2z"}]],Ae=[["path",{d:"M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z"}],["path",{d:"M8 12h8"}]],s2=[["path",{d:"m15 9-6 6"}],["path",{d:"M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z"}],["path",{d:"m9 9 6 6"}]],we=[["path",{d:"M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z"}]],g2=[["path",{d:"M10 15V9"}],["path",{d:"M14 15V9"}],["path",{d:"M2.586 16.726A2 2 0 0 1 2 15.312V8.688a2 2 0 0 1 .586-1.414l4.688-4.688A2 2 0 0 1 8.688 2h6.624a2 2 0 0 1 1.414.586l4.688 4.688A2 2 0 0 1 22 8.688v6.624a2 2 0 0 1-.586 1.414l-4.688 4.688a2 2 0 0 1-1.414.586H8.688a2 2 0 0 1-1.414-.586z"}]],Ve=[["path",{d:"M3 20h4.5a.5.5 0 0 0 .5-.5v-.282a.52.52 0 0 0-.247-.437 8 8 0 1 1 8.494-.001.52.52 0 0 0-.247.438v.282a.5.5 0 0 0 .5.5H21"}]],Se=[["path",{d:"M3 3h6l6 18h6"}],["path",{d:"M14 3h7"}]],Le=[["path",{d:"M20.341 6.484A10 10 0 0 1 10.266 21.85"}],["path",{d:"M3.659 17.516A10 10 0 0 1 13.74 2.152"}],["circle",{cx:"12",cy:"12",r:"3"}],["circle",{cx:"19",cy:"5",r:"2"}],["circle",{cx:"5",cy:"19",r:"2"}]],fe=[["path",{d:"M12 3v6"}],["path",{d:"M16.76 3a2 2 0 0 1 1.8 1.1l2.23 4.479a2 2 0 0 1 .21.891V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V9.472a2 2 0 0 1 .211-.894L5.45 4.1A2 2 0 0 1 7.24 3z"}],["path",{d:"M3.054 9.013h17.893"}]],ke=[["path",{d:"m16 16 2 2 4-4"}],["path",{d:"M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14"}],["path",{d:"m7.5 4.27 9 5.15"}],["polyline",{points:"3.29 7 12 12 20.71 7"}],["line",{x1:"12",x2:"12",y1:"22",y2:"12"}]],Pe=[["path",{d:"M12 12V4a1 1 0 0 1 1-1h6.297a1 1 0 0 1 .651 1.759l-4.696 4.025"}],["path",{d:"m12 21-7.414-7.414A2 2 0 0 1 4 12.172V6.415a1.002 1.002 0 0 1 1.707-.707L20 20.009"}],["path",{d:"m12.214 3.381 8.414 14.966a1 1 0 0 1-.167 1.199l-1.168 1.163a1 1 0 0 1-.706.291H6.351a1 1 0 0 1-.625-.219L3.25 18.8a1 1 0 0 1 .631-1.781l4.165.027"}]],Be=[["path",{d:"M16 16h6"}],["path",{d:"M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14"}],["path",{d:"m7.5 4.27 9 5.15"}],["polyline",{points:"3.29 7 12 12 20.71 7"}],["line",{x1:"12",x2:"12",y1:"22",y2:"12"}]],De=[["path",{d:"M12 22v-9"}],["path",{d:"M15.17 2.21a1.67 1.67 0 0 1 1.63 0L21 4.57a1.93 1.93 0 0 1 0 3.36L8.82 14.79a1.655 1.655 0 0 1-1.64 0L3 12.43a1.93 1.93 0 0 1 0-3.36z"}],["path",{d:"M20 13v3.87a2.06 2.06 0 0 1-1.11 1.83l-6 3.08a1.93 1.93 0 0 1-1.78 0l-6-3.08A2.06 2.06 0 0 1 4 16.87V13"}],["path",{d:"M21 12.43a1.93 1.93 0 0 0 0-3.36L8.83 2.2a1.64 1.64 0 0 0-1.63 0L3 4.57a1.93 1.93 0 0 0 0 3.36l12.18 6.86a1.636 1.636 0 0 0 1.63 0z"}]],Fe=[["path",{d:"M16 16h6"}],["path",{d:"M19 13v6"}],["path",{d:"M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14"}],["path",{d:"m7.5 4.27 9 5.15"}],["polyline",{points:"3.29 7 12 12 20.71 7"}],["line",{x1:"12",x2:"12",y1:"22",y2:"12"}]],ze=[["path",{d:"M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14"}],["path",{d:"m7.5 4.27 9 5.15"}],["polyline",{points:"3.29 7 12 12 20.71 7"}],["line",{x1:"12",x2:"12",y1:"22",y2:"12"}],["path",{d:"m17 13 5 5m-5 0 5-5"}]],be=[["path",{d:"M21 10V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l2-1.14"}],["path",{d:"m7.5 4.27 9 5.15"}],["polyline",{points:"3.29 7 12 12 20.71 7"}],["line",{x1:"12",x2:"12",y1:"22",y2:"12"}],["circle",{cx:"18.5",cy:"15.5",r:"2.5"}],["path",{d:"M20.27 17.27 22 19"}]],Re=[["path",{d:"M11 21.73a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73z"}],["path",{d:"M12 22V12"}],["polyline",{points:"3.29 7 12 12 20.71 7"}],["path",{d:"m7.5 4.27 9 5.15"}]],Te=[["path",{d:"m19 11-8-8-8.6 8.6a2 2 0 0 0 0 2.8l5.2 5.2c.8.8 2 .8 2.8 0L19 11Z"}],["path",{d:"m5 2 5 5"}],["path",{d:"M2 13h15"}],["path",{d:"M22 20a2 2 0 1 1-4 0c0-1.6 1.7-2.4 2-4 .3 1.6 2 2.4 2 4Z"}]],qe=[["rect",{width:"16",height:"6",x:"2",y:"2",rx:"2"}],["path",{d:"M10 16v-2a2 2 0 0 1 2-2h8a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2h-2"}],["rect",{width:"4",height:"6",x:"8",y:"16",rx:"1"}]],u2=[["path",{d:"M10 2v2"}],["path",{d:"M14 2v4"}],["path",{d:"M17 2a1 1 0 0 1 1 1v9H6V3a1 1 0 0 1 1-1z"}],["path",{d:"M6 12a1 1 0 0 0-1 1v1a2 2 0 0 0 2 2h2a1 1 0 0 1 1 1v2.9a2 2 0 1 0 4 0V17a1 1 0 0 1 1-1h2a2 2 0 0 0 2-2v-1a1 1 0 0 0-1-1"}]],Ue=[["path",{d:"m14.622 17.897-10.68-2.913"}],["path",{d:"M18.376 2.622a1 1 0 1 1 3.002 3.002L17.36 9.643a.5.5 0 0 0 0 .707l.944.944a2.41 2.41 0 0 1 0 3.408l-.944.944a.5.5 0 0 1-.707 0L8.354 7.348a.5.5 0 0 1 0-.707l.944-.944a2.41 2.41 0 0 1 3.408 0l.944.944a.5.5 0 0 0 .707 0z"}],["path",{d:"M9 8c-1.804 2.71-3.97 3.46-6.583 3.948a.507.507 0 0 0-.302.819l7.32 8.883a1 1 0 0 0 1.185.204C12.735 20.405 16 16.792 16 15"}]],Oe=[["path",{d:"M12 22a1 1 0 0 1 0-20 10 9 0 0 1 10 9 5 5 0 0 1-5 5h-2.25a1.75 1.75 0 0 0-1.4 2.8l.3.4a1.75 1.75 0 0 1-1.4 2.8z"}],["circle",{cx:"13.5",cy:"6.5",r:".5",fill:"currentColor"}],["circle",{cx:"17.5",cy:"10.5",r:".5",fill:"currentColor"}],["circle",{cx:"6.5",cy:"12.5",r:".5",fill:"currentColor"}],["circle",{cx:"8.5",cy:"7.5",r:".5",fill:"currentColor"}]],Ze=[["path",{d:"M11.25 17.25h1.5L12 18z"}],["path",{d:"m15 12 2 2"}],["path",{d:"M18 6.5a.5.5 0 0 0-.5-.5"}],["path",{d:"M20.69 9.67a4.5 4.5 0 1 0-7.04-5.5 8.35 8.35 0 0 0-3.3 0 4.5 4.5 0 1 0-7.04 5.5C2.49 11.2 2 12.88 2 14.5 2 19.47 6.48 22 12 22s10-2.53 10-7.5c0-1.62-.48-3.3-1.3-4.83"}],["path",{d:"M6 6.5a.495.495 0 0 1 .5-.5"}],["path",{d:"m9 12-2 2"}]],Ge=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M3 15h18"}],["path",{d:"m15 8-3 3-3-3"}]],C2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M14 15h1"}],["path",{d:"M19 15h2"}],["path",{d:"M3 15h2"}],["path",{d:"M9 15h1"}]],Ie=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M3 15h18"}],["path",{d:"m9 10 3-3 3 3"}]],H2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M9 3v18"}],["path",{d:"m16 15-3-3 3-3"}]],We=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M3 15h18"}]],A2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M9 14v1"}],["path",{d:"M9 19v2"}],["path",{d:"M9 3v2"}],["path",{d:"M9 9v1"}]],w2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M9 3v18"}],["path",{d:"m14 9 3 3-3 3"}]],Ee=[["path",{d:"M15 10V9"}],["path",{d:"M15 15v-1"}],["path",{d:"M15 21v-2"}],["path",{d:"M15 5V3"}],["path",{d:"M9 10V9"}],["path",{d:"M9 15v-1"}],["path",{d:"M9 21v-2"}],["path",{d:"M9 5V3"}],["rect",{x:"3",y:"3",width:"18",height:"18",rx:"2"}]],V2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M9 3v18"}]],Xe=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M15 3v18"}],["path",{d:"m8 9 3 3-3 3"}]],S2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M15 14v1"}],["path",{d:"M15 19v2"}],["path",{d:"M15 3v2"}],["path",{d:"M15 9v1"}]],je=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M15 3v18"}],["path",{d:"m10 15-3-3 3-3"}]],Ne=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M15 3v18"}]],Ke=[["path",{d:"M14 15h1"}],["path",{d:"M14 9h1"}],["path",{d:"M19 15h2"}],["path",{d:"M19 9h2"}],["path",{d:"M3 15h2"}],["path",{d:"M3 9h2"}],["path",{d:"M9 15h1"}],["path",{d:"M9 9h1"}],["rect",{x:"3",y:"3",width:"18",height:"18",rx:"2"}]],Qe=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M3 9h18"}],["path",{d:"m9 16 3-3 3 3"}]],L2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M14 9h1"}],["path",{d:"M19 9h2"}],["path",{d:"M3 9h2"}],["path",{d:"M9 9h1"}]],Je=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M3 9h18"}],["path",{d:"m15 14-3 3-3-3"}]],Ye=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M3 9h18"}]],_e=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M9 3v18"}],["path",{d:"M9 15h12"}]],xe=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M3 15h12"}],["path",{d:"M15 3v18"}]],f2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M3 9h18"}],["path",{d:"M9 21V9"}]],ar=[["path",{d:"m16 6-8.414 8.586a2 2 0 0 0 2.829 2.829l8.414-8.586a4 4 0 1 0-5.657-5.657l-8.379 8.551a6 6 0 1 0 8.485 8.485l8.379-8.551"}]],tr=[["path",{d:"M8 21s-4-3-4-9 4-9 4-9"}],["path",{d:"M16 3s4 3 4 9-4 9-4 9"}]],hr=[["path",{d:"M11 15h2"}],["path",{d:"M12 12v3"}],["path",{d:"M12 19v3"}],["path",{d:"M15.282 19a1 1 0 0 0 .948-.68l2.37-6.988a7 7 0 1 0-13.2 0l2.37 6.988a1 1 0 0 0 .948.68z"}],["path",{d:"M9 9a3 3 0 1 1 6 0"}]],dr=[["path",{d:"M5.8 11.3 2 22l10.7-3.79"}],["path",{d:"M4 3h.01"}],["path",{d:"M22 8h.01"}],["path",{d:"M15 2h.01"}],["path",{d:"M22 20h.01"}],["path",{d:"m22 2-2.24.75a2.9 2.9 0 0 0-1.96 3.12c.1.86-.57 1.63-1.45 1.63h-.38c-.86 0-1.6.6-1.76 1.44L14 10"}],["path",{d:"m22 13-.82-.33c-.86-.34-1.82.2-1.98 1.11c-.11.7-.72 1.22-1.43 1.22H17"}],["path",{d:"m11 2 .33.82c.34.86-.2 1.82-1.11 1.98C9.52 4.9 9 5.52 9 6.23V7"}],["path",{d:"M11 13c1.93 1.93 2.83 4.17 2 5-.83.83-3.07-.07-5-2-1.93-1.93-2.83-4.17-2-5 .83-.83 3.07.07 5 2Z"}]],cr=[["rect",{x:"14",y:"3",width:"5",height:"18",rx:"1"}],["rect",{x:"5",y:"3",width:"5",height:"18",rx:"1"}]],Mr=[["circle",{cx:"11",cy:"4",r:"2"}],["circle",{cx:"18",cy:"8",r:"2"}],["circle",{cx:"20",cy:"16",r:"2"}],["path",{d:"M9 10a5 5 0 0 1 5 5v3.5a3.5 3.5 0 0 1-6.84 1.045Q6.52 17.48 4.46 16.84A3.5 3.5 0 0 1 5.5 10Z"}]],pr=[["rect",{width:"14",height:"20",x:"5",y:"2",rx:"2"}],["path",{d:"M15 14h.01"}],["path",{d:"M9 6h6"}],["path",{d:"M9 10h6"}]],k2=[["path",{d:"M13 21h8"}],["path",{d:"M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z"}]],ir=[["path",{d:"m10 10-6.157 6.162a2 2 0 0 0-.5.833l-1.322 4.36a.5.5 0 0 0 .622.624l4.358-1.323a2 2 0 0 0 .83-.5L14 13.982"}],["path",{d:"m12.829 7.172 4.359-4.346a1 1 0 1 1 3.986 3.986l-4.353 4.353"}],["path",{d:"m2 2 20 20"}]],nr=[["path",{d:"M15.707 21.293a1 1 0 0 1-1.414 0l-1.586-1.586a1 1 0 0 1 0-1.414l5.586-5.586a1 1 0 0 1 1.414 0l1.586 1.586a1 1 0 0 1 0 1.414z"}],["path",{d:"m18 13-1.375-6.874a1 1 0 0 0-.746-.776L3.235 2.028a1 1 0 0 0-1.207 1.207L5.35 15.879a1 1 0 0 0 .776.746L13 18"}],["path",{d:"m2.3 2.3 7.286 7.286"}],["circle",{cx:"11",cy:"11",r:"2"}]],lr=[["path",{d:"M13 21h8"}],["path",{d:"m15 5 4 4"}],["path",{d:"M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z"}]],P2=[["path",{d:"M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z"}]],er=[["path",{d:"m10 10-6.157 6.162a2 2 0 0 0-.5.833l-1.322 4.36a.5.5 0 0 0 .622.624l4.358-1.323a2 2 0 0 0 .83-.5L14 13.982"}],["path",{d:"m12.829 7.172 4.359-4.346a1 1 0 1 1 3.986 3.986l-4.353 4.353"}],["path",{d:"m15 5 4 4"}],["path",{d:"m2 2 20 20"}]],rr=[["path",{d:"M13 7 8.7 2.7a2.41 2.41 0 0 0-3.4 0L2.7 5.3a2.41 2.41 0 0 0 0 3.4L7 13"}],["path",{d:"m8 6 2-2"}],["path",{d:"m18 16 2-2"}],["path",{d:"m17 11 4.3 4.3c.94.94.94 2.46 0 3.4l-2.6 2.6c-.94.94-2.46.94-3.4 0L11 17"}],["path",{d:"M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z"}],["path",{d:"m15 5 4 4"}]],or=[["path",{d:"M21.174 6.812a1 1 0 0 0-3.986-3.987L3.842 16.174a2 2 0 0 0-.5.83l-1.321 4.352a.5.5 0 0 0 .623.622l4.353-1.32a2 2 0 0 0 .83-.497z"}],["path",{d:"m15 5 4 4"}]],vr=[["path",{d:"M10.83 2.38a2 2 0 0 1 2.34 0l8 5.74a2 2 0 0 1 .73 2.25l-3.04 9.26a2 2 0 0 1-1.9 1.37H7.04a2 2 0 0 1-1.9-1.37L2.1 10.37a2 2 0 0 1 .73-2.25z"}]],$r=[["line",{x1:"19",x2:"5",y1:"5",y2:"19"}],["circle",{cx:"6.5",cy:"6.5",r:"2.5"}],["circle",{cx:"17.5",cy:"17.5",r:"2.5"}]],mr=[["circle",{cx:"12",cy:"5",r:"1"}],["path",{d:"m9 20 3-6 3 6"}],["path",{d:"m6 8 6 2 6-2"}],["path",{d:"M12 10v4"}]],yr=[["path",{d:"M20 11H4"}],["path",{d:"M20 7H4"}],["path",{d:"M7 21V4a1 1 0 0 1 1-1h4a1 1 0 0 1 0 12H7"}]],sr=[["path",{d:"M13 2a9 9 0 0 1 9 9"}],["path",{d:"M13 6a5 5 0 0 1 5 5"}],["path",{d:"M13.832 16.568a1 1 0 0 0 1.213-.303l.355-.465A2 2 0 0 1 17 15h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2A18 18 0 0 1 2 4a2 2 0 0 1 2-2h3a2 2 0 0 1 2 2v3a2 2 0 0 1-.8 1.6l-.468.351a1 1 0 0 0-.292 1.233 14 14 0 0 0 6.392 6.384"}]],gr=[["path",{d:"M14 6h8"}],["path",{d:"m18 2 4 4-4 4"}],["path",{d:"M13.832 16.568a1 1 0 0 0 1.213-.303l.355-.465A2 2 0 0 1 17 15h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2A18 18 0 0 1 2 4a2 2 0 0 1 2-2h3a2 2 0 0 1 2 2v3a2 2 0 0 1-.8 1.6l-.468.351a1 1 0 0 0-.292 1.233 14 14 0 0 0 6.392 6.384"}]],ur=[["path",{d:"M16 2v6h6"}],["path",{d:"m22 2-6 6"}],["path",{d:"M13.832 16.568a1 1 0 0 0 1.213-.303l.355-.465A2 2 0 0 1 17 15h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2A18 18 0 0 1 2 4a2 2 0 0 1 2-2h3a2 2 0 0 1 2 2v3a2 2 0 0 1-.8 1.6l-.468.351a1 1 0 0 0-.292 1.233 14 14 0 0 0 6.392 6.384"}]],Cr=[["path",{d:"m16 2 6 6"}],["path",{d:"m22 2-6 6"}],["path",{d:"M13.832 16.568a1 1 0 0 0 1.213-.303l.355-.465A2 2 0 0 1 17 15h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2A18 18 0 0 1 2 4a2 2 0 0 1 2-2h3a2 2 0 0 1 2 2v3a2 2 0 0 1-.8 1.6l-.468.351a1 1 0 0 0-.292 1.233 14 14 0 0 0 6.392 6.384"}]],Hr=[["path",{d:"M10.1 13.9a14 14 0 0 0 3.732 2.668 1 1 0 0 0 1.213-.303l.355-.465A2 2 0 0 1 17 15h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2 18 18 0 0 1-12.728-5.272"}],["path",{d:"M22 2 2 22"}],["path",{d:"M4.76 13.582A18 18 0 0 1 2 4a2 2 0 0 1 2-2h3a2 2 0 0 1 2 2v3a2 2 0 0 1-.8 1.6l-.468.351a1 1 0 0 0-.292 1.233 14 14 0 0 0 .244.473"}]],Ar=[["path",{d:"m16 8 6-6"}],["path",{d:"M22 8V2h-6"}],["path",{d:"M13.832 16.568a1 1 0 0 0 1.213-.303l.355-.465A2 2 0 0 1 17 15h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2A18 18 0 0 1 2 4a2 2 0 0 1 2-2h3a2 2 0 0 1 2 2v3a2 2 0 0 1-.8 1.6l-.468.351a1 1 0 0 0-.292 1.233 14 14 0 0 0 6.392 6.384"}]],wr=[["path",{d:"M13.832 16.568a1 1 0 0 0 1.213-.303l.355-.465A2 2 0 0 1 17 15h3a2 2 0 0 1 2 2v3a2 2 0 0 1-2 2A18 18 0 0 1 2 4a2 2 0 0 1 2-2h3a2 2 0 0 1 2 2v3a2 2 0 0 1-.8 1.6l-.468.351a1 1 0 0 0-.292 1.233 14 14 0 0 0 6.392 6.384"}]],Vr=[["line",{x1:"9",x2:"9",y1:"4",y2:"20"}],["path",{d:"M4 7c0-1.7 1.3-3 3-3h13"}],["path",{d:"M18 20c-1.7 0-3-1.3-3-3V4"}]],Sr=[["path",{d:"M18.5 8c-1.4 0-2.6-.8-3.2-2A6.87 6.87 0 0 0 2 9v11a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-8.5C22 9.6 20.4 8 18.5 8"}],["path",{d:"M2 14h20"}],["path",{d:"M6 14v4"}],["path",{d:"M10 14v4"}],["path",{d:"M14 14v4"}],["path",{d:"M18 14v4"}]],Lr=[["path",{d:"m14 13-8.381 8.38a1 1 0 0 1-3.001-3L11 9.999"}],["path",{d:"M15.973 4.027A13 13 0 0 0 5.902 2.373c-1.398.342-1.092 2.158.277 2.601a19.9 19.9 0 0 1 5.822 3.024"}],["path",{d:"M16.001 11.999a19.9 19.9 0 0 1 3.024 5.824c.444 1.369 2.26 1.676 2.603.278A13 13 0 0 0 20 8.069"}],["path",{d:"M18.352 3.352a1.205 1.205 0 0 0-1.704 0l-5.296 5.296a1.205 1.205 0 0 0 0 1.704l2.296 2.296a1.205 1.205 0 0 0 1.704 0l5.296-5.296a1.205 1.205 0 0 0 0-1.704z"}]],fr=[["path",{d:"M21 9V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v10c0 1.1.9 2 2 2h4"}],["rect",{width:"10",height:"7",x:"12",y:"13",rx:"2"}]],kr=[["path",{d:"M2 10h6V4"}],["path",{d:"m2 4 6 6"}],["path",{d:"M21 10V7a2 2 0 0 0-2-2h-7"}],["path",{d:"M3 14v2a2 2 0 0 0 2 2h3"}],["rect",{x:"12",y:"14",width:"10",height:"7",rx:"1"}]],Pr=[["path",{d:"M11 17h3v2a1 1 0 0 0 1 1h2a1 1 0 0 0 1-1v-3a3.16 3.16 0 0 0 2-2h1a1 1 0 0 0 1-1v-2a1 1 0 0 0-1-1h-1a5 5 0 0 0-2-4V3a4 4 0 0 0-3.2 1.6l-.3.4H11a6 6 0 0 0-6 6v1a5 5 0 0 0 2 4v3a1 1 0 0 0 1 1h2a1 1 0 0 0 1-1z"}],["path",{d:"M16 10h.01"}],["path",{d:"M2 8v1a2 2 0 0 0 2 2h1"}]],Br=[["path",{d:"M10 3v11"}],["path",{d:"M10 9H7a1 1 0 0 1 0-6h8"}],["path",{d:"M14 3v11"}],["path",{d:"m18 14 4 4H2"}],["path",{d:"m22 18-4 4"}]],Dr=[["path",{d:"M14 3v11"}],["path",{d:"M14 9h-3a3 3 0 0 1 0-6h9"}],["path",{d:"M18 3v11"}],["path",{d:"M22 18H2l4-4"}],["path",{d:"m6 22-4-4"}]],Fr=[["path",{d:"M13 4v16"}],["path",{d:"M17 4v16"}],["path",{d:"M19 4H9.5a4.5 4.5 0 0 0 0 9H13"}]],zr=[["path",{d:"M18 11h-4a1 1 0 0 0-1 1v5a1 1 0 0 0 1 1h4"}],["path",{d:"M6 7v13a2 2 0 0 0 2 2h8a2 2 0 0 0 2-2V7"}],["rect",{width:"16",height:"5",x:"4",y:"2",rx:"1"}]],br=[["path",{d:"m10.5 20.5 10-10a4.95 4.95 0 1 0-7-7l-10 10a4.95 4.95 0 1 0 7 7Z"}],["path",{d:"m8.5 8.5 7 7"}]],Rr=[["path",{d:"M12 17v5"}],["path",{d:"M15 9.34V7a1 1 0 0 1 1-1 2 2 0 0 0 0-4H7.89"}],["path",{d:"m2 2 20 20"}],["path",{d:"M9 9v1.76a2 2 0 0 1-1.11 1.79l-1.78.9A2 2 0 0 0 5 15.24V16a1 1 0 0 0 1 1h11"}]],Tr=[["path",{d:"M12 17v5"}],["path",{d:"M9 10.76a2 2 0 0 1-1.11 1.79l-1.78.9A2 2 0 0 0 5 15.24V16a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-.76a2 2 0 0 0-1.11-1.79l-1.78-.9A2 2 0 0 1 15 10.76V7a1 1 0 0 1 1-1 2 2 0 0 0 0-4H8a2 2 0 0 0 0 4 1 1 0 0 1 1 1z"}]],qr=[["path",{d:"m12 9-8.414 8.414A2 2 0 0 0 3 18.828v1.344a2 2 0 0 1-.586 1.414A2 2 0 0 1 3.828 21h1.344a2 2 0 0 0 1.414-.586L15 12"}],["path",{d:"m18 9 .4.4a1 1 0 1 1-3 3l-3.8-3.8a1 1 0 1 1 3-3l.4.4 3.4-3.4a1 1 0 1 1 3 3z"}],["path",{d:"m2 22 .414-.414"}]],Ur=[["path",{d:"m12 14-1 1"}],["path",{d:"m13.75 18.25-1.25 1.42"}],["path",{d:"M17.775 5.654a15.68 15.68 0 0 0-12.121 12.12"}],["path",{d:"M18.8 9.3a1 1 0 0 0 2.1 7.7"}],["path",{d:"M21.964 20.732a1 1 0 0 1-1.232 1.232l-18-5a1 1 0 0 1-.695-1.232A19.68 19.68 0 0 1 15.732 2.037a1 1 0 0 1 1.232.695z"}]],Or=[["path",{d:"M2 22h20"}],["path",{d:"M3.77 10.77 2 9l2-4.5 1.1.55c.55.28.9.84.9 1.45s.35 1.17.9 1.45L8 8.5l3-6 1.05.53a2 2 0 0 1 1.09 1.52l.72 5.4a2 2 0 0 0 1.09 1.52l4.4 2.2c.42.22.78.55 1.01.96l.6 1.03c.49.88-.06 1.98-1.06 2.1l-1.18.15c-.47.06-.95-.02-1.37-.24L4.29 11.15a2 2 0 0 1-.52-.38Z"}]],Zr=[["path",{d:"M2 22h20"}],["path",{d:"M6.36 17.4 4 17l-2-4 1.1-.55a2 2 0 0 1 1.8 0l.17.1a2 2 0 0 0 1.8 0L8 12 5 6l.9-.45a2 2 0 0 1 2.09.2l4.02 3a2 2 0 0 0 2.1.2l4.19-2.06a2.41 2.41 0 0 1 1.73-.17L21 7a1.4 1.4 0 0 1 .87 1.99l-.38.76c-.23.46-.6.84-1.07 1.08L7.58 17.2a2 2 0 0 1-1.22.18Z"}]],Gr=[["path",{d:"M17.8 19.2 16 11l3.5-3.5C21 6 21.5 4 21 3c-1-.5-3 0-4.5 1.5L13 8 4.8 6.2c-.5-.1-.9.1-1.1.5l-.3.5c-.2.5-.1 1 .3 1.3L9 12l-2 3H4l-1 1 3 2 2 3 1-1v-3l3-2 3.5 5.3c.3.4.8.5 1.3.3l.5-.2c.4-.3.6-.7.5-1.2z"}]],Ir=[["path",{d:"M5 5a2 2 0 0 1 3.008-1.728l11.997 6.998a2 2 0 0 1 .003 3.458l-12 7A2 2 0 0 1 5 19z"}]],Wr=[["path",{d:"M9 2v6"}],["path",{d:"M15 2v6"}],["path",{d:"M12 17v5"}],["path",{d:"M5 8h14"}],["path",{d:"M6 11V8h12v3a6 6 0 1 1-12 0Z"}]],B2=[["path",{d:"M6.3 20.3a2.4 2.4 0 0 0 3.4 0L12 18l-6-6-2.3 2.3a2.4 2.4 0 0 0 0 3.4Z"}],["path",{d:"m2 22 3-3"}],["path",{d:"M7.5 13.5 10 11"}],["path",{d:"M10.5 16.5 13 14"}],["path",{d:"m18 3-4 4h6l-4 4"}]],Er=[["path",{d:"M12 22v-5"}],["path",{d:"M9 8V2"}],["path",{d:"M15 8V2"}],["path",{d:"M18 8v5a4 4 0 0 1-4 4h-4a4 4 0 0 1-4-4V8Z"}]],Xr=[["path",{d:"M5 12h14"}],["path",{d:"M12 5v14"}]],jr=[["path",{d:"M3 2v1c0 1 2 1 2 2S3 6 3 7s2 1 2 2-2 1-2 2 2 1 2 2"}],["path",{d:"M18 6h.01"}],["path",{d:"M6 18h.01"}],["path",{d:"M20.83 8.83a4 4 0 0 0-5.66-5.66l-12 12a4 4 0 1 0 5.66 5.66Z"}],["path",{d:"M18 11.66V22a4 4 0 0 0 4-4V6"}]],Nr=[["path",{d:"M13 17a1 1 0 1 0-2 0l.5 4.5a0.5 0.5 0 0 0 1 0z",fill:"currentColor"}],["path",{d:"M16.85 18.58a9 9 0 1 0-9.7 0"}],["path",{d:"M8 14a5 5 0 1 1 8 0"}],["circle",{cx:"12",cy:"11",r:"1",fill:"currentColor"}]],Kr=[["path",{d:"M20 3a2 2 0 0 1 2 2v6a1 1 0 0 1-20 0V5a2 2 0 0 1 2-2z"}],["path",{d:"m8 10 4 4 4-4"}]],Qr=[["path",{d:"M22 14a8 8 0 0 1-8 8"}],["path",{d:"M18 11v-1a2 2 0 0 0-2-2a2 2 0 0 0-2 2"}],["path",{d:"M14 10V9a2 2 0 0 0-2-2a2 2 0 0 0-2 2v1"}],["path",{d:"M10 9.5V4a2 2 0 0 0-2-2a2 2 0 0 0-2 2v10"}],["path",{d:"M18 11a2 2 0 1 1 4 0v3a8 8 0 0 1-8 8h-2c-2.8 0-4.5-.86-5.99-2.34l-3.6-3.6a2 2 0 0 1 2.83-2.82L7 15"}]],Jr=[["path",{d:"M10 4.5V4a2 2 0 0 0-2.41-1.957"}],["path",{d:"M13.9 8.4a2 2 0 0 0-1.26-1.295"}],["path",{d:"M21.7 16.2A8 8 0 0 0 22 14v-3a2 2 0 1 0-4 0v-1a2 2 0 0 0-3.63-1.158"}],["path",{d:"m7 15-1.8-1.8a2 2 0 0 0-2.79 2.86L6 19.7a7.74 7.74 0 0 0 6 2.3h2a8 8 0 0 0 5.657-2.343"}],["path",{d:"M6 6v8"}],["path",{d:"m2 2 20 20"}]],Yr=[["path",{d:"M18 8a2 2 0 0 0 0-4 2 2 0 0 0-4 0 2 2 0 0 0-4 0 2 2 0 0 0-4 0 2 2 0 0 0 0 4"}],["path",{d:"M10 22 9 8"}],["path",{d:"m14 22 1-14"}],["path",{d:"M20 8c.5 0 .9.4.8 1l-2.6 12c-.1.5-.7 1-1.2 1H7c-.6 0-1.1-.4-1.2-1L3.2 9c-.1-.6.3-1 .8-1Z"}]],_r=[["path",{d:"M18.6 14.4c.8-.8.8-2 0-2.8l-8.1-8.1a4.95 4.95 0 1 0-7.1 7.1l8.1 8.1c.9.7 2.1.7 2.9-.1Z"}],["path",{d:"m22 22-5.5-5.5"}]],xr=[["path",{d:"M18 7c0-5.333-8-5.333-8 0"}],["path",{d:"M10 7v14"}],["path",{d:"M6 21h12"}],["path",{d:"M6 13h10"}]],ao=[["path",{d:"M18.36 6.64A9 9 0 0 1 20.77 15"}],["path",{d:"M6.16 6.16a9 9 0 1 0 12.68 12.68"}],["path",{d:"M12 2v4"}],["path",{d:"m2 2 20 20"}]],to=[["path",{d:"M2 3h20"}],["path",{d:"M21 3v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V3"}],["path",{d:"m7 21 5-5 5 5"}]],ho=[["path",{d:"M12 2v10"}],["path",{d:"M18.4 6.6a9 9 0 1 1-12.77.04"}]],co=[["path",{d:"M13.5 22H7a1 1 0 0 1-1-1v-6a1 1 0 0 1 1-1h10a1 1 0 0 1 1 1v.5"}],["path",{d:"m16 19 2 2 4-4"}],["path",{d:"M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v2"}],["path",{d:"M6 9V3a1 1 0 0 1 1-1h10a1 1 0 0 1 1 1v6"}]],Mo=[["path",{d:"M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2"}],["path",{d:"M6 9V3a1 1 0 0 1 1-1h10a1 1 0 0 1 1 1v6"}],["rect",{x:"6",y:"14",width:"12",height:"8",rx:"1"}]],po=[["path",{d:"M5 7 3 5"}],["path",{d:"M9 6V3"}],["path",{d:"m13 7 2-2"}],["circle",{cx:"9",cy:"13",r:"3"}],["path",{d:"M11.83 12H20a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2v-4a2 2 0 0 1 2-2h2.17"}],["path",{d:"M16 16h2"}]],io=[["rect",{width:"20",height:"16",x:"2",y:"4",rx:"2"}],["path",{d:"M12 9v11"}],["path",{d:"M2 9h13a2 2 0 0 1 2 2v9"}]],no=[["path",{d:"M2.5 16.88a1 1 0 0 1-.32-1.43l9-13.02a1 1 0 0 1 1.64 0l9 13.01a1 1 0 0 1-.32 1.44l-8.51 4.86a2 2 0 0 1-1.98 0Z"}],["path",{d:"M12 2v20"}]],lo=[["path",{d:"M15.39 4.39a1 1 0 0 0 1.68-.474 2.5 2.5 0 1 1 3.014 3.015 1 1 0 0 0-.474 1.68l1.683 1.682a2.414 2.414 0 0 1 0 3.414L19.61 15.39a1 1 0 0 1-1.68-.474 2.5 2.5 0 1 0-3.014 3.015 1 1 0 0 1 .474 1.68l-1.683 1.682a2.414 2.414 0 0 1-3.414 0L8.61 19.61a1 1 0 0 0-1.68.474 2.5 2.5 0 1 1-3.014-3.015 1 1 0 0 0 .474-1.68l-1.683-1.682a2.414 2.414 0 0 1 0-3.414L4.39 8.61a1 1 0 0 1 1.68.474 2.5 2.5 0 1 0 3.014-3.015 1 1 0 0 1-.474-1.68l1.683-1.682a2.414 2.414 0 0 1 3.414 0z"}]],eo=[["rect",{width:"5",height:"5",x:"3",y:"3",rx:"1"}],["rect",{width:"5",height:"5",x:"16",y:"3",rx:"1"}],["rect",{width:"5",height:"5",x:"3",y:"16",rx:"1"}],["path",{d:"M21 16h-3a2 2 0 0 0-2 2v3"}],["path",{d:"M21 21v.01"}],["path",{d:"M12 7v3a2 2 0 0 1-2 2H7"}],["path",{d:"M3 12h.01"}],["path",{d:"M12 3h.01"}],["path",{d:"M12 16v.01"}],["path",{d:"M16 12h1"}],["path",{d:"M21 12v.01"}],["path",{d:"M12 21v-1"}]],ro=[["path",{d:"M16 3a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2 1 1 0 0 1 1 1v1a2 2 0 0 1-2 2 1 1 0 0 0-1 1v2a1 1 0 0 0 1 1 6 6 0 0 0 6-6V5a2 2 0 0 0-2-2z"}],["path",{d:"M5 3a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2 1 1 0 0 1 1 1v1a2 2 0 0 1-2 2 1 1 0 0 0-1 1v2a1 1 0 0 0 1 1 6 6 0 0 0 6-6V5a2 2 0 0 0-2-2z"}]],oo=[["path",{d:"M13 16a3 3 0 0 1 2.24 5"}],["path",{d:"M18 12h.01"}],["path",{d:"M18 21h-8a4 4 0 0 1-4-4 7 7 0 0 1 7-7h.2L9.6 6.4a1 1 0 1 1 2.8-2.8L15.8 7h.2c3.3 0 6 2.7 6 6v1a2 2 0 0 1-2 2h-1a3 3 0 0 0-3 3"}],["path",{d:"M20 8.54V4a2 2 0 1 0-4 0v3"}],["path",{d:"M7.612 12.524a3 3 0 1 0-1.6 4.3"}]],vo=[["path",{d:"M19.07 4.93A10 10 0 0 0 6.99 3.34"}],["path",{d:"M4 6h.01"}],["path",{d:"M2.29 9.62A10 10 0 1 0 21.31 8.35"}],["path",{d:"M16.24 7.76A6 6 0 1 0 8.23 16.67"}],["path",{d:"M12 18h.01"}],["path",{d:"M17.99 11.66A6 6 0 0 1 15.77 16.67"}],["circle",{cx:"12",cy:"12",r:"2"}],["path",{d:"m13.41 10.59 5.66-5.66"}]],$o=[["path",{d:"M12 12h.01"}],["path",{d:"M14 15.4641a4 4 0 0 1-4 0L7.52786 19.74597 A 1 1 0 0 0 7.99303 21.16211 10 10 0 0 0 16.00697 21.16211 1 1 0 0 0 16.47214 19.74597z"}],["path",{d:"M16 12a4 4 0 0 0-2-3.464l2.472-4.282a1 1 0 0 1 1.46-.305 10 10 0 0 1 4.006 6.94A1 1 0 0 1 21 12z"}],["path",{d:"M8 12a4 4 0 0 1 2-3.464L7.528 4.254a1 1 0 0 0-1.46-.305 10 10 0 0 0-4.006 6.94A1 1 0 0 0 3 12z"}]],mo=[["path",{d:"M5 16v2"}],["path",{d:"M19 16v2"}],["rect",{width:"20",height:"8",x:"2",y:"8",rx:"2"}],["path",{d:"M18 12h.01"}]],yo=[["path",{d:"M3 12h3.28a1 1 0 0 1 .948.684l2.298 7.934a.5.5 0 0 0 .96-.044L13.82 4.771A1 1 0 0 1 14.792 4H21"}]],so=[["path",{d:"M4.9 16.1C1 12.2 1 5.8 4.9 1.9"}],["path",{d:"M7.8 4.7a6.14 6.14 0 0 0-.8 7.5"}],["circle",{cx:"12",cy:"9",r:"2"}],["path",{d:"M16.2 4.8c2 2 2.26 5.11.8 7.47"}],["path",{d:"M19.1 1.9a9.96 9.96 0 0 1 0 14.1"}],["path",{d:"M9.5 18h5"}],["path",{d:"m8 22 4-11 4 11"}]],go=[["path",{d:"M16.247 7.761a6 6 0 0 1 0 8.478"}],["path",{d:"M19.075 4.933a10 10 0 0 1 0 14.134"}],["path",{d:"M4.925 19.067a10 10 0 0 1 0-14.134"}],["path",{d:"M7.753 16.239a6 6 0 0 1 0-8.478"}],["circle",{cx:"12",cy:"12",r:"2"}]],uo=[["path",{d:"M20.34 17.52a10 10 0 1 0-2.82 2.82"}],["circle",{cx:"19",cy:"19",r:"2"}],["path",{d:"m13.41 13.41 4.18 4.18"}],["circle",{cx:"12",cy:"12",r:"2"}]],Co=[["path",{d:"M5 15h14"}],["path",{d:"M5 9h14"}],["path",{d:"m14 20-5-5 6-6-5-5"}]],Ho=[["path",{d:"M22 17a10 10 0 0 0-20 0"}],["path",{d:"M6 17a6 6 0 0 1 12 0"}],["path",{d:"M10 17a2 2 0 0 1 4 0"}]],Ao=[["path",{d:"M13 22H4a2 2 0 0 1 0-4h12"}],["path",{d:"M13.236 18a3 3 0 0 0-2.2-5"}],["path",{d:"M16 9h.01"}],["path",{d:"M16.82 3.94a3 3 0 1 1 3.237 4.868l1.815 2.587a1.5 1.5 0 0 1-1.5 2.1l-2.872-.453a3 3 0 0 0-3.5 3"}],["path",{d:"M17 4.988a3 3 0 1 0-5.2 2.052A7 7 0 0 0 4 14.015 4 4 0 0 0 8 18"}]],wo=[["rect",{width:"12",height:"20",x:"6",y:"2",rx:"2"}],["rect",{width:"20",height:"12",x:"2",y:"6",rx:"2"}]],Vo=[["path",{d:"M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"}],["path",{d:"M12 6.5v11"}],["path",{d:"M15 9.4a4 4 0 1 0 0 5.2"}]],So=[["path",{d:"M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"}],["path",{d:"M8 12h5"}],["path",{d:"M16 9.5a4 4 0 1 0 0 5.2"}]],Lo=[["path",{d:"M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"}],["path",{d:"M8 7h8"}],["path",{d:"M12 17.5 8 15h1a4 4 0 0 0 0-8"}],["path",{d:"M8 11h8"}]],fo=[["path",{d:"M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"}],["path",{d:"m12 10 3-3"}],["path",{d:"m9 7 3 3v7.5"}],["path",{d:"M9 11h6"}],["path",{d:"M9 15h6"}]],ko=[["path",{d:"M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"}],["path",{d:"M8 13h5"}],["path",{d:"M10 17V9.5a2.5 2.5 0 0 1 5 0"}],["path",{d:"M8 17h7"}]],Po=[["path",{d:"M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"}],["path",{d:"M10 17V7h5"}],["path",{d:"M10 11h4"}],["path",{d:"M8 15h5"}]],Bo=[["path",{d:"M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"}],["path",{d:"M8 15h5"}],["path",{d:"M8 11h5a2 2 0 1 0 0-4h-3v10"}]],Do=[["path",{d:"M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"}],["path",{d:"M14 8H8"}],["path",{d:"M16 12H8"}],["path",{d:"M13 16H8"}]],Fo=[["path",{d:"M10 6.5v11a5.5 5.5 0 0 0 5.5-5.5"}],["path",{d:"m14 8-6 3"}],["path",{d:"M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1z"}]],zo=[["path",{d:"M4 2v20l2-1 2 1 2-1 2 1 2-1 2 1 2-1 2 1V2l-2 1-2-1-2 1-2-1-2 1-2-1-2 1Z"}],["path",{d:"M16 8h-6a2 2 0 1 0 0 4h4a2 2 0 1 1 0 4H8"}],["path",{d:"M12 17.5v-11"}]],bo=[["path",{d:"M14 4v16H3a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1z"}],["circle",{cx:"14",cy:"12",r:"8"}]],D2=[["rect",{width:"20",height:"12",x:"2",y:"6",rx:"2"}],["path",{d:"M12 12h.01"}],["path",{d:"M17 12h.01"}],["path",{d:"M7 12h.01"}]],Ro=[["path",{d:"M20 6a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-4a2 2 0 0 1-1.6-.8l-1.6-2.13a1 1 0 0 0-1.6 0L9.6 17.2A2 2 0 0 1 8 18H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2z"}]],To=[["rect",{width:"20",height:"12",x:"2",y:"6",rx:"2"}]],qo=[["rect",{width:"12",height:"20",x:"6",y:"2",rx:"2"}]],Uo=[["path",{d:"M7 19H4.815a1.83 1.83 0 0 1-1.57-.881 1.785 1.785 0 0 1-.004-1.784L7.196 9.5"}],["path",{d:"M11 19h8.203a1.83 1.83 0 0 0 1.556-.89 1.784 1.784 0 0 0 0-1.775l-1.226-2.12"}],["path",{d:"m14 16-3 3 3 3"}],["path",{d:"M8.293 13.596 7.196 9.5 3.1 10.598"}],["path",{d:"m9.344 5.811 1.093-1.892A1.83 1.83 0 0 1 11.985 3a1.784 1.784 0 0 1 1.546.888l3.943 6.843"}],["path",{d:"m13.378 9.633 4.096 1.098 1.097-4.096"}]],Oo=[["path",{d:"m15 14 5-5-5-5"}],["path",{d:"M20 9H9.5A5.5 5.5 0 0 0 4 14.5A5.5 5.5 0 0 0 9.5 20H13"}]],Zo=[["circle",{cx:"12",cy:"17",r:"1"}],["path",{d:"M21 7v6h-6"}],["path",{d:"M3 17a9 9 0 0 1 9-9 9 9 0 0 1 6 2.3l3 2.7"}]],Go=[["path",{d:"M21 7v6h-6"}],["path",{d:"M3 17a9 9 0 0 1 9-9 9 9 0 0 1 6 2.3l3 2.7"}]],Io=[["path",{d:"M21 12a9 9 0 0 0-9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"}],["path",{d:"M3 3v5h5"}],["path",{d:"M3 12a9 9 0 0 0 9 9 9.75 9.75 0 0 0 6.74-2.74L21 16"}],["path",{d:"M16 16h5v5"}]],Wo=[["path",{d:"M21 12a9 9 0 0 0-9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"}],["path",{d:"M3 3v5h5"}],["path",{d:"M3 12a9 9 0 0 0 9 9 9.75 9.75 0 0 0 6.74-2.74L21 16"}],["path",{d:"M16 16h5v5"}],["circle",{cx:"12",cy:"12",r:"1"}]],Eo=[["path",{d:"M21 8L18.74 5.74A9.75 9.75 0 0 0 12 3C11 3 10.03 3.16 9.13 3.47"}],["path",{d:"M8 16H3v5"}],["path",{d:"M3 12C3 9.51 4 7.26 5.64 5.64"}],["path",{d:"m3 16 2.26 2.26A9.75 9.75 0 0 0 12 21c2.49 0 4.74-1 6.36-2.64"}],["path",{d:"M21 12c0 1-.16 1.97-.47 2.87"}],["path",{d:"M21 3v5h-5"}],["path",{d:"M22 22 2 2"}]],Xo=[["path",{d:"M3 12a9 9 0 0 1 9-9 9.75 9.75 0 0 1 6.74 2.74L21 8"}],["path",{d:"M21 3v5h-5"}],["path",{d:"M21 12a9 9 0 0 1-9 9 9.75 9.75 0 0 1-6.74-2.74L3 16"}],["path",{d:"M8 16H3v5"}]],jo=[["path",{d:"M5 6a4 4 0 0 1 4-4h6a4 4 0 0 1 4 4v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6Z"}],["path",{d:"M5 10h14"}],["path",{d:"M15 7v6"}]],No=[["path",{d:"M17 3v10"}],["path",{d:"m12.67 5.5 8.66 5"}],["path",{d:"m12.67 10.5 8.66-5"}],["path",{d:"M9 17a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v2a2 2 0 0 0 2 2h2a2 2 0 0 0 2-2v-2z"}]],Ko=[["path",{d:"M4 7V4h16v3"}],["path",{d:"M5 20h6"}],["path",{d:"M13 4 8 20"}],["path",{d:"m15 15 5 5"}],["path",{d:"m20 15-5 5"}]],Qo=[["path",{d:"m17 2 4 4-4 4"}],["path",{d:"M3 11v-1a4 4 0 0 1 4-4h14"}],["path",{d:"m7 22-4-4 4-4"}],["path",{d:"M21 13v1a4 4 0 0 1-4 4H3"}],["path",{d:"M11 10h1v4"}]],Jo=[["path",{d:"m2 9 3-3 3 3"}],["path",{d:"M13 18H7a2 2 0 0 1-2-2V6"}],["path",{d:"m22 15-3 3-3-3"}],["path",{d:"M11 6h6a2 2 0 0 1 2 2v10"}]],Yo=[["path",{d:"m17 2 4 4-4 4"}],["path",{d:"M3 11v-1a4 4 0 0 1 4-4h14"}],["path",{d:"m7 22-4-4 4-4"}],["path",{d:"M21 13v1a4 4 0 0 1-4 4H3"}]],_o=[["path",{d:"M14 14a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2"}],["path",{d:"M14 4a2 2 0 0 1 2-2"}],["path",{d:"M16 10a2 2 0 0 1-2-2"}],["path",{d:"M20 14a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2"}],["path",{d:"M20 2a2 2 0 0 1 2 2"}],["path",{d:"M22 8a2 2 0 0 1-2 2"}],["path",{d:"m3 7 3 3 3-3"}],["path",{d:"M6 10V5a 3 3 0 0 1 3-3h1"}],["rect",{x:"2",y:"14",width:"8",height:"8",rx:"2"}]],xo=[["path",{d:"M14 4a2 2 0 0 1 2-2"}],["path",{d:"M16 10a2 2 0 0 1-2-2"}],["path",{d:"M20 2a2 2 0 0 1 2 2"}],["path",{d:"M22 8a2 2 0 0 1-2 2"}],["path",{d:"m3 7 3 3 3-3"}],["path",{d:"M6 10V5a3 3 0 0 1 3-3h1"}],["rect",{x:"2",y:"14",width:"8",height:"8",rx:"2"}]],av=[["path",{d:"m12 17-5-5 5-5"}],["path",{d:"M22 18v-2a4 4 0 0 0-4-4H7"}],["path",{d:"m7 17-5-5 5-5"}]],tv=[["path",{d:"M20 18v-2a4 4 0 0 0-4-4H4"}],["path",{d:"m9 17-5-5 5-5"}]],hv=[["path",{d:"M12 6a2 2 0 0 0-3.414-1.414l-6 6a2 2 0 0 0 0 2.828l6 6A2 2 0 0 0 12 18z"}],["path",{d:"M22 6a2 2 0 0 0-3.414-1.414l-6 6a2 2 0 0 0 0 2.828l6 6A2 2 0 0 0 22 18z"}]],dv=[["path",{d:"M12 11.22C11 9.997 10 9 10 8a2 2 0 0 1 4 0c0 1-.998 2.002-2.01 3.22"}],["path",{d:"m12 18 2.57-3.5"}],["path",{d:"M6.243 9.016a7 7 0 0 1 11.507-.009"}],["path",{d:"M9.35 14.53 12 11.22"}],["path",{d:"M9.35 14.53C7.728 12.246 6 10.221 6 7a6 5 0 0 1 12 0c-.005 3.22-1.778 5.235-3.43 7.5l3.557 4.527a1 1 0 0 1-.203 1.43l-1.894 1.36a1 1 0 0 1-1.384-.215L12 18l-2.679 3.593a1 1 0 0 1-1.39.213l-1.865-1.353a1 1 0 0 1-.203-1.422z"}]],cv=[["path",{d:"M4.5 16.5c-1.5 1.26-2 5-2 5s3.74-.5 5-2c.71-.84.7-2.13-.09-2.91a2.18 2.18 0 0 0-2.91-.09z"}],["path",{d:"m12 15-3-3a22 22 0 0 1 2-3.95A12.88 12.88 0 0 1 22 2c0 2.72-.78 7.5-6 11a22.35 22.35 0 0 1-4 2z"}],["path",{d:"M9 12H4s.55-3.03 2-4c1.62-1.08 5 0 5 0"}],["path",{d:"M12 15v5s3.03-.55 4-2c1.08-1.62 0-5 0-5"}]],Mv=[["polyline",{points:"3.5 2 6.5 12.5 18 12.5"}],["line",{x1:"9.5",x2:"5.5",y1:"12.5",y2:"20"}],["line",{x1:"15",x2:"18.5",y1:"12.5",y2:"20"}],["path",{d:"M2.75 18a13 13 0 0 0 18.5 0"}]],pv=[["path",{d:"M6 19V5"}],["path",{d:"M10 19V6.8"}],["path",{d:"M14 19v-7.8"}],["path",{d:"M18 5v4"}],["path",{d:"M18 19v-6"}],["path",{d:"M22 19V9"}],["path",{d:"M2 19V9a4 4 0 0 1 4-4c2 0 4 1.33 6 4s4 4 6 4a4 4 0 1 0-3-6.65"}]],iv=[["path",{d:"M17 10h-1a4 4 0 1 1 4-4v.534"}],["path",{d:"M17 6h1a4 4 0 0 1 1.42 7.74l-2.29.87a6 6 0 0 1-5.339-10.68l2.069-1.31"}],["path",{d:"M4.5 17c2.8-.5 4.4 0 5.5.8s1.8 2.2 2.3 3.7c-2 .4-3.5.4-4.8-.3-1.2-.6-2.3-1.9-3-4.2"}],["path",{d:"M9.77 12C4 15 2 22 2 22"}],["circle",{cx:"17",cy:"8",r:"2"}]],F2=[["path",{d:"M16.466 7.5C15.643 4.237 13.952 2 12 2 9.239 2 7 6.477 7 12s2.239 10 5 10c.342 0 .677-.069 1-.2"}],["path",{d:"m15.194 13.707 3.814 1.86-1.86 3.814"}],["path",{d:"M19 15.57c-1.804.885-4.274 1.43-7 1.43-5.523 0-10-2.239-10-5s4.477-5 10-5c4.838 0 8.873 1.718 9.8 4"}]],nv=[["path",{d:"m14.5 9.5 1 1"}],["path",{d:"m15.5 8.5-4 4"}],["path",{d:"M3 12a9 9 0 1 0 9-9 9.74 9.74 0 0 0-6.74 2.74L3 8"}],["path",{d:"M3 3v5h5"}],["circle",{cx:"10",cy:"14",r:"2"}]],lv=[["path",{d:"M20 9V7a2 2 0 0 0-2-2h-6"}],["path",{d:"m15 2-3 3 3 3"}],["path",{d:"M20 13v5a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2h2"}]],ev=[["path",{d:"M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"}],["path",{d:"M3 3v5h5"}]],rv=[["path",{d:"M12 5H6a2 2 0 0 0-2 2v3"}],["path",{d:"m9 8 3-3-3-3"}],["path",{d:"M4 14v4a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2h-2"}]],ov=[["path",{d:"M21 12a9 9 0 1 1-9-9c2.52 0 4.93 1 6.74 2.74L21 8"}],["path",{d:"M21 3v5h-5"}]],vv=[["circle",{cx:"6",cy:"19",r:"3"}],["path",{d:"M9 19h8.5c.4 0 .9-.1 1.3-.2"}],["path",{d:"M5.2 5.2A3.5 3.53 0 0 0 6.5 12H12"}],["path",{d:"m2 2 20 20"}],["path",{d:"M21 15.3a3.5 3.5 0 0 0-3.3-3.3"}],["path",{d:"M15 5h-4.3"}],["circle",{cx:"18",cy:"5",r:"3"}]],$v=[["circle",{cx:"6",cy:"19",r:"3"}],["path",{d:"M9 19h8.5a3.5 3.5 0 0 0 0-7h-11a3.5 3.5 0 0 1 0-7H15"}],["circle",{cx:"18",cy:"5",r:"3"}]],mv=[["rect",{width:"20",height:"8",x:"2",y:"14",rx:"2"}],["path",{d:"M6.01 18H6"}],["path",{d:"M10.01 18H10"}],["path",{d:"M15 10v4"}],["path",{d:"M17.84 7.17a4 4 0 0 0-5.66 0"}],["path",{d:"M20.66 4.34a8 8 0 0 0-11.31 0"}]],z2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M3 12h18"}]],b2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M21 9H3"}],["path",{d:"M21 15H3"}]],yv=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M21 7.5H3"}],["path",{d:"M21 12H3"}],["path",{d:"M21 16.5H3"}]],sv=[["path",{d:"M4 11a9 9 0 0 1 9 9"}],["path",{d:"M4 4a16 16 0 0 1 16 16"}],["circle",{cx:"5",cy:"19",r:"1"}]],gv=[["path",{d:"M12 15v-3.014"}],["path",{d:"M16 15v-3.014"}],["path",{d:"M20 6H4"}],["path",{d:"M20 8V4"}],["path",{d:"M4 8V4"}],["path",{d:"M8 15v-3.014"}],["rect",{x:"3",y:"12",width:"18",height:"7",rx:"1"}]],uv=[["path",{d:"M6 11h8a4 4 0 0 0 0-8H9v18"}],["path",{d:"M6 15h8"}]],Cv=[["path",{d:"M21.3 15.3a2.4 2.4 0 0 1 0 3.4l-2.6 2.6a2.4 2.4 0 0 1-3.4 0L2.7 8.7a2.41 2.41 0 0 1 0-3.4l2.6-2.6a2.41 2.41 0 0 1 3.4 0Z"}],["path",{d:"m14.5 12.5 2-2"}],["path",{d:"m11.5 9.5 2-2"}],["path",{d:"m8.5 6.5 2-2"}],["path",{d:"m17.5 15.5 2-2"}]],Hv=[["path",{d:"M10 2v15"}],["path",{d:"M7 22a4 4 0 0 1-4-4 1 1 0 0 1 1-1h16a1 1 0 0 1 1 1 4 4 0 0 1-4 4z"}],["path",{d:"M9.159 2.46a1 1 0 0 1 1.521-.193l9.977 8.98A1 1 0 0 1 20 13H4a1 1 0 0 1-.824-1.567z"}]],Av=[["path",{d:"M7 21h10"}],["path",{d:"M12 21a9 9 0 0 0 9-9H3a9 9 0 0 0 9 9Z"}],["path",{d:"M11.38 12a2.4 2.4 0 0 1-.4-4.77 2.4 2.4 0 0 1 3.2-2.77 2.4 2.4 0 0 1 3.47-.63 2.4 2.4 0 0 1 3.37 3.37 2.4 2.4 0 0 1-1.1 3.7 2.51 2.51 0 0 1 .03 1.1"}],["path",{d:"m13 12 4-4"}],["path",{d:"M10.9 7.25A3.99 3.99 0 0 0 4 10c0 .73.2 1.41.54 2"}]],wv=[["path",{d:"M4 10a7.31 7.31 0 0 0 10 10Z"}],["path",{d:"m9 15 3-3"}],["path",{d:"M17 13a6 6 0 0 0-6-6"}],["path",{d:"M21 13A10 10 0 0 0 11 3"}]],Vv=[["path",{d:"m2.37 11.223 8.372-6.777a2 2 0 0 1 2.516 0l8.371 6.777"}],["path",{d:"M21 15a1 1 0 0 1 1 1v2a1 1 0 0 1-1 1h-5.25"}],["path",{d:"M3 15a1 1 0 0 0-1 1v2a1 1 0 0 0 1 1h9"}],["path",{d:"m6.67 15 6.13 4.6a2 2 0 0 0 2.8-.4l3.15-4.2"}],["rect",{width:"20",height:"4",x:"2",y:"11",rx:"1"}]],Sv=[["path",{d:"m13.5 6.5-3.148-3.148a1.205 1.205 0 0 0-1.704 0L6.352 5.648a1.205 1.205 0 0 0 0 1.704L9.5 10.5"}],["path",{d:"M16.5 7.5 19 5"}],["path",{d:"m17.5 10.5 3.148 3.148a1.205 1.205 0 0 1 0 1.704l-2.296 2.296a1.205 1.205 0 0 1-1.704 0L13.5 14.5"}],["path",{d:"M9 21a6 6 0 0 0-6-6"}],["path",{d:"M9.352 10.648a1.205 1.205 0 0 0 0 1.704l2.296 2.296a1.205 1.205 0 0 0 1.704 0l4.296-4.296a1.205 1.205 0 0 0 0-1.704l-2.296-2.296a1.205 1.205 0 0 0-1.704 0z"}]],Lv=[["path",{d:"m20 19.5-5.5 1.2"}],["path",{d:"M14.5 4v11.22a1 1 0 0 0 1.242.97L20 15.2"}],["path",{d:"m2.978 19.351 5.549-1.363A2 2 0 0 0 10 16V2"}],["path",{d:"M20 10 4 13.5"}]],fv=[["path",{d:"M10 2v3a1 1 0 0 0 1 1h5"}],["path",{d:"M18 18v-6a1 1 0 0 0-1-1h-6a1 1 0 0 0-1 1v6"}],["path",{d:"M18 22H4a2 2 0 0 1-2-2V6"}],["path",{d:"M8 18a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9.172a2 2 0 0 1 1.414.586l2.828 2.828A2 2 0 0 1 22 6.828V16a2 2 0 0 1-2.01 2z"}]],kv=[["path",{d:"M13 13H8a1 1 0 0 0-1 1v7"}],["path",{d:"M14 8h1"}],["path",{d:"M17 21v-4"}],["path",{d:"m2 2 20 20"}],["path",{d:"M20.41 20.41A2 2 0 0 1 19 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 .59-1.41"}],["path",{d:"M29.5 11.5s5 5 4 5"}],["path",{d:"M9 3h6.2a2 2 0 0 1 1.4.6l3.8 3.8a2 2 0 0 1 .6 1.4V15"}]],Pv=[["path",{d:"M15.2 3a2 2 0 0 1 1.4.6l3.8 3.8a2 2 0 0 1 .6 1.4V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2z"}],["path",{d:"M17 21v-7a1 1 0 0 0-1-1H8a1 1 0 0 0-1 1v7"}],["path",{d:"M7 3v4a1 1 0 0 0 1 1h7"}]],R2=[["path",{d:"M5 7v11a1 1 0 0 0 1 1h11"}],["path",{d:"M5.293 18.707 11 13"}],["circle",{cx:"19",cy:"19",r:"2"}],["circle",{cx:"5",cy:"5",r:"2"}]],Bv=[["path",{d:"m16 16 3-8 3 8c-.87.65-1.92 1-3 1s-2.13-.35-3-1Z"}],["path",{d:"m2 16 3-8 3 8c-.87.65-1.92 1-3 1s-2.13-.35-3-1Z"}],["path",{d:"M7 21h10"}],["path",{d:"M12 3v18"}],["path",{d:"M3 7h2c2 0 5-1 7-2 2 1 5 2 7 2h2"}]],Dv=[["path",{d:"M12 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"}],["path",{d:"M14 15H9v-5"}],["path",{d:"M16 3h5v5"}],["path",{d:"M21 3 9 15"}]],Fv=[["path",{d:"M3 7V5a2 2 0 0 1 2-2h2"}],["path",{d:"M17 3h2a2 2 0 0 1 2 2v2"}],["path",{d:"M21 17v2a2 2 0 0 1-2 2h-2"}],["path",{d:"M7 21H5a2 2 0 0 1-2-2v-2"}],["path",{d:"M8 7v10"}],["path",{d:"M12 7v10"}],["path",{d:"M17 7v10"}]],zv=[["path",{d:"M3 7V5a2 2 0 0 1 2-2h2"}],["path",{d:"M17 3h2a2 2 0 0 1 2 2v2"}],["path",{d:"M21 17v2a2 2 0 0 1-2 2h-2"}],["path",{d:"M7 21H5a2 2 0 0 1-2-2v-2"}],["circle",{cx:"12",cy:"12",r:"1"}],["path",{d:"M18.944 12.33a1 1 0 0 0 0-.66 7.5 7.5 0 0 0-13.888 0 1 1 0 0 0 0 .66 7.5 7.5 0 0 0 13.888 0"}]],bv=[["path",{d:"M3 7V5a2 2 0 0 1 2-2h2"}],["path",{d:"M17 3h2a2 2 0 0 1 2 2v2"}],["path",{d:"M21 17v2a2 2 0 0 1-2 2h-2"}],["path",{d:"M7 21H5a2 2 0 0 1-2-2v-2"}],["path",{d:"M8 14s1.5 2 4 2 4-2 4-2"}],["path",{d:"M9 9h.01"}],["path",{d:"M15 9h.01"}]],Rv=[["path",{d:"M17 3h2a2 2 0 0 1 2 2v2"}],["path",{d:"M21 17v2a2 2 0 0 1-2 2h-2"}],["path",{d:"M3 7V5a2 2 0 0 1 2-2h2"}],["path",{d:"M7 21H5a2 2 0 0 1-2-2v-2"}],["path",{d:"M7.828 13.07A3 3 0 0 1 12 8.764a3 3 0 0 1 4.172 4.306l-3.447 3.62a1 1 0 0 1-1.449 0z"}]],Tv=[["path",{d:"M3 7V5a2 2 0 0 1 2-2h2"}],["path",{d:"M17 3h2a2 2 0 0 1 2 2v2"}],["path",{d:"M21 17v2a2 2 0 0 1-2 2h-2"}],["path",{d:"M7 21H5a2 2 0 0 1-2-2v-2"}],["path",{d:"M7 12h10"}]],qv=[["path",{d:"M17 12v4a1 1 0 0 1-1 1h-4"}],["path",{d:"M17 3h2a2 2 0 0 1 2 2v2"}],["path",{d:"M17 8V7"}],["path",{d:"M21 17v2a2 2 0 0 1-2 2h-2"}],["path",{d:"M3 7V5a2 2 0 0 1 2-2h2"}],["path",{d:"M7 17h.01"}],["path",{d:"M7 21H5a2 2 0 0 1-2-2v-2"}],["rect",{x:"7",y:"7",width:"5",height:"5",rx:"1"}]],Uv=[["path",{d:"M3 7V5a2 2 0 0 1 2-2h2"}],["path",{d:"M17 3h2a2 2 0 0 1 2 2v2"}],["path",{d:"M21 17v2a2 2 0 0 1-2 2h-2"}],["path",{d:"M7 21H5a2 2 0 0 1-2-2v-2"}],["path",{d:"M7 8h8"}],["path",{d:"M7 12h10"}],["path",{d:"M7 16h6"}]],Ov=[["path",{d:"M3 7V5a2 2 0 0 1 2-2h2"}],["path",{d:"M17 3h2a2 2 0 0 1 2 2v2"}],["path",{d:"M21 17v2a2 2 0 0 1-2 2h-2"}],["path",{d:"M7 21H5a2 2 0 0 1-2-2v-2"}],["circle",{cx:"12",cy:"12",r:"3"}],["path",{d:"m16 16-1.9-1.9"}]],Zv=[["path",{d:"M3 7V5a2 2 0 0 1 2-2h2"}],["path",{d:"M17 3h2a2 2 0 0 1 2 2v2"}],["path",{d:"M21 17v2a2 2 0 0 1-2 2h-2"}],["path",{d:"M7 21H5a2 2 0 0 1-2-2v-2"}]],Gv=[["path",{d:"M14 21v-3a2 2 0 0 0-4 0v3"}],["path",{d:"M18 5v16"}],["path",{d:"m4 6 7.106-3.79a2 2 0 0 1 1.788 0L20 6"}],["path",{d:"m6 11-3.52 2.147a1 1 0 0 0-.48.854V19a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-5a1 1 0 0 0-.48-.853L18 11"}],["path",{d:"M6 5v16"}],["circle",{cx:"12",cy:"9",r:"2"}]],Iv=[["path",{d:"M5.42 9.42 8 12"}],["circle",{cx:"4",cy:"8",r:"2"}],["path",{d:"m14 6-8.58 8.58"}],["circle",{cx:"4",cy:"16",r:"2"}],["path",{d:"M10.8 14.8 14 18"}],["path",{d:"M16 12h-2"}],["path",{d:"M22 12h-2"}]],Wv=[["circle",{cx:"6",cy:"6",r:"3"}],["path",{d:"M8.12 8.12 12 12"}],["path",{d:"M20 4 8.12 15.88"}],["circle",{cx:"6",cy:"18",r:"3"}],["path",{d:"M14.8 14.8 20 20"}]],Ev=[["path",{d:"M13 3H4a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-3"}],["path",{d:"M8 21h8"}],["path",{d:"M12 17v4"}],["path",{d:"m22 3-5 5"}],["path",{d:"m17 3 5 5"}]],Xv=[["path",{d:"M13 3H4a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-3"}],["path",{d:"M8 21h8"}],["path",{d:"M12 17v4"}],["path",{d:"m17 8 5-5"}],["path",{d:"M17 3h5v5"}]],jv=[["path",{d:"M15 12h-5"}],["path",{d:"M15 8h-5"}],["path",{d:"M19 17V5a2 2 0 0 0-2-2H4"}],["path",{d:"M8 21h12a2 2 0 0 0 2-2v-1a1 1 0 0 0-1-1H11a1 1 0 0 0-1 1v1a2 2 0 1 1-4 0V5a2 2 0 1 0-4 0v2a1 1 0 0 0 1 1h3"}]],Nv=[["path",{d:"M19 17V5a2 2 0 0 0-2-2H4"}],["path",{d:"M8 21h12a2 2 0 0 0 2-2v-1a1 1 0 0 0-1-1H11a1 1 0 0 0-1 1v1a2 2 0 1 1-4 0V5a2 2 0 1 0-4 0v2a1 1 0 0 0 1 1h3"}]],Kv=[["path",{d:"m8 11 2 2 4-4"}],["circle",{cx:"11",cy:"11",r:"8"}],["path",{d:"m21 21-4.3-4.3"}]],Qv=[["path",{d:"m13 13.5 2-2.5-2-2.5"}],["path",{d:"m21 21-4.3-4.3"}],["path",{d:"M9 8.5 7 11l2 2.5"}],["circle",{cx:"11",cy:"11",r:"8"}]],Jv=[["path",{d:"m13.5 8.5-5 5"}],["circle",{cx:"11",cy:"11",r:"8"}],["path",{d:"m21 21-4.3-4.3"}]],Yv=[["path",{d:"m13.5 8.5-5 5"}],["path",{d:"m8.5 8.5 5 5"}],["circle",{cx:"11",cy:"11",r:"8"}],["path",{d:"m21 21-4.3-4.3"}]],_v=[["path",{d:"m21 21-4.34-4.34"}],["circle",{cx:"11",cy:"11",r:"8"}]],xv=[["path",{d:"M16 5a4 3 0 0 0-8 0c0 4 8 3 8 7a4 3 0 0 1-8 0"}],["path",{d:"M8 19a4 3 0 0 0 8 0c0-4-8-3-8-7a4 3 0 0 1 8 0"}]],T2=[["path",{d:"M3.714 3.048a.498.498 0 0 0-.683.627l2.843 7.627a2 2 0 0 1 0 1.396l-2.842 7.627a.498.498 0 0 0 .682.627l18-8.5a.5.5 0 0 0 0-.904z"}],["path",{d:"M6 12h16"}]],a$=[["rect",{x:"14",y:"14",width:"8",height:"8",rx:"2"}],["rect",{x:"2",y:"2",width:"8",height:"8",rx:"2"}],["path",{d:"M7 14v1a2 2 0 0 0 2 2h1"}],["path",{d:"M14 7h1a2 2 0 0 1 2 2v1"}]],t$=[["path",{d:"M14.536 21.686a.5.5 0 0 0 .937-.024l6.5-19a.496.496 0 0 0-.635-.635l-19 6.5a.5.5 0 0 0-.024.937l7.93 3.18a2 2 0 0 1 1.112 1.11z"}],["path",{d:"m21.854 2.147-10.94 10.939"}]],h$=[["path",{d:"m16 16-4 4-4-4"}],["path",{d:"M3 12h18"}],["path",{d:"m8 8 4-4 4 4"}]],d$=[["path",{d:"M12 3v18"}],["path",{d:"m16 16 4-4-4-4"}],["path",{d:"m8 8-4 4 4 4"}]],c$=[["path",{d:"m10.852 14.772-.383.923"}],["path",{d:"M13.148 14.772a3 3 0 1 0-2.296-5.544l-.383-.923"}],["path",{d:"m13.148 9.228.383-.923"}],["path",{d:"m13.53 15.696-.382-.924a3 3 0 1 1-2.296-5.544"}],["path",{d:"m14.772 10.852.923-.383"}],["path",{d:"m14.772 13.148.923.383"}],["path",{d:"M4.5 10H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2h-.5"}],["path",{d:"M4.5 14H4a2 2 0 0 0-2 2v4a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-4a2 2 0 0 0-2-2h-.5"}],["path",{d:"M6 18h.01"}],["path",{d:"M6 6h.01"}],["path",{d:"m9.228 10.852-.923-.383"}],["path",{d:"m9.228 13.148-.923.383"}]],M$=[["path",{d:"M6 10H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2h-2"}],["path",{d:"M6 14H4a2 2 0 0 0-2 2v4a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-4a2 2 0 0 0-2-2h-2"}],["path",{d:"M6 6h.01"}],["path",{d:"M6 18h.01"}],["path",{d:"m13 6-4 6h6l-4 6"}]],p$=[["rect",{width:"20",height:"8",x:"2",y:"2",rx:"2",ry:"2"}],["rect",{width:"20",height:"8",x:"2",y:"14",rx:"2",ry:"2"}],["line",{x1:"6",x2:"6.01",y1:"6",y2:"6"}],["line",{x1:"6",x2:"6.01",y1:"18",y2:"18"}]],i$=[["path",{d:"M7 2h13a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2h-5"}],["path",{d:"M10 10 2.5 2.5C2 2 2 2.5 2 5v3a2 2 0 0 0 2 2h6z"}],["path",{d:"M22 17v-1a2 2 0 0 0-2-2h-1"}],["path",{d:"M4 14a2 2 0 0 0-2 2v4a2 2 0 0 0 2 2h16.5l1-.5.5.5-8-8H4z"}],["path",{d:"M6 18h.01"}],["path",{d:"m2 2 20 20"}]],n$=[["path",{d:"M14 17H5"}],["path",{d:"M19 7h-9"}],["circle",{cx:"17",cy:"17",r:"3"}],["circle",{cx:"7",cy:"7",r:"3"}]],l$=[["path",{d:"M9.671 4.136a2.34 2.34 0 0 1 4.659 0 2.34 2.34 0 0 0 3.319 1.915 2.34 2.34 0 0 1 2.33 4.033 2.34 2.34 0 0 0 0 3.831 2.34 2.34 0 0 1-2.33 4.033 2.34 2.34 0 0 0-3.319 1.915 2.34 2.34 0 0 1-4.659 0 2.34 2.34 0 0 0-3.32-1.915 2.34 2.34 0 0 1-2.33-4.033 2.34 2.34 0 0 0 0-3.831A2.34 2.34 0 0 1 6.35 6.051a2.34 2.34 0 0 0 3.319-1.915"}],["circle",{cx:"12",cy:"12",r:"3"}]],e$=[["path",{d:"M8.3 10a.7.7 0 0 1-.626-1.079L11.4 3a.7.7 0 0 1 1.198-.043L16.3 8.9a.7.7 0 0 1-.572 1.1Z"}],["rect",{x:"3",y:"14",width:"7",height:"7",rx:"1"}],["circle",{cx:"17.5",cy:"17.5",r:"3.5"}]],r$=[["circle",{cx:"18",cy:"5",r:"3"}],["circle",{cx:"6",cy:"12",r:"3"}],["circle",{cx:"18",cy:"19",r:"3"}],["line",{x1:"8.59",x2:"15.42",y1:"13.51",y2:"17.49"}],["line",{x1:"15.41",x2:"8.59",y1:"6.51",y2:"10.49"}]],o$=[["path",{d:"M12 2v13"}],["path",{d:"m16 6-4-4-4 4"}],["path",{d:"M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8"}]],v$=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2",ry:"2"}],["line",{x1:"3",x2:"21",y1:"9",y2:"9"}],["line",{x1:"3",x2:"21",y1:"15",y2:"15"}],["line",{x1:"9",x2:"9",y1:"9",y2:"21"}],["line",{x1:"15",x2:"15",y1:"9",y2:"21"}]],$$=[["path",{d:"M14 11a2 2 0 1 1-4 0 4 4 0 0 1 8 0 6 6 0 0 1-12 0 8 8 0 0 1 16 0 10 10 0 1 1-20 0 11.93 11.93 0 0 1 2.42-7.22 2 2 0 1 1 3.16 2.44"}]],m$=[["path",{d:"M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"}],["path",{d:"M12 8v4"}],["path",{d:"M12 16h.01"}]],y$=[["path",{d:"M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"}],["path",{d:"m4.243 5.21 14.39 12.472"}]],s$=[["path",{d:"M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"}],["path",{d:"m9 12 2 2 4-4"}]],g$=[["path",{d:"M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"}],["path",{d:"M8 12h.01"}],["path",{d:"M12 12h.01"}],["path",{d:"M16 12h.01"}]],u$=[["path",{d:"M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"}],["path",{d:"M12 22V2"}]],C$=[["path",{d:"M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"}],["path",{d:"M9 12h6"}]],H$=[["path",{d:"m2 2 20 20"}],["path",{d:"M5 5a1 1 0 0 0-1 1v7c0 5 3.5 7.5 7.67 8.94a1 1 0 0 0 .67.01c2.35-.82 4.48-1.97 5.9-3.71"}],["path",{d:"M9.309 3.652A12.252 12.252 0 0 0 11.24 2.28a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1v7a9.784 9.784 0 0 1-.08 1.264"}]],A$=[["path",{d:"M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"}],["path",{d:"M9 12h6"}],["path",{d:"M12 9v6"}]],w$=[["path",{d:"M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"}],["path",{d:"M6.376 18.91a6 6 0 0 1 11.249.003"}],["circle",{cx:"12",cy:"11",r:"4"}]],q2=[["path",{d:"M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"}],["path",{d:"M9.1 9a3 3 0 0 1 5.82 1c0 2-3 3-3 3"}],["path",{d:"M12 17h.01"}]],U2=[["path",{d:"M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"}],["path",{d:"m14.5 9.5-5 5"}],["path",{d:"m9.5 9.5 5 5"}]],V$=[["path",{d:"M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"}]],S$=[["path",{d:"M12 10.189V14"}],["path",{d:"M12 2v3"}],["path",{d:"M19 13V7a2 2 0 0 0-2-2H7a2 2 0 0 0-2 2v6"}],["path",{d:"M19.38 20A11.6 11.6 0 0 0 21 14l-8.188-3.639a2 2 0 0 0-1.624 0L3 14a11.6 11.6 0 0 0 2.81 7.76"}],["path",{d:"M2 21c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1s1.2 1 2.5 1c2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"}]],L$=[["path",{d:"M20.38 3.46 16 2a4 4 0 0 1-8 0L3.62 3.46a2 2 0 0 0-1.34 2.23l.58 3.47a1 1 0 0 0 .99.84H6v10c0 1.1.9 2 2 2h8a2 2 0 0 0 2-2V10h2.15a1 1 0 0 0 .99-.84l.58-3.47a2 2 0 0 0-1.34-2.23z"}]],f$=[["circle",{cx:"12",cy:"12",r:"8"}],["path",{d:"M12 2v7.5"}],["path",{d:"m19 5-5.23 5.23"}],["path",{d:"M22 12h-7.5"}],["path",{d:"m19 19-5.23-5.23"}],["path",{d:"M12 14.5V22"}],["path",{d:"M10.23 13.77 5 19"}],["path",{d:"M9.5 12H2"}],["path",{d:"M10.23 10.23 5 5"}],["circle",{cx:"12",cy:"12",r:"2.5"}]],k$=[["path",{d:"M16 10a4 4 0 0 1-8 0"}],["path",{d:"M3.103 6.034h17.794"}],["path",{d:"M3.4 5.467a2 2 0 0 0-.4 1.2V20a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V6.667a2 2 0 0 0-.4-1.2l-2-2.667A2 2 0 0 0 17 2H7a2 2 0 0 0-1.6.8z"}]],P$=[["path",{d:"m15 11-1 9"}],["path",{d:"m19 11-4-7"}],["path",{d:"M2 11h20"}],["path",{d:"m3.5 11 1.6 7.4a2 2 0 0 0 2 1.6h9.8a2 2 0 0 0 2-1.6l1.7-7.4"}],["path",{d:"M4.5 15.5h15"}],["path",{d:"m5 11 4-7"}],["path",{d:"m9 11 1 9"}]],B$=[["circle",{cx:"8",cy:"21",r:"1"}],["circle",{cx:"19",cy:"21",r:"1"}],["path",{d:"M2.05 2.05h2l2.66 12.42a2 2 0 0 0 2 1.58h9.78a2 2 0 0 0 1.95-1.57l1.65-7.43H5.12"}]],D$=[["path",{d:"M21.56 4.56a1.5 1.5 0 0 1 0 2.122l-.47.47a3 3 0 0 1-4.212-.03 3 3 0 0 1 0-4.243l.44-.44a1.5 1.5 0 0 1 2.121 0z"}],["path",{d:"M3 22a1 1 0 0 1-1-1v-3.586a1 1 0 0 1 .293-.707l3.355-3.355a1.205 1.205 0 0 1 1.704 0l3.296 3.296a1.205 1.205 0 0 1 0 1.704l-3.355 3.355a1 1 0 0 1-.707.293z"}],["path",{d:"m9 15 7.879-7.878"}]],F$=[["path",{d:"m4 4 2.5 2.5"}],["path",{d:"M13.5 6.5a4.95 4.95 0 0 0-7 7"}],["path",{d:"M15 5 5 15"}],["path",{d:"M14 17v.01"}],["path",{d:"M10 16v.01"}],["path",{d:"M13 13v.01"}],["path",{d:"M16 10v.01"}],["path",{d:"M11 20v.01"}],["path",{d:"M17 14v.01"}],["path",{d:"M20 11v.01"}]],z$=[["path",{d:"M10 22v-5"}],["path",{d:"M14 19v-2"}],["path",{d:"M14 2v4a2 2 0 0 0 2 2h4"}],["path",{d:"M18 20v-3"}],["path",{d:"M2 13h20"}],["path",{d:"M20 13V7l-5-5H6a2 2 0 0 0-2 2v9"}],["path",{d:"M6 20v-3"}]],b$=[["path",{d:"M11 12h.01"}],["path",{d:"M13 22c.5-.5 1.12-1 2.5-1-1.38 0-2-.5-2.5-1"}],["path",{d:"M14 2a3.28 3.28 0 0 1-3.227 1.798l-6.17-.561A2.387 2.387 0 1 0 4.387 8H15.5a1 1 0 0 1 0 13 1 1 0 0 0 0-5H12a7 7 0 0 1-7-7V8"}],["path",{d:"M14 8a8.5 8.5 0 0 1 0 8"}],["path",{d:"M16 16c2 0 4.5-4 4-6"}]],R$=[["path",{d:"m15 15 6 6m-6-6v4.8m0-4.8h4.8"}],["path",{d:"M9 19.8V15m0 0H4.2M9 15l-6 6"}],["path",{d:"M15 4.2V9m0 0h4.8M15 9l6-6"}],["path",{d:"M9 4.2V9m0 0H4.2M9 9 3 3"}]],T$=[["path",{d:"M18 7V5a1 1 0 0 0-1-1H6.5a.5.5 0 0 0-.4.8l4.5 6a2 2 0 0 1 0 2.4l-4.5 6a.5.5 0 0 0 .4.8H17a1 1 0 0 0 1-1v-2"}]],q$=[["path",{d:"M12 22v-5.172a2 2 0 0 0-.586-1.414L9.5 13.5"}],["path",{d:"M14.5 14.5 12 17"}],["path",{d:"M17 8.8A6 6 0 0 1 13.8 20H10A6.5 6.5 0 0 1 7 8a5 5 0 0 1 10 0z"}]],U$=[["path",{d:"m18 14 4 4-4 4"}],["path",{d:"m18 2 4 4-4 4"}],["path",{d:"M2 18h1.973a4 4 0 0 0 3.3-1.7l5.454-8.6a4 4 0 0 1 3.3-1.7H22"}],["path",{d:"M2 6h1.972a4 4 0 0 1 3.6 2.2"}],["path",{d:"M22 18h-6.041a4 4 0 0 1-3.3-1.8l-.359-.45"}]],O$=[["path",{d:"M2 20h.01"}],["path",{d:"M7 20v-4"}],["path",{d:"M12 20v-8"}],["path",{d:"M17 20V8"}]],Z$=[["path",{d:"M2 20h.01"}],["path",{d:"M7 20v-4"}]],G$=[["path",{d:"M2 20h.01"}],["path",{d:"M7 20v-4"}],["path",{d:"M12 20v-8"}]],I$=[["path",{d:"M2 20h.01"}]],W$=[["path",{d:"M2 20h.01"}],["path",{d:"M7 20v-4"}],["path",{d:"M12 20v-8"}],["path",{d:"M17 20V8"}],["path",{d:"M22 4v16"}]],E$=[["path",{d:"m21 17-2.156-1.868A.5.5 0 0 0 18 15.5v.5a1 1 0 0 1-1 1h-2a1 1 0 0 1-1-1c0-2.545-3.991-3.97-8.5-4a1 1 0 0 0 0 5c4.153 0 4.745-11.295 5.708-13.5a2.5 2.5 0 1 1 3.31 3.284"}],["path",{d:"M3 21h18"}]],X$=[["path",{d:"M10 9H4L2 7l2-2h6"}],["path",{d:"M14 5h6l2 2-2 2h-6"}],["path",{d:"M10 22V4a2 2 0 1 1 4 0v18"}],["path",{d:"M8 22h8"}]],j$=[["path",{d:"M12 13v8"}],["path",{d:"M12 3v3"}],["path",{d:"M18 6a2 2 0 0 1 1.387.56l2.307 2.22a1 1 0 0 1 0 1.44l-2.307 2.22A2 2 0 0 1 18 13H6a2 2 0 0 1-1.387-.56l-2.306-2.22a1 1 0 0 1 0-1.44l2.306-2.22A2 2 0 0 1 6 6z"}]],N$=[["path",{d:"M7 18v-6a5 5 0 1 1 10 0v6"}],["path",{d:"M5 21a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-1a2 2 0 0 0-2-2H7a2 2 0 0 0-2 2z"}],["path",{d:"M21 12h1"}],["path",{d:"M18.5 4.5 18 5"}],["path",{d:"M2 12h1"}],["path",{d:"M12 2v1"}],["path",{d:"m4.929 4.929.707.707"}],["path",{d:"M12 12v6"}]],K$=[["path",{d:"M17.971 4.285A2 2 0 0 1 21 6v12a2 2 0 0 1-3.029 1.715l-9.997-5.998a2 2 0 0 1-.003-3.432z"}],["path",{d:"M3 20V4"}]],Q$=[["path",{d:"M21 4v16"}],["path",{d:"M6.029 4.285A2 2 0 0 0 3 6v12a2 2 0 0 0 3.029 1.715l9.997-5.998a2 2 0 0 0 .003-3.432z"}]],J$=[["path",{d:"m12.5 17-.5-1-.5 1h1z"}],["path",{d:"M15 22a1 1 0 0 0 1-1v-1a2 2 0 0 0 1.56-3.25 8 8 0 1 0-11.12 0A2 2 0 0 0 8 20v1a1 1 0 0 0 1 1z"}],["circle",{cx:"15",cy:"12",r:"1"}],["circle",{cx:"9",cy:"12",r:"1"}]],Y$=[["rect",{width:"3",height:"8",x:"13",y:"2",rx:"1.5"}],["path",{d:"M19 8.5V10h1.5A1.5 1.5 0 1 0 19 8.5"}],["rect",{width:"3",height:"8",x:"8",y:"14",rx:"1.5"}],["path",{d:"M5 15.5V14H3.5A1.5 1.5 0 1 0 5 15.5"}],["rect",{width:"8",height:"3",x:"14",y:"13",rx:"1.5"}],["path",{d:"M15.5 19H14v1.5a1.5 1.5 0 1 0 1.5-1.5"}],["rect",{width:"8",height:"3",x:"2",y:"8",rx:"1.5"}],["path",{d:"M8.5 5H10V3.5A1.5 1.5 0 1 0 8.5 5"}]],_$=[["path",{d:"M22 2 2 22"}]],x$=[["path",{d:"M11 16.586V19a1 1 0 0 1-1 1H2L18.37 3.63a1 1 0 1 1 3 3l-9.663 9.663a1 1 0 0 1-1.414 0L8 14"}]],am=[["path",{d:"M10 5H3"}],["path",{d:"M12 19H3"}],["path",{d:"M14 3v4"}],["path",{d:"M16 17v4"}],["path",{d:"M21 12h-9"}],["path",{d:"M21 19h-5"}],["path",{d:"M21 5h-7"}],["path",{d:"M8 10v4"}],["path",{d:"M8 12H3"}]],O2=[["path",{d:"M10 8h4"}],["path",{d:"M12 21v-9"}],["path",{d:"M12 8V3"}],["path",{d:"M17 16h4"}],["path",{d:"M19 12V3"}],["path",{d:"M19 21v-5"}],["path",{d:"M3 14h4"}],["path",{d:"M5 10V3"}],["path",{d:"M5 21v-7"}]],tm=[["rect",{width:"7",height:"12",x:"2",y:"6",rx:"1"}],["path",{d:"M13 8.32a7.43 7.43 0 0 1 0 7.36"}],["path",{d:"M16.46 6.21a11.76 11.76 0 0 1 0 11.58"}],["path",{d:"M19.91 4.1a15.91 15.91 0 0 1 .01 15.8"}]],hm=[["rect",{width:"14",height:"20",x:"5",y:"2",rx:"2",ry:"2"}],["path",{d:"M12.667 8 10 12h4l-2.667 4"}]],dm=[["rect",{width:"14",height:"20",x:"5",y:"2",rx:"2",ry:"2"}],["path",{d:"M12 18h.01"}]],cm=[["path",{d:"M22 11v1a10 10 0 1 1-9-10"}],["path",{d:"M8 14s1.5 2 4 2 4-2 4-2"}],["line",{x1:"9",x2:"9.01",y1:"9",y2:"9"}],["line",{x1:"15",x2:"15.01",y1:"9",y2:"9"}],["path",{d:"M16 5h6"}],["path",{d:"M19 2v6"}]],Mm=[["circle",{cx:"12",cy:"12",r:"10"}],["path",{d:"M8 14s1.5 2 4 2 4-2 4-2"}],["line",{x1:"9",x2:"9.01",y1:"9",y2:"9"}],["line",{x1:"15",x2:"15.01",y1:"9",y2:"9"}]],pm=[["path",{d:"M2 13a6 6 0 1 0 12 0 4 4 0 1 0-8 0 2 2 0 0 0 4 0"}],["circle",{cx:"10",cy:"13",r:"8"}],["path",{d:"M2 21h12c4.4 0 8-3.6 8-8V7a2 2 0 1 0-4 0v6"}],["path",{d:"M18 3 19.1 5.2"}],["path",{d:"M22 3 20.9 5.2"}]],im=[["path",{d:"m10 20-1.25-2.5L6 18"}],["path",{d:"M10 4 8.75 6.5 6 6"}],["path",{d:"m14 20 1.25-2.5L18 18"}],["path",{d:"m14 4 1.25 2.5L18 6"}],["path",{d:"m17 21-3-6h-4"}],["path",{d:"m17 3-3 6 1.5 3"}],["path",{d:"M2 12h6.5L10 9"}],["path",{d:"m20 10-1.5 2 1.5 2"}],["path",{d:"M22 12h-6.5L14 15"}],["path",{d:"m4 10 1.5 2L4 14"}],["path",{d:"m7 21 3-6-1.5-3"}],["path",{d:"m7 3 3 6h4"}]],nm=[["path",{d:"M10.5 2v4"}],["path",{d:"M14 2H7a2 2 0 0 0-2 2"}],["path",{d:"M19.29 14.76A6.67 6.67 0 0 1 17 11a6.6 6.6 0 0 1-2.29 3.76c-1.15.92-1.71 2.04-1.71 3.19 0 2.22 1.8 4.05 4 4.05s4-1.83 4-4.05c0-1.16-.57-2.26-1.71-3.19"}],["path",{d:"M9.607 21H6a2 2 0 0 1-2-2v-7a2 2 0 0 1 2-2h7V7a1 1 0 0 0-1-1H9a1 1 0 0 0-1 1v3"}]],lm=[["path",{d:"M20 9V6a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v3"}],["path",{d:"M2 16a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-5a2 2 0 0 0-4 0v1.5a.5.5 0 0 1-.5.5h-11a.5.5 0 0 1-.5-.5V11a2 2 0 0 0-4 0z"}],["path",{d:"M4 18v2"}],["path",{d:"M20 18v2"}],["path",{d:"M12 4v9"}]],em=[["path",{d:"M12 21a9 9 0 0 0 9-9H3a9 9 0 0 0 9 9Z"}],["path",{d:"M7 21h10"}],["path",{d:"M19.5 12 22 6"}],["path",{d:"M16.25 3c.27.1.8.53.75 1.36-.06.83-.93 1.2-1 2.02-.05.78.34 1.24.73 1.62"}],["path",{d:"M11.25 3c.27.1.8.53.74 1.36-.05.83-.93 1.2-.98 2.02-.06.78.33 1.24.72 1.62"}],["path",{d:"M6.25 3c.27.1.8.53.75 1.36-.06.83-.93 1.2-1 2.02-.05.78.34 1.24.74 1.62"}]],rm=[["path",{d:"M12 18v4"}],["path",{d:"M2 14.499a5.5 5.5 0 0 0 9.591 3.675.6.6 0 0 1 .818.001A5.5 5.5 0 0 0 22 14.5c0-2.29-1.5-4-3-5.5l-5.492-5.312a2 2 0 0 0-3-.02L5 8.999c-1.5 1.5-3 3.2-3 5.5"}]],om=[["path",{d:"M11.017 2.814a1 1 0 0 1 1.966 0l1.051 5.558a2 2 0 0 0 1.594 1.594l5.558 1.051a1 1 0 0 1 0 1.966l-5.558 1.051a2 2 0 0 0-1.594 1.594l-1.051 5.558a1 1 0 0 1-1.966 0l-1.051-5.558a2 2 0 0 0-1.594-1.594l-5.558-1.051a1 1 0 0 1 0-1.966l5.558-1.051a2 2 0 0 0 1.594-1.594z"}]],vm=[["path",{d:"M22 17v1c0 .5-.5 1-1 1H3c-.5 0-1-.5-1-1v-1"}]],Z2=[["path",{d:"M11.017 2.814a1 1 0 0 1 1.966 0l1.051 5.558a2 2 0 0 0 1.594 1.594l5.558 1.051a1 1 0 0 1 0 1.966l-5.558 1.051a2 2 0 0 0-1.594 1.594l-1.051 5.558a1 1 0 0 1-1.966 0l-1.051-5.558a2 2 0 0 0-1.594-1.594l-5.558-1.051a1 1 0 0 1 0-1.966l5.558-1.051a2 2 0 0 0 1.594-1.594z"}],["path",{d:"M20 2v4"}],["path",{d:"M22 4h-4"}],["circle",{cx:"4",cy:"20",r:"2"}]],$m=[["rect",{width:"16",height:"20",x:"4",y:"2",rx:"2"}],["path",{d:"M12 6h.01"}],["circle",{cx:"12",cy:"14",r:"4"}],["path",{d:"M12 14h.01"}]],mm=[["path",{d:"M8.8 20v-4.1l1.9.2a2.3 2.3 0 0 0 2.164-2.1V8.3A5.37 5.37 0 0 0 2 8.25c0 2.8.656 3.054 1 4.55a5.77 5.77 0 0 1 .029 2.758L2 20"}],["path",{d:"M19.8 17.8a7.5 7.5 0 0 0 .003-10.603"}],["path",{d:"M17 15a3.5 3.5 0 0 0-.025-4.975"}]],ym=[["path",{d:"m6 16 6-12 6 12"}],["path",{d:"M8 12h8"}],["path",{d:"M4 21c1.1 0 1.1-1 2.3-1s1.1 1 2.3 1c1.1 0 1.1-1 2.3-1 1.1 0 1.1 1 2.3 1 1.1 0 1.1-1 2.3-1 1.1 0 1.1 1 2.3 1 1.1 0 1.1-1 2.3-1"}]],sm=[["path",{d:"m6 16 6-12 6 12"}],["path",{d:"M8 12h8"}],["path",{d:"m16 20 2 2 4-4"}]],gm=[["path",{d:"M12.034 12.681a.498.498 0 0 1 .647-.647l9 3.5a.5.5 0 0 1-.033.943l-3.444 1.068a1 1 0 0 0-.66.66l-1.067 3.443a.5.5 0 0 1-.943.033z"}],["path",{d:"M5 17A12 12 0 0 1 17 5"}],["circle",{cx:"19",cy:"5",r:"2"}],["circle",{cx:"5",cy:"19",r:"2"}]],um=[["circle",{cx:"19",cy:"5",r:"2"}],["circle",{cx:"5",cy:"19",r:"2"}],["path",{d:"M5 17A12 12 0 0 1 17 5"}]],Cm=[["path",{d:"M16 3h5v5"}],["path",{d:"M8 3H3v5"}],["path",{d:"M12 22v-8.3a4 4 0 0 0-1.172-2.872L3 3"}],["path",{d:"m15 9 6-6"}]],Hm=[["path",{d:"M17 13.44 4.442 17.082A2 2 0 0 0 4.982 21H19a2 2 0 0 0 .558-3.921l-1.115-.32A2 2 0 0 1 17 14.837V7.66"}],["path",{d:"m7 10.56 12.558-3.642A2 2 0 0 0 19.018 3H5a2 2 0 0 0-.558 3.921l1.115.32A2 2 0 0 1 7 9.163v7.178"}]],Am=[["path",{d:"M15.295 19.562 16 22"}],["path",{d:"m17 16 3.758 2.098"}],["path",{d:"m19 12.5 3.026-.598"}],["path",{d:"M7.61 6.3a3 3 0 0 0-3.92 1.3l-1.38 2.79a3 3 0 0 0 1.3 3.91l6.89 3.597a1 1 0 0 0 1.342-.447l3.106-6.211a1 1 0 0 0-.447-1.341z"}],["path",{d:"M8 9V2"}]],wm=[["path",{d:"M3 3h.01"}],["path",{d:"M7 5h.01"}],["path",{d:"M11 7h.01"}],["path",{d:"M3 7h.01"}],["path",{d:"M7 9h.01"}],["path",{d:"M3 11h.01"}],["rect",{width:"4",height:"4",x:"15",y:"5"}],["path",{d:"m19 9 2 2v10c0 .6-.4 1-1 1h-6c-.6 0-1-.4-1-1V11l2-2"}],["path",{d:"m13 14 8-2"}],["path",{d:"m13 19 8-2"}]],Vm=[["path",{d:"M14 9.536V7a4 4 0 0 1 4-4h1.5a.5.5 0 0 1 .5.5V5a4 4 0 0 1-4 4 4 4 0 0 0-4 4c0 2 1 3 1 5a5 5 0 0 1-1 3"}],["path",{d:"M4 9a5 5 0 0 1 8 4 5 5 0 0 1-8-4"}],["path",{d:"M5 21h14"}]],G2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M17 12h-2l-2 5-2-10-2 5H7"}]],I2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"m16 8-8 8"}],["path",{d:"M16 16H8V8"}]],W2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"m8 8 8 8"}],["path",{d:"M16 8v8H8"}]],E2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M12 8v8"}],["path",{d:"m8 12 4 4 4-4"}]],X2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"m12 8-4 4 4 4"}],["path",{d:"M16 12H8"}]],j2=[["path",{d:"M13 21h6a2 2 0 0 0 2-2V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v6"}],["path",{d:"m3 21 9-9"}],["path",{d:"M9 21H3v-6"}]],N2=[["path",{d:"M13 3h6a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-6"}],["path",{d:"m3 3 9 9"}],["path",{d:"M3 9V3h6"}]],K2=[["path",{d:"M21 11V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h6"}],["path",{d:"m21 21-9-9"}],["path",{d:"M21 15v6h-6"}]],Q2=[["path",{d:"M21 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h6"}],["path",{d:"m21 3-9 9"}],["path",{d:"M15 3h6v6"}]],J2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M8 12h8"}],["path",{d:"m12 16 4-4-4-4"}]],Y2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M8 16V8h8"}],["path",{d:"M16 16 8 8"}]],_2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M8 8h8v8"}],["path",{d:"m8 16 8-8"}]],x2=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"m16 12-4-4-4 4"}],["path",{d:"M12 16V8"}]],a0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M12 8v8"}],["path",{d:"m8.5 14 7-4"}],["path",{d:"m8.5 10 7 4"}]],t0=[["path",{d:"M4 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v16a2 2 0 0 1-2 2"}],["path",{d:"M10 22H8"}],["path",{d:"M16 22h-2"}],["circle",{cx:"8",cy:"8",r:"2"}],["path",{d:"M9.414 9.414 12 12"}],["path",{d:"M14.8 14.8 18 18"}],["circle",{cx:"8",cy:"16",r:"2"}],["path",{d:"m18 6-8.586 8.586"}]],$=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M9 8h7"}],["path",{d:"M8 12h6"}],["path",{d:"M11 16h5"}]],h0=[["path",{d:"M21 10.656V19a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h12.344"}],["path",{d:"m9 11 3 3L22 4"}]],d0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"m9 12 2 2 4-4"}]],c0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"m16 10-4 4-4-4"}]],M0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"m14 16-4-4 4-4"}]],p0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"m10 8 4 4-4 4"}]],i0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"m8 14 4-4 4 4"}]],n0=[["path",{d:"m10 9-3 3 3 3"}],["path",{d:"m14 15 3-3-3-3"}],["rect",{x:"3",y:"3",width:"18",height:"18",rx:"2"}]],Sm=[["path",{d:"M10 9.5 8 12l2 2.5"}],["path",{d:"M14 21h1"}],["path",{d:"m14 9.5 2 2.5-2 2.5"}],["path",{d:"M5 21a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2"}],["path",{d:"M9 21h1"}]],Lm=[["path",{d:"M5 21a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2"}],["path",{d:"M9 21h1"}],["path",{d:"M14 21h1"}]],l0=[["path",{d:"M8 7v7"}],["path",{d:"M12 7v4"}],["path",{d:"M16 7v9"}],["path",{d:"M5 3a2 2 0 0 0-2 2"}],["path",{d:"M9 3h1"}],["path",{d:"M14 3h1"}],["path",{d:"M19 3a2 2 0 0 1 2 2"}],["path",{d:"M21 9v1"}],["path",{d:"M21 14v1"}],["path",{d:"M21 19a2 2 0 0 1-2 2"}],["path",{d:"M14 21h1"}],["path",{d:"M9 21h1"}],["path",{d:"M5 21a2 2 0 0 1-2-2"}],["path",{d:"M3 14v1"}],["path",{d:"M3 9v1"}]],e0=[["path",{d:"M12.034 12.681a.498.498 0 0 1 .647-.647l9 3.5a.5.5 0 0 1-.033.943l-3.444 1.068a1 1 0 0 0-.66.66l-1.067 3.443a.5.5 0 0 1-.943.033z"}],["path",{d:"M5 3a2 2 0 0 0-2 2"}],["path",{d:"M19 3a2 2 0 0 1 2 2"}],["path",{d:"M5 21a2 2 0 0 1-2-2"}],["path",{d:"M9 3h1"}],["path",{d:"M9 21h2"}],["path",{d:"M14 3h1"}],["path",{d:"M3 9v1"}],["path",{d:"M21 9v2"}],["path",{d:"M3 14v1"}]],fm=[["path",{d:"M14 21h1"}],["path",{d:"M21 14v1"}],["path",{d:"M21 19a2 2 0 0 1-2 2"}],["path",{d:"M21 9v1"}],["path",{d:"M3 14v1"}],["path",{d:"M3 5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2"}],["path",{d:"M3 9v1"}],["path",{d:"M5 21a2 2 0 0 1-2-2"}],["path",{d:"M9 21h1"}]],r0=[["path",{d:"M5 3a2 2 0 0 0-2 2"}],["path",{d:"M19 3a2 2 0 0 1 2 2"}],["path",{d:"M21 19a2 2 0 0 1-2 2"}],["path",{d:"M5 21a2 2 0 0 1-2-2"}],["path",{d:"M9 3h1"}],["path",{d:"M9 21h1"}],["path",{d:"M14 3h1"}],["path",{d:"M14 21h1"}],["path",{d:"M3 9v1"}],["path",{d:"M21 9v1"}],["path",{d:"M3 14v1"}],["path",{d:"M21 14v1"}]],o0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["circle",{cx:"12",cy:"12",r:"1"}]],v0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2",ry:"2"}],["line",{x1:"8",x2:"16",y1:"12",y2:"12"}],["line",{x1:"12",x2:"12",y1:"16",y2:"16"}],["line",{x1:"12",x2:"12",y1:"8",y2:"8"}]],$0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M7 10h10"}],["path",{d:"M7 14h10"}]],m0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2",ry:"2"}],["path",{d:"M9 17c2 0 2.8-1 2.8-2.8V10c0-2 1-3.3 3.2-3"}],["path",{d:"M9 11.2h5.7"}]],y0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M8 7v7"}],["path",{d:"M12 7v4"}],["path",{d:"M16 7v9"}]],s0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M7 7v10"}],["path",{d:"M11 7v10"}],["path",{d:"m15 7 2 10"}]],g0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M8 16V8l4 4 4-4v8"}]],u0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M7 8h10"}],["path",{d:"M7 12h10"}],["path",{d:"M7 16h10"}]],C0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M8 12h8"}]],H0=[["path",{d:"M12.034 12.681a.498.498 0 0 1 .647-.647l9 3.5a.5.5 0 0 1-.033.943l-3.444 1.068a1 1 0 0 0-.66.66l-1.067 3.443a.5.5 0 0 1-.943.033z"}],["path",{d:"M21 11V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h6"}]],A0=[["path",{d:"M3.6 3.6A2 2 0 0 1 5 3h14a2 2 0 0 1 2 2v14a2 2 0 0 1-.59 1.41"}],["path",{d:"M3 8.7V19a2 2 0 0 0 2 2h10.3"}],["path",{d:"m2 2 20 20"}],["path",{d:"M13 13a3 3 0 1 0 0-6H9v2"}],["path",{d:"M9 17v-2.3"}]],w0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M9 17V7h4a3 3 0 0 1 0 6H9"}]],km=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["line",{x1:"10",x2:"10",y1:"15",y2:"9"}],["line",{x1:"14",x2:"14",y1:"15",y2:"9"}]],p=[["path",{d:"M12 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7"}],["path",{d:"M18.375 2.625a1 1 0 0 1 3 3l-9.013 9.014a2 2 0 0 1-.853.505l-2.873.84a.5.5 0 0 1-.62-.62l.84-2.873a2 2 0 0 1 .506-.852z"}]],V0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"m15 9-6 6"}],["path",{d:"M9 9h.01"}],["path",{d:"M15 15h.01"}]],S0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M7 7h10"}],["path",{d:"M10 7v10"}],["path",{d:"M16 17a2 2 0 0 1-2-2V7"}]],L0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M12 12H9.5a2.5 2.5 0 0 1 0-5H17"}],["path",{d:"M12 7v10"}],["path",{d:"M16 7v10"}]],f0=[["rect",{x:"3",y:"3",width:"18",height:"18",rx:"2"}],["path",{d:"M9 9.003a1 1 0 0 1 1.517-.859l4.997 2.997a1 1 0 0 1 0 1.718l-4.997 2.997A1 1 0 0 1 9 14.996z"}]],k0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M8 12h8"}],["path",{d:"M12 8v8"}]],P0=[["path",{d:"M12 7v4"}],["path",{d:"M7.998 9.003a5 5 0 1 0 8-.005"}],["rect",{x:"3",y:"3",width:"18",height:"18",rx:"2"}]],Pm=[["path",{d:"M7 12h2l2 5 2-10h4"}],["rect",{x:"3",y:"3",width:"18",height:"18",rx:"2"}]],B0=[["rect",{width:"20",height:"20",x:"2",y:"2",rx:"2"}],["circle",{cx:"8",cy:"8",r:"2"}],["path",{d:"M9.414 9.414 12 12"}],["path",{d:"M14.8 14.8 18 18"}],["circle",{cx:"8",cy:"16",r:"2"}],["path",{d:"m18 6-8.586 8.586"}]],Bm=[["path",{d:"M21 11a8 8 0 0 0-8-8"}],["path",{d:"M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4"}]],D0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M16 8.9V7H8l4 5-4 5h8v-1.9"}]],F0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["line",{x1:"9",x2:"15",y1:"15",y2:"9"}]],z0=[["path",{d:"M8 19H5c-1 0-2-1-2-2V7c0-1 1-2 2-2h3"}],["path",{d:"M16 5h3c1 0 2 1 2 2v10c0 1-1 2-2 2h-3"}],["line",{x1:"12",x2:"12",y1:"4",y2:"20"}]],b0=[["path",{d:"M5 8V5c0-1 1-2 2-2h10c1 0 2 1 2 2v3"}],["path",{d:"M19 16v3c0 1-1 2-2 2H7c-1 0-2-1-2-2v-3"}],["line",{x1:"4",x2:"20",y1:"12",y2:"12"}]],Dm=[["rect",{x:"3",y:"3",width:"18",height:"18",rx:"2"}],["rect",{x:"8",y:"8",width:"8",height:"8",rx:"1"}]],Fm=[["path",{d:"M11.035 7.69a1 1 0 0 1 1.909.024l.737 1.452a1 1 0 0 0 .737.535l1.634.256a1 1 0 0 1 .588 1.806l-1.172 1.168a1 1 0 0 0-.282.866l.259 1.613a1 1 0 0 1-1.541 1.134l-1.465-.75a1 1 0 0 0-.912 0l-1.465.75a1 1 0 0 1-1.539-1.133l.258-1.613a1 1 0 0 0-.282-.866l-1.156-1.153a1 1 0 0 1 .572-1.822l1.633-.256a1 1 0 0 0 .737-.535z"}],["rect",{x:"3",y:"3",width:"18",height:"18",rx:"2"}]],zm=[["path",{d:"M4 10c-1.1 0-2-.9-2-2V4c0-1.1.9-2 2-2h4c1.1 0 2 .9 2 2"}],["path",{d:"M10 16c-1.1 0-2-.9-2-2v-4c0-1.1.9-2 2-2h4c1.1 0 2 .9 2 2"}],["rect",{width:"8",height:"8",x:"14",y:"14",rx:"2"}]],bm=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["rect",{x:"9",y:"9",width:"6",height:"6",rx:"1"}]],R0=[["path",{d:"m7 11 2-2-2-2"}],["path",{d:"M11 13h4"}],["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2",ry:"2"}]],T0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["circle",{cx:"12",cy:"10",r:"3"}],["path",{d:"M7 21v-2a2 2 0 0 1 2-2h6a2 2 0 0 1 2 2v2"}]],q0=[["path",{d:"M18 21a6 6 0 0 0-12 0"}],["circle",{cx:"12",cy:"11",r:"4"}],["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}]],U0=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2",ry:"2"}],["path",{d:"m15 9-6 6"}],["path",{d:"m9 9 6 6"}]],Rm=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}]],Tm=[["path",{d:"M16 12v2a2 2 0 0 1-2 2H9a1 1 0 0 0-1 1v3a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V10a2 2 0 0 0-2-2h0"}],["path",{d:"M4 16a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v3a1 1 0 0 1-1 1h-5a2 2 0 0 0-2 2v2"}]],qm=[["path",{d:"M10 22a2 2 0 0 1-2-2"}],["path",{d:"M14 2a2 2 0 0 1 2 2"}],["path",{d:"M16 22h-2"}],["path",{d:"M2 10V8"}],["path",{d:"M2 4a2 2 0 0 1 2-2"}],["path",{d:"M20 8a2 2 0 0 1 2 2"}],["path",{d:"M22 14v2"}],["path",{d:"M22 20a2 2 0 0 1-2 2"}],["path",{d:"M4 16a2 2 0 0 1-2-2"}],["path",{d:"M8 10a2 2 0 0 1 2-2h5a1 1 0 0 1 1 1v5a2 2 0 0 1-2 2H9a1 1 0 0 1-1-1z"}],["path",{d:"M8 2h2"}]],Um=[["path",{d:"M10 22a2 2 0 0 1-2-2"}],["path",{d:"M16 22h-2"}],["path",{d:"M16 4a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v10a2 2 0 0 0 2 2h3a1 1 0 0 0 1-1v-5a2 2 0 0 1 2-2h5a1 1 0 0 0 1-1z"}],["path",{d:"M20 8a2 2 0 0 1 2 2"}],["path",{d:"M22 14v2"}],["path",{d:"M22 20a2 2 0 0 1-2 2"}]],Om=[["path",{d:"M4 16a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2v3a1 1 0 0 0 1 1h3a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H10a2 2 0 0 1-2-2v-3a1 1 0 0 0-1-1z"}]],Zm=[["path",{d:"M13.77 3.043a34 34 0 0 0-3.54 0"}],["path",{d:"M13.771 20.956a33 33 0 0 1-3.541.001"}],["path",{d:"M20.18 17.74c-.51 1.15-1.29 1.93-2.439 2.44"}],["path",{d:"M20.18 6.259c-.51-1.148-1.291-1.929-2.44-2.438"}],["path",{d:"M20.957 10.23a33 33 0 0 1 0 3.54"}],["path",{d:"M3.043 10.23a34 34 0 0 0 .001 3.541"}],["path",{d:"M6.26 20.179c-1.15-.508-1.93-1.29-2.44-2.438"}],["path",{d:"M6.26 3.82c-1.149.51-1.93 1.291-2.44 2.44"}]],Gm=[["path",{d:"M12 3c7.2 0 9 1.8 9 9s-1.8 9-9 9-9-1.8-9-9 1.8-9 9-9"}]],Im=[["path",{d:"M15.236 22a3 3 0 0 0-2.2-5"}],["path",{d:"M16 20a3 3 0 0 1 3-3h1a2 2 0 0 0 2-2v-2a4 4 0 0 0-4-4V4"}],["path",{d:"M18 13h.01"}],["path",{d:"M18 6a4 4 0 0 0-4 4 7 7 0 0 0-7 7c0-5 4-5 4-10.5a4.5 4.5 0 1 0-9 0 2.5 2.5 0 0 0 5 0C7 10 3 11 3 17c0 2.8 2.2 5 5 5h10"}]],Wm=[["path",{d:"M14 13V8.5C14 7 15 7 15 5a3 3 0 0 0-6 0c0 2 1 2 1 3.5V13"}],["path",{d:"M20 15.5a2.5 2.5 0 0 0-2.5-2.5h-11A2.5 2.5 0 0 0 4 15.5V17a1 1 0 0 0 1 1h14a1 1 0 0 0 1-1z"}],["path",{d:"M5 22h14"}]],Em=[["path",{d:"M12 18.338a2.1 2.1 0 0 0-.987.244L6.396 21.01a.53.53 0 0 1-.77-.56l.881-5.139a2.12 2.12 0 0 0-.611-1.879L2.16 9.795a.53.53 0 0 1 .294-.906l5.165-.755a2.12 2.12 0 0 0 1.597-1.16l2.309-4.679A.53.53 0 0 1 12 2"}]],Xm=[["path",{d:"M8.34 8.34 2 9.27l5 4.87L5.82 21 12 17.77 18.18 21l-.59-3.43"}],["path",{d:"M18.42 12.76 22 9.27l-6.91-1L12 2l-1.44 2.91"}],["line",{x1:"2",x2:"22",y1:"2",y2:"22"}]],jm=[["path",{d:"M11.525 2.295a.53.53 0 0 1 .95 0l2.31 4.679a2.123 2.123 0 0 0 1.595 1.16l5.166.756a.53.53 0 0 1 .294.904l-3.736 3.638a2.123 2.123 0 0 0-.611 1.878l.882 5.14a.53.53 0 0 1-.771.56l-4.618-2.428a2.122 2.122 0 0 0-1.973 0L6.396 21.01a.53.53 0 0 1-.77-.56l.881-5.139a2.122 2.122 0 0 0-.611-1.879L2.16 9.795a.53.53 0 0 1 .294-.906l5.165-.755a2.122 2.122 0 0 0 1.597-1.16z"}]],Nm=[["path",{d:"M13.971 4.285A2 2 0 0 1 17 6v12a2 2 0 0 1-3.029 1.715l-9.997-5.998a2 2 0 0 1-.003-3.432z"}],["path",{d:"M21 20V4"}]],Km=[["path",{d:"M10.029 4.285A2 2 0 0 0 7 6v12a2 2 0 0 0 3.029 1.715l9.997-5.998a2 2 0 0 0 .003-3.432z"}],["path",{d:"M3 4v16"}]],Qm=[["path",{d:"M11 2v2"}],["path",{d:"M5 2v2"}],["path",{d:"M5 3H4a2 2 0 0 0-2 2v4a6 6 0 0 0 12 0V5a2 2 0 0 0-2-2h-1"}],["path",{d:"M8 15a6 6 0 0 0 12 0v-3"}],["circle",{cx:"20",cy:"10",r:"2"}]],Jm=[["path",{d:"M15.5 3H5a2 2 0 0 0-2 2v14c0 1.1.9 2 2 2h14a2 2 0 0 0 2-2V8.5L15.5 3Z"}],["path",{d:"M14 3v4a2 2 0 0 0 2 2h4"}],["path",{d:"M8 13h.01"}],["path",{d:"M16 13h.01"}],["path",{d:"M10 16s.8 1 2 1c1.3 0 2-1 2-1"}]],Ym=[["path",{d:"M15 21v-5a1 1 0 0 0-1-1h-4a1 1 0 0 0-1 1v5"}],["path",{d:"M17.774 10.31a1.12 1.12 0 0 0-1.549 0 2.5 2.5 0 0 1-3.451 0 1.12 1.12 0 0 0-1.548 0 2.5 2.5 0 0 1-3.452 0 1.12 1.12 0 0 0-1.549 0 2.5 2.5 0 0 1-3.77-3.248l2.889-4.184A2 2 0 0 1 7 2h10a2 2 0 0 1 1.653.873l2.895 4.192a2.5 2.5 0 0 1-3.774 3.244"}],["path",{d:"M4 10.95V19a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8.05"}]],_m=[["path",{d:"M16 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V8Z"}],["path",{d:"M15 3v4a2 2 0 0 0 2 2h4"}]],xm=[["rect",{width:"20",height:"6",x:"2",y:"4",rx:"2"}],["rect",{width:"20",height:"6",x:"2",y:"14",rx:"2"}]],ay=[["rect",{width:"6",height:"20",x:"4",y:"2",rx:"2"}],["rect",{width:"6",height:"20",x:"14",y:"2",rx:"2"}]],ty=[["path",{d:"M16 4H9a3 3 0 0 0-2.83 4"}],["path",{d:"M14 12a4 4 0 0 1 0 8H6"}],["line",{x1:"4",x2:"20",y1:"12",y2:"12"}]],hy=[["path",{d:"m4 5 8 8"}],["path",{d:"m12 5-8 8"}],["path",{d:"M20 19h-4c0-1.5.44-2 1.5-2.5S20 15.33 20 14c0-.47-.17-.93-.48-1.29a2.11 2.11 0 0 0-2.62-.44c-.42.24-.74.62-.9 1.07"}]],dy=[["circle",{cx:"12",cy:"12",r:"4"}],["path",{d:"M12 3v1"}],["path",{d:"M12 20v1"}],["path",{d:"M3 12h1"}],["path",{d:"M20 12h1"}],["path",{d:"m18.364 5.636-.707.707"}],["path",{d:"m6.343 17.657-.707.707"}],["path",{d:"m5.636 5.636.707.707"}],["path",{d:"m17.657 17.657.707.707"}]],cy=[["circle",{cx:"12",cy:"12",r:"4"}],["path",{d:"M12 4h.01"}],["path",{d:"M20 12h.01"}],["path",{d:"M12 20h.01"}],["path",{d:"M4 12h.01"}],["path",{d:"M17.657 6.343h.01"}],["path",{d:"M17.657 17.657h.01"}],["path",{d:"M6.343 17.657h.01"}],["path",{d:"M6.343 6.343h.01"}]],My=[["path",{d:"M10 21v-1"}],["path",{d:"M10 4V3"}],["path",{d:"M10 9a3 3 0 0 0 0 6"}],["path",{d:"m14 20 1.25-2.5L18 18"}],["path",{d:"m14 4 1.25 2.5L18 6"}],["path",{d:"m17 21-3-6 1.5-3H22"}],["path",{d:"m17 3-3 6 1.5 3"}],["path",{d:"M2 12h1"}],["path",{d:"m20 10-1.5 2 1.5 2"}],["path",{d:"m3.64 18.36.7-.7"}],["path",{d:"m4.34 6.34-.7-.7"}]],py=[["path",{d:"M12 2v2"}],["path",{d:"M14.837 16.385a6 6 0 1 1-7.223-7.222c.624-.147.97.66.715 1.248a4 4 0 0 0 5.26 5.259c.589-.255 1.396.09 1.248.715"}],["path",{d:"M16 12a4 4 0 0 0-4-4"}],["path",{d:"m19 5-1.256 1.256"}],["path",{d:"M20 12h2"}]],iy=[["circle",{cx:"12",cy:"12",r:"4"}],["path",{d:"M12 2v2"}],["path",{d:"M12 20v2"}],["path",{d:"m4.93 4.93 1.41 1.41"}],["path",{d:"m17.66 17.66 1.41 1.41"}],["path",{d:"M2 12h2"}],["path",{d:"M20 12h2"}],["path",{d:"m6.34 17.66-1.41 1.41"}],["path",{d:"m19.07 4.93-1.41 1.41"}]],ny=[["path",{d:"M12 2v8"}],["path",{d:"m4.93 10.93 1.41 1.41"}],["path",{d:"M2 18h2"}],["path",{d:"M20 18h2"}],["path",{d:"m19.07 10.93-1.41 1.41"}],["path",{d:"M22 22H2"}],["path",{d:"m8 6 4-4 4 4"}],["path",{d:"M16 18a4 4 0 0 0-8 0"}]],ly=[["path",{d:"m4 19 8-8"}],["path",{d:"m12 19-8-8"}],["path",{d:"M20 12h-4c0-1.5.442-2 1.5-2.5S20 8.334 20 7.002c0-.472-.17-.93-.484-1.29a2.105 2.105 0 0 0-2.617-.436c-.42.239-.738.614-.899 1.06"}]],ey=[["path",{d:"M12 10V2"}],["path",{d:"m4.93 10.93 1.41 1.41"}],["path",{d:"M2 18h2"}],["path",{d:"M20 18h2"}],["path",{d:"m19.07 10.93-1.41 1.41"}],["path",{d:"M22 22H2"}],["path",{d:"m16 6-4 4-4-4"}],["path",{d:"M16 18a4 4 0 0 0-8 0"}]],ry=[["path",{d:"M11 17a4 4 0 0 1-8 0V5a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2Z"}],["path",{d:"M16.7 13H19a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2H7"}],["path",{d:"M 7 17h.01"}],["path",{d:"m11 8 2.3-2.3a2.4 2.4 0 0 1 3.404.004L18.6 7.6a2.4 2.4 0 0 1 .026 3.434L9.9 19.8"}]],oy=[["path",{d:"M10 21V3h8"}],["path",{d:"M6 16h9"}],["path",{d:"M10 9.5h7"}]],vy=[["path",{d:"M11 19H4a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2h5"}],["path",{d:"M13 5h7a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-5"}],["circle",{cx:"12",cy:"12",r:"3"}],["path",{d:"m18 22-3-3 3-3"}],["path",{d:"m6 2 3 3-3 3"}]],$y=[["polyline",{points:"14.5 17.5 3 6 3 3 6 3 17.5 14.5"}],["line",{x1:"13",x2:"19",y1:"19",y2:"13"}],["line",{x1:"16",x2:"20",y1:"16",y2:"20"}],["line",{x1:"19",x2:"21",y1:"21",y2:"19"}]],my=[["path",{d:"m18 2 4 4"}],["path",{d:"m17 7 3-3"}],["path",{d:"M19 9 8.7 19.3c-1 1-2.5 1-3.4 0l-.6-.6c-1-1-1-2.5 0-3.4L15 5"}],["path",{d:"m9 11 4 4"}],["path",{d:"m5 19-3 3"}],["path",{d:"m14 4 6 6"}]],yy=[["polyline",{points:"14.5 17.5 3 6 3 3 6 3 17.5 14.5"}],["line",{x1:"13",x2:"19",y1:"19",y2:"13"}],["line",{x1:"16",x2:"20",y1:"16",y2:"20"}],["line",{x1:"19",x2:"21",y1:"21",y2:"19"}],["polyline",{points:"14.5 6.5 18 3 21 3 21 6 17.5 9.5"}],["line",{x1:"5",x2:"9",y1:"14",y2:"18"}],["line",{x1:"7",x2:"4",y1:"17",y2:"20"}],["line",{x1:"3",x2:"5",y1:"19",y2:"21"}]],sy=[["path",{d:"M9 3H5a2 2 0 0 0-2 2v4m6-6h10a2 2 0 0 1 2 2v4M9 3v18m0 0h10a2 2 0 0 0 2-2V9M9 21H5a2 2 0 0 1-2-2V9m0 0h18"}]],gy=[["path",{d:"M12 21v-6"}],["path",{d:"M12 9V3"}],["path",{d:"M3 15h18"}],["path",{d:"M3 9h18"}],["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}]],uy=[["path",{d:"M12 15V9"}],["path",{d:"M3 15h18"}],["path",{d:"M3 9h18"}],["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}]],Cy=[["path",{d:"M14 14v2"}],["path",{d:"M14 20v2"}],["path",{d:"M14 2v2"}],["path",{d:"M14 8v2"}],["path",{d:"M2 15h8"}],["path",{d:"M2 3h6a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H2"}],["path",{d:"M2 9h8"}],["path",{d:"M22 15h-4"}],["path",{d:"M22 3h-2a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h2"}],["path",{d:"M22 9h-4"}],["path",{d:"M5 3v18"}]],Hy=[["path",{d:"M15 3v18"}],["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M21 9H3"}],["path",{d:"M21 15H3"}]],Ay=[["path",{d:"M16 5H3"}],["path",{d:"M16 12H3"}],["path",{d:"M16 19H3"}],["path",{d:"M21 5h.01"}],["path",{d:"M21 12h.01"}],["path",{d:"M21 19h.01"}]],wy=[["path",{d:"M14 10h2"}],["path",{d:"M15 22v-8"}],["path",{d:"M15 2v4"}],["path",{d:"M2 10h2"}],["path",{d:"M20 10h2"}],["path",{d:"M3 19h18"}],["path",{d:"M3 22v-6a2 2 135 0 1 2-2h14a2 2 45 0 1 2 2v6"}],["path",{d:"M3 2v2a2 2 45 0 0 2 2h14a2 2 135 0 0 2-2V2"}],["path",{d:"M8 10h2"}],["path",{d:"M9 22v-8"}],["path",{d:"M9 2v4"}]],Vy=[["path",{d:"M12 3v18"}],["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M3 9h18"}],["path",{d:"M3 15h18"}]],Sy=[["rect",{width:"10",height:"14",x:"3",y:"8",rx:"2"}],["path",{d:"M5 4a2 2 0 0 1 2-2h12a2 2 0 0 1 2 2v16a2 2 0 0 1-2 2h-2.4"}],["path",{d:"M8 18h.01"}]],Ly=[["rect",{width:"16",height:"20",x:"4",y:"2",rx:"2",ry:"2"}],["line",{x1:"12",x2:"12.01",y1:"18",y2:"18"}]],fy=[["circle",{cx:"7",cy:"7",r:"5"}],["circle",{cx:"17",cy:"17",r:"5"}],["path",{d:"M12 17h10"}],["path",{d:"m3.46 10.54 7.08-7.08"}]],ky=[["path",{d:"M12.586 2.586A2 2 0 0 0 11.172 2H4a2 2 0 0 0-2 2v7.172a2 2 0 0 0 .586 1.414l8.704 8.704a2.426 2.426 0 0 0 3.42 0l6.58-6.58a2.426 2.426 0 0 0 0-3.42z"}],["circle",{cx:"7.5",cy:"7.5",r:".5",fill:"currentColor"}]],Py=[["path",{d:"M13.172 2a2 2 0 0 1 1.414.586l6.71 6.71a2.4 2.4 0 0 1 0 3.408l-4.592 4.592a2.4 2.4 0 0 1-3.408 0l-6.71-6.71A2 2 0 0 1 6 9.172V3a1 1 0 0 1 1-1z"}],["path",{d:"M2 7v6.172a2 2 0 0 0 .586 1.414l6.71 6.71a2.4 2.4 0 0 0 3.191.193"}],["circle",{cx:"10.5",cy:"6.5",r:".5",fill:"currentColor"}]],By=[["path",{d:"M4 4v16"}]],Dy=[["path",{d:"M4 4v16"}],["path",{d:"M9 4v16"}]],Fy=[["path",{d:"M4 4v16"}],["path",{d:"M9 4v16"}],["path",{d:"M14 4v16"}]],zy=[["path",{d:"M4 4v16"}],["path",{d:"M9 4v16"}],["path",{d:"M14 4v16"}],["path",{d:"M19 4v16"}]],by=[["path",{d:"M4 4v16"}],["path",{d:"M9 4v16"}],["path",{d:"M14 4v16"}],["path",{d:"M19 4v16"}],["path",{d:"M22 6 2 18"}]],Ry=[["circle",{cx:"17",cy:"4",r:"2"}],["path",{d:"M15.59 5.41 5.41 15.59"}],["circle",{cx:"4",cy:"17",r:"2"}],["path",{d:"M12 22s-4-9-1.5-11.5S22 12 22 12"}]],Ty=[["path",{d:"m10.065 12.493-6.18 1.318a.934.934 0 0 1-1.108-.702l-.537-2.15a1.07 1.07 0 0 1 .691-1.265l13.504-4.44"}],["path",{d:"m13.56 11.747 4.332-.924"}],["path",{d:"m16 21-3.105-6.21"}],["path",{d:"M16.485 5.94a2 2 0 0 1 1.455-2.425l1.09-.272a1 1 0 0 1 1.212.727l1.515 6.06a1 1 0 0 1-.727 1.213l-1.09.272a2 2 0 0 1-2.425-1.455z"}],["path",{d:"m6.158 8.633 1.114 4.456"}],["path",{d:"m8 21 3.105-6.21"}],["circle",{cx:"12",cy:"13",r:"2"}]],qy=[["circle",{cx:"12",cy:"12",r:"10"}],["circle",{cx:"12",cy:"12",r:"6"}],["circle",{cx:"12",cy:"12",r:"2"}]],Uy=[["path",{d:"M3.5 21 14 3"}],["path",{d:"M20.5 21 10 3"}],["path",{d:"M15.5 21 12 15l-3.5 6"}],["path",{d:"M2 21h20"}]],Oy=[["circle",{cx:"4",cy:"4",r:"2"}],["path",{d:"m14 5 3-3 3 3"}],["path",{d:"m14 10 3-3 3 3"}],["path",{d:"M17 14V2"}],["path",{d:"M17 14H7l-5 8h20Z"}],["path",{d:"M8 14v8"}],["path",{d:"m9 14 5 8"}]],O0=[["path",{d:"M21 7 6.82 21.18a2.83 2.83 0 0 1-3.99-.01a2.83 2.83 0 0 1 0-4L17 3"}],["path",{d:"m16 2 6 6"}],["path",{d:"M12 16H4"}]],Zy=[["path",{d:"M12 19h8"}],["path",{d:"m4 17 6-6-6-6"}]],Gy=[["path",{d:"M14.5 2v17.5c0 1.4-1.1 2.5-2.5 2.5c-1.4 0-2.5-1.1-2.5-2.5V2"}],["path",{d:"M8.5 2h7"}],["path",{d:"M14.5 16h-5"}]],Iy=[["path",{d:"M9 2v17.5A2.5 2.5 0 0 1 6.5 22A2.5 2.5 0 0 1 4 19.5V2"}],["path",{d:"M20 2v17.5a2.5 2.5 0 0 1-2.5 2.5a2.5 2.5 0 0 1-2.5-2.5V2"}],["path",{d:"M3 2h7"}],["path",{d:"M14 2h7"}],["path",{d:"M9 16H4"}],["path",{d:"M20 16h-5"}]],Z0=[["path",{d:"M21 5H3"}],["path",{d:"M17 12H7"}],["path",{d:"M19 19H5"}]],G0=[["path",{d:"M21 5H3"}],["path",{d:"M21 12H9"}],["path",{d:"M21 19H7"}]],I0=[["path",{d:"M3 5h18"}],["path",{d:"M3 12h18"}],["path",{d:"M3 19h18"}]],m=[["path",{d:"M21 5H3"}],["path",{d:"M15 12H3"}],["path",{d:"M17 19H3"}]],Wy=[["path",{d:"M12 20h-1a2 2 0 0 1-2-2 2 2 0 0 1-2 2H6"}],["path",{d:"M13 8h7a2 2 0 0 1 2 2v4a2 2 0 0 1-2 2h-7"}],["path",{d:"M5 16H4a2 2 0 0 1-2-2v-4a2 2 0 0 1 2-2h1"}],["path",{d:"M6 4h1a2 2 0 0 1 2 2 2 2 0 0 1 2-2h1"}],["path",{d:"M9 6v12"}]],Ey=[["path",{d:"M17 22h-1a4 4 0 0 1-4-4V6a4 4 0 0 1 4-4h1"}],["path",{d:"M7 22h1a4 4 0 0 0 4-4v-1"}],["path",{d:"M7 2h1a4 4 0 0 1 4 4v1"}]],W0=[["path",{d:"M15 5h6"}],["path",{d:"M15 12h6"}],["path",{d:"M3 19h18"}],["path",{d:"m3 12 3.553-7.724a.5.5 0 0 1 .894 0L11 12"}],["path",{d:"M3.92 10h6.16"}]],Xy=[["path",{d:"M17 5H3"}],["path",{d:"M21 12H8"}],["path",{d:"M21 19H8"}],["path",{d:"M3 12v7"}]],jy=[["path",{d:"M21 5H3"}],["path",{d:"M10 12H3"}],["path",{d:"M10 19H3"}],["circle",{cx:"17",cy:"15",r:"3"}],["path",{d:"m21 19-1.9-1.9"}]],E0=[["path",{d:"M14 21h1"}],["path",{d:"M14 3h1"}],["path",{d:"M19 3a2 2 0 0 1 2 2"}],["path",{d:"M21 14v1"}],["path",{d:"M21 19a2 2 0 0 1-2 2"}],["path",{d:"M21 9v1"}],["path",{d:"M3 14v1"}],["path",{d:"M3 9v1"}],["path",{d:"M5 21a2 2 0 0 1-2-2"}],["path",{d:"M5 3a2 2 0 0 0-2 2"}],["path",{d:"M7 12h10"}],["path",{d:"M7 16h6"}],["path",{d:"M7 8h8"}],["path",{d:"M9 21h1"}],["path",{d:"M9 3h1"}]],Ny=[["path",{d:"M2 10s3-3 3-8"}],["path",{d:"M22 10s-3-3-3-8"}],["path",{d:"M10 2c0 4.4-3.6 8-8 8"}],["path",{d:"M14 2c0 4.4 3.6 8 8 8"}],["path",{d:"M2 10s2 2 2 5"}],["path",{d:"M22 10s-2 2-2 5"}],["path",{d:"M8 15h8"}],["path",{d:"M2 22v-1a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v1"}],["path",{d:"M14 22v-1a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v1"}]],X0=[["path",{d:"m16 16-3 3 3 3"}],["path",{d:"M3 12h14.5a1 1 0 0 1 0 7H13"}],["path",{d:"M3 19h6"}],["path",{d:"M3 5h18"}]],Ky=[["path",{d:"m10 20-1.25-2.5L6 18"}],["path",{d:"M10 4 8.75 6.5 6 6"}],["path",{d:"M10.585 15H10"}],["path",{d:"M2 12h6.5L10 9"}],["path",{d:"M20 14.54a4 4 0 1 1-4 0V4a2 2 0 0 1 4 0z"}],["path",{d:"m4 10 1.5 2L4 14"}],["path",{d:"m7 21 3-6-1.5-3"}],["path",{d:"m7 3 3 6h2"}]],Qy=[["path",{d:"M12 9a4 4 0 0 0-2 7.5"}],["path",{d:"M12 3v2"}],["path",{d:"m6.6 18.4-1.4 1.4"}],["path",{d:"M20 4v10.54a4 4 0 1 1-4 0V4a2 2 0 0 1 4 0Z"}],["path",{d:"M4 13H2"}],["path",{d:"M6.34 7.34 4.93 5.93"}]],Jy=[["path",{d:"M14 4v10.54a4 4 0 1 1-4 0V4a2 2 0 0 1 4 0Z"}]],Yy=[["path",{d:"M17 14V2"}],["path",{d:"M9 18.12 10 14H4.17a2 2 0 0 1-1.92-2.56l2.33-8A2 2 0 0 1 6.5 2H20a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-2.76a2 2 0 0 0-1.79 1.11L12 22a3.13 3.13 0 0 1-3-3.88Z"}]],_y=[["path",{d:"M7 10v12"}],["path",{d:"M15 5.88 14 10h5.83a2 2 0 0 1 1.92 2.56l-2.33 8A2 2 0 0 1 17.5 22H4a2 2 0 0 1-2-2v-8a2 2 0 0 1 2-2h2.76a2 2 0 0 0 1.79-1.11L12 2a3.13 3.13 0 0 1 3 3.88Z"}]],xy=[["path",{d:"M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"}],["path",{d:"m9 12 2 2 4-4"}]],as=[["path",{d:"M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"}],["path",{d:"M9 12h6"}]],ts=[["path",{d:"M2 9a3 3 0 1 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 1 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"}],["path",{d:"M9 9h.01"}],["path",{d:"m15 9-6 6"}],["path",{d:"M15 15h.01"}]],hs=[["path",{d:"M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"}],["path",{d:"M9 12h6"}],["path",{d:"M12 9v6"}]],ds=[["path",{d:"M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"}],["path",{d:"m9.5 14.5 5-5"}]],cs=[["path",{d:"M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"}],["path",{d:"m9.5 14.5 5-5"}],["path",{d:"m9.5 9.5 5 5"}]],Ms=[["path",{d:"M2 9a3 3 0 0 1 0 6v2a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-2a3 3 0 0 1 0-6V7a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2Z"}],["path",{d:"M13 5v2"}],["path",{d:"M13 17v2"}],["path",{d:"M13 11v2"}]],ps=[["path",{d:"M10.5 17h1.227a2 2 0 0 0 1.345-.52L18 12"}],["path",{d:"m12 13.5 3.75.5"}],["path",{d:"m4.5 8 10.58-5.06a1 1 0 0 1 1.342.488L18.5 8"}],["path",{d:"M6 10V8"}],["path",{d:"M6 14v1"}],["path",{d:"M6 19v2"}],["rect",{x:"2",y:"8",width:"20",height:"13",rx:"2"}]],is=[["path",{d:"m4.5 8 10.58-5.06a1 1 0 0 1 1.342.488L18.5 8"}],["path",{d:"M6 10V8"}],["path",{d:"M6 14v1"}],["path",{d:"M6 19v2"}],["rect",{x:"2",y:"8",width:"20",height:"13",rx:"2"}]],ns=[["path",{d:"M10 2h4"}],["path",{d:"M4.6 11a8 8 0 0 0 1.7 8.7 8 8 0 0 0 8.7 1.7"}],["path",{d:"M7.4 7.4a8 8 0 0 1 10.3 1 8 8 0 0 1 .9 10.2"}],["path",{d:"m2 2 20 20"}],["path",{d:"M12 12v-2"}]],ls=[["path",{d:"M10 2h4"}],["path",{d:"M12 14v-4"}],["path",{d:"M4 13a8 8 0 0 1 8-7 8 8 0 1 1-5.3 14L4 17.6"}],["path",{d:"M9 17H4v5"}]],es=[["line",{x1:"10",x2:"14",y1:"2",y2:"2"}],["line",{x1:"12",x2:"15",y1:"14",y2:"11"}],["circle",{cx:"12",cy:"14",r:"8"}]],rs=[["circle",{cx:"9",cy:"12",r:"3"}],["rect",{width:"20",height:"14",x:"2",y:"5",rx:"7"}]],os=[["circle",{cx:"15",cy:"12",r:"3"}],["rect",{width:"20",height:"14",x:"2",y:"5",rx:"7"}]],vs=[["path",{d:"M7 12h13a1 1 0 0 1 1 1 5 5 0 0 1-5 5h-.598a.5.5 0 0 0-.424.765l1.544 2.47a.5.5 0 0 1-.424.765H5.402a.5.5 0 0 1-.424-.765L7 18"}],["path",{d:"M8 18a5 5 0 0 1-5-5V4a2 2 0 0 1 2-2h8a2 2 0 0 1 2 2v8"}]],$s=[["path",{d:"M10 15h4"}],["path",{d:"m14.817 10.995-.971-1.45 1.034-1.232a2 2 0 0 0-2.025-3.238l-1.82.364L9.91 3.885a2 2 0 0 0-3.625.748L6.141 6.55l-1.725.426a2 2 0 0 0-.19 3.756l.657.27"}],["path",{d:"m18.822 10.995 2.26-5.38a1 1 0 0 0-.557-1.318L16.954 2.9a1 1 0 0 0-1.281.533l-.924 2.122"}],["path",{d:"M4 12.006A1 1 0 0 1 4.994 11H19a1 1 0 0 1 1 1v7a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2z"}]],ms=[["path",{d:"M21 4H3"}],["path",{d:"M18 8H6"}],["path",{d:"M19 12H9"}],["path",{d:"M16 16h-6"}],["path",{d:"M11 20H9"}]],ys=[["ellipse",{cx:"12",cy:"11",rx:"3",ry:"2"}],["ellipse",{cx:"12",cy:"12.5",rx:"10",ry:"8.5"}]],ss=[["path",{d:"M12 20v-6"}],["path",{d:"M19.656 14H22"}],["path",{d:"M2 14h12"}],["path",{d:"m2 2 20 20"}],["path",{d:"M20 20H4a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2"}],["path",{d:"M9.656 4H20a2 2 0 0 1 2 2v10.344"}]],gs=[["rect",{width:"20",height:"16",x:"2",y:"4",rx:"2"}],["path",{d:"M2 14h20"}],["path",{d:"M12 20v-6"}]],us=[["path",{d:"M18.2 12.27 20 6H4l1.8 6.27a1 1 0 0 0 .95.73h10.5a1 1 0 0 0 .96-.73Z"}],["path",{d:"M8 13v9"}],["path",{d:"M16 22v-9"}],["path",{d:"m9 6 1 7"}],["path",{d:"m15 6-1 7"}],["path",{d:"M12 6V2"}],["path",{d:"M13 2h-2"}]],Cs=[["rect",{width:"18",height:"12",x:"3",y:"8",rx:"1"}],["path",{d:"M10 8V5c0-.6-.4-1-1-1H6a1 1 0 0 0-1 1v3"}],["path",{d:"M19 8V5c0-.6-.4-1-1-1h-3a1 1 0 0 0-1 1v3"}]],Hs=[["path",{d:"m10 11 11 .9a1 1 0 0 1 .8 1.1l-.665 4.158a1 1 0 0 1-.988.842H20"}],["path",{d:"M16 18h-5"}],["path",{d:"M18 5a1 1 0 0 0-1 1v5.573"}],["path",{d:"M3 4h8.129a1 1 0 0 1 .99.863L13 11.246"}],["path",{d:"M4 11V4"}],["path",{d:"M7 15h.01"}],["path",{d:"M8 10.1V4"}],["circle",{cx:"18",cy:"18",r:"2"}],["circle",{cx:"7",cy:"15",r:"5"}]],As=[["path",{d:"M16.05 10.966a5 2.5 0 0 1-8.1 0"}],["path",{d:"m16.923 14.049 4.48 2.04a1 1 0 0 1 .001 1.831l-8.574 3.9a2 2 0 0 1-1.66 0l-8.574-3.91a1 1 0 0 1 0-1.83l4.484-2.04"}],["path",{d:"M16.949 14.14a5 2.5 0 1 1-9.9 0L10.063 3.5a2 2 0 0 1 3.874 0z"}],["path",{d:"M9.194 6.57a5 2.5 0 0 0 5.61 0"}]],ws=[["path",{d:"M2 22V12a10 10 0 1 1 20 0v10"}],["path",{d:"M15 6.8v1.4a3 2.8 0 1 1-6 0V6.8"}],["path",{d:"M10 15h.01"}],["path",{d:"M14 15h.01"}],["path",{d:"M10 19a4 4 0 0 1-4-4v-3a6 6 0 1 1 12 0v3a4 4 0 0 1-4 4Z"}],["path",{d:"m9 19-2 3"}],["path",{d:"m15 19 2 3"}]],Vs=[["path",{d:"M8 3.1V7a4 4 0 0 0 8 0V3.1"}],["path",{d:"m9 15-1-1"}],["path",{d:"m15 15 1-1"}],["path",{d:"M9 19c-2.8 0-5-2.2-5-5v-4a8 8 0 0 1 16 0v4c0 2.8-2.2 5-5 5Z"}],["path",{d:"m8 19-2 3"}],["path",{d:"m16 19 2 3"}]],Ss=[["path",{d:"M2 17 17 2"}],["path",{d:"m2 14 8 8"}],["path",{d:"m5 11 8 8"}],["path",{d:"m8 8 8 8"}],["path",{d:"m11 5 8 8"}],["path",{d:"m14 2 8 8"}],["path",{d:"M7 22 22 7"}]],j0=[["rect",{width:"16",height:"16",x:"4",y:"3",rx:"2"}],["path",{d:"M4 11h16"}],["path",{d:"M12 3v8"}],["path",{d:"m8 19-2 3"}],["path",{d:"m18 22-2-3"}],["path",{d:"M8 15h.01"}],["path",{d:"M16 15h.01"}]],Ls=[["path",{d:"M12 16v6"}],["path",{d:"M14 20h-4"}],["path",{d:"M18 2h4v4"}],["path",{d:"m2 2 7.17 7.17"}],["path",{d:"M2 5.355V2h3.357"}],["path",{d:"m22 2-7.17 7.17"}],["path",{d:"M8 5 5 8"}],["circle",{cx:"12",cy:"12",r:"4"}]],fs=[["path",{d:"M10 11v6"}],["path",{d:"M14 11v6"}],["path",{d:"M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6"}],["path",{d:"M3 6h18"}],["path",{d:"M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"}]],ks=[["path",{d:"M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6"}],["path",{d:"M3 6h18"}],["path",{d:"M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"}]],Ps=[["path",{d:"M8 19a4 4 0 0 1-2.24-7.32A3.5 3.5 0 0 1 9 6.03V6a3 3 0 1 1 6 0v.04a3.5 3.5 0 0 1 3.24 5.65A4 4 0 0 1 16 19Z"}],["path",{d:"M12 19v3"}]],N0=[["path",{d:"M13 8c0-2.76-2.46-5-5.5-5S2 5.24 2 8h2l1-1 1 1h4"}],["path",{d:"M13 7.14A5.82 5.82 0 0 1 16.5 6c3.04 0 5.5 2.24 5.5 5h-3l-1-1-1 1h-3"}],["path",{d:"M5.89 9.71c-2.15 2.15-2.3 5.47-.35 7.43l4.24-4.25.7-.7.71-.71 2.12-2.12c-1.95-1.96-5.27-1.8-7.42.35"}],["path",{d:"M11 15.5c.5 2.5-.17 4.5-1 6.5h4c2-5.5-.5-12-1-14"}]],Bs=[["path",{d:"m17 14 3 3.3a1 1 0 0 1-.7 1.7H4.7a1 1 0 0 1-.7-1.7L7 14h-.3a1 1 0 0 1-.7-1.7L9 9h-.2A1 1 0 0 1 8 7.3L12 3l4 4.3a1 1 0 0 1-.8 1.7H15l3 3.3a1 1 0 0 1-.7 1.7H17Z"}],["path",{d:"M12 22v-3"}]],Ds=[["path",{d:"M10 10v.2A3 3 0 0 1 8.9 16H5a3 3 0 0 1-1-5.8V10a3 3 0 0 1 6 0Z"}],["path",{d:"M7 16v6"}],["path",{d:"M13 19v3"}],["path",{d:"M12 19h8.3a1 1 0 0 0 .7-1.7L18 14h.3a1 1 0 0 0 .7-1.7L16 9h.2a1 1 0 0 0 .8-1.7L13 3l-1.4 1.5"}]],Fs=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2",ry:"2"}],["rect",{width:"3",height:"9",x:"7",y:"7"}],["rect",{width:"3",height:"5",x:"14",y:"7"}]],zs=[["path",{d:"M16 17h6v-6"}],["path",{d:"m22 17-8.5-8.5-5 5L2 7"}]],bs=[["path",{d:"M14.828 14.828 21 21"}],["path",{d:"M21 16v5h-5"}],["path",{d:"m21 3-9 9-4-4-6 6"}],["path",{d:"M21 8V3h-5"}]],Rs=[["path",{d:"M16 7h6v6"}],["path",{d:"m22 7-8.5 8.5-5-5L2 17"}]],K0=[["path",{d:"m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"}],["path",{d:"M12 9v4"}],["path",{d:"M12 17h.01"}]],Ts=[["path",{d:"M10.17 4.193a2 2 0 0 1 3.666.013"}],["path",{d:"M14 21h2"}],["path",{d:"m15.874 7.743 1 1.732"}],["path",{d:"m18.849 12.952 1 1.732"}],["path",{d:"M21.824 18.18a2 2 0 0 1-1.835 2.824"}],["path",{d:"M4.024 21a2 2 0 0 1-1.839-2.839"}],["path",{d:"m5.136 12.952-1 1.732"}],["path",{d:"M8 21h2"}],["path",{d:"m8.102 7.743-1 1.732"}]],qs=[["path",{d:"M22 18a2 2 0 0 1-2 2H3c-1.1 0-1.3-.6-.4-1.3L20.4 4.3c.9-.7 1.6-.4 1.6.7Z"}]],Us=[["path",{d:"M10 14.66v1.626a2 2 0 0 1-.976 1.696A5 5 0 0 0 7 21.978"}],["path",{d:"M14 14.66v1.626a2 2 0 0 0 .976 1.696A5 5 0 0 1 17 21.978"}],["path",{d:"M18 9h1.5a1 1 0 0 0 0-5H18"}],["path",{d:"M4 22h16"}],["path",{d:"M6 9a6 6 0 0 0 12 0V3a1 1 0 0 0-1-1H7a1 1 0 0 0-1 1z"}],["path",{d:"M6 9H4.5a1 1 0 0 1 0-5H6"}]],Os=[["path",{d:"M13.73 4a2 2 0 0 0-3.46 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3Z"}]],Zs=[["path",{d:"M14 19V7a2 2 0 0 0-2-2H9"}],["path",{d:"M15 19H9"}],["path",{d:"M19 19h2a1 1 0 0 0 1-1v-3.65a1 1 0 0 0-.22-.62L18.3 9.38a1 1 0 0 0-.78-.38H14"}],["path",{d:"M2 13v5a1 1 0 0 0 1 1h2"}],["path",{d:"M4 3 2.15 5.15a.495.495 0 0 0 .35.86h2.15a.47.47 0 0 1 .35.86L3 9.02"}],["circle",{cx:"17",cy:"19",r:"2"}],["circle",{cx:"7",cy:"19",r:"2"}]],Gs=[["path",{d:"M14 18V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v11a1 1 0 0 0 1 1h2"}],["path",{d:"M15 18H9"}],["path",{d:"M19 18h2a1 1 0 0 0 1-1v-3.65a1 1 0 0 0-.22-.624l-3.48-4.35A1 1 0 0 0 17.52 8H14"}],["circle",{cx:"17",cy:"18",r:"2"}],["circle",{cx:"7",cy:"18",r:"2"}]],Is=[["path",{d:"M15 4 5 9"}],["path",{d:"m15 8.5-10 5"}],["path",{d:"M18 12a9 9 0 0 1-9 9V3"}]],Ws=[["path",{d:"M10 12.01h.01"}],["path",{d:"M18 8v4a8 8 0 0 1-1.07 4"}],["circle",{cx:"10",cy:"12",r:"4"}],["rect",{x:"2",y:"4",width:"20",height:"16",rx:"2"}]],Es=[["path",{d:"m12 10 2 4v3a1 1 0 0 0 1 1h2a1 1 0 0 0 1-1v-3a8 8 0 1 0-16 0v3a1 1 0 0 0 1 1h2a1 1 0 0 0 1-1v-3l2-4h4Z"}],["path",{d:"M4.82 7.9 8 10"}],["path",{d:"M15.18 7.9 12 10"}],["path",{d:"M16.93 10H20a2 2 0 0 1 0 4H2"}]],Q0=[["path",{d:"M7 21h10"}],["rect",{width:"20",height:"14",x:"2",y:"3",rx:"2"}]],Xs=[["path",{d:"M15.033 9.44a.647.647 0 0 1 0 1.12l-4.065 2.352a.645.645 0 0 1-.968-.56V7.648a.645.645 0 0 1 .967-.56z"}],["path",{d:"M7 21h10"}],["rect",{width:"20",height:"14",x:"2",y:"3",rx:"2"}]],js=[["path",{d:"m17 2-5 5-5-5"}],["rect",{width:"20",height:"15",x:"2",y:"7",rx:"2"}]],Ns=[["path",{d:"M21 2H3v16h5v4l4-4h5l4-4V2zm-10 9V7m5 4V7"}]],Ks=[["path",{d:"M22 4s-.7 2.1-2 3.4c1.6 10-9.4 17.3-18 11.6 2.2.1 4.4-.6 6-2C3 15.5.5 9.6 3 5c2.2 2.6 5.6 4.1 9 4-.9-4.2 4-6.6 7-3.8 1.1 0 3-1.2 3-1.2z"}]],Qs=[["path",{d:"M14 16.5a.5.5 0 0 0 .5.5h.5a2 2 0 0 1 0 4H9a2 2 0 0 1 0-4h.5a.5.5 0 0 0 .5-.5v-9a.5.5 0 0 0-.5-.5h-3a.5.5 0 0 0-.5.5V8a2 2 0 0 1-4 0V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v3a2 2 0 0 1-4 0v-.5a.5.5 0 0 0-.5-.5h-3a.5.5 0 0 0-.5.5Z"}]],Js=[["path",{d:"M12 4v16"}],["path",{d:"M4 7V5a1 1 0 0 1 1-1h14a1 1 0 0 1 1 1v2"}],["path",{d:"M9 20h6"}]],Ys=[["path",{d:"M12 13v7a2 2 0 0 0 4 0"}],["path",{d:"M12 2v2"}],["path",{d:"M18.656 13h2.336a1 1 0 0 0 .97-1.274 10.284 10.284 0 0 0-12.07-7.51"}],["path",{d:"m2 2 20 20"}],["path",{d:"M5.961 5.957a10.28 10.28 0 0 0-3.922 5.769A1 1 0 0 0 3 13h10"}]],_s=[["path",{d:"M12 13v7a2 2 0 0 0 4 0"}],["path",{d:"M12 2v2"}],["path",{d:"M20.992 13a1 1 0 0 0 .97-1.274 10.284 10.284 0 0 0-19.923 0A1 1 0 0 0 3 13z"}]],xs=[["path",{d:"M6 4v6a6 6 0 0 0 12 0V4"}],["line",{x1:"4",x2:"20",y1:"20",y2:"20"}]],ag=[["path",{d:"M9 14 4 9l5-5"}],["path",{d:"M4 9h10.5a5.5 5.5 0 0 1 5.5 5.5a5.5 5.5 0 0 1-5.5 5.5H11"}]],tg=[["path",{d:"M21 17a9 9 0 0 0-15-6.7L3 13"}],["path",{d:"M3 7v6h6"}],["circle",{cx:"12",cy:"17",r:"1"}]],hg=[["path",{d:"M3 7v6h6"}],["path",{d:"M21 17a9 9 0 0 0-9-9 9 9 0 0 0-6 2.3L3 13"}]],dg=[["path",{d:"M16 12h6"}],["path",{d:"M8 12H2"}],["path",{d:"M12 2v2"}],["path",{d:"M12 8v2"}],["path",{d:"M12 14v2"}],["path",{d:"M12 20v2"}],["path",{d:"m19 15 3-3-3-3"}],["path",{d:"m5 9-3 3 3 3"}]],cg=[["path",{d:"M12 22v-6"}],["path",{d:"M12 8V2"}],["path",{d:"M4 12H2"}],["path",{d:"M10 12H8"}],["path",{d:"M16 12h-2"}],["path",{d:"M22 12h-2"}],["path",{d:"m15 19-3 3-3-3"}],["path",{d:"m15 5-3-3-3 3"}]],Mg=[["rect",{width:"8",height:"6",x:"5",y:"4",rx:"1"}],["rect",{width:"8",height:"6",x:"11",y:"14",rx:"1"}]],J0=[["path",{d:"M14 21v-3a2 2 0 0 0-4 0v3"}],["path",{d:"M18 12h.01"}],["path",{d:"M18 16h.01"}],["path",{d:"M22 7a1 1 0 0 0-1-1h-2a2 2 0 0 1-1.143-.359L13.143 2.36a2 2 0 0 0-2.286-.001L6.143 5.64A2 2 0 0 1 5 6H3a1 1 0 0 0-1 1v12a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2z"}],["path",{d:"M6 12h.01"}],["path",{d:"M6 16h.01"}],["circle",{cx:"12",cy:"10",r:"2"}]],pg=[["path",{d:"M15 7h2a5 5 0 0 1 0 10h-2m-6 0H7A5 5 0 0 1 7 7h2"}]],ig=[["path",{d:"m18.84 12.25 1.72-1.71h-.02a5.004 5.004 0 0 0-.12-7.07 5.006 5.006 0 0 0-6.95 0l-1.72 1.71"}],["path",{d:"m5.17 11.75-1.71 1.71a5.004 5.004 0 0 0 .12 7.07 5.006 5.006 0 0 0 6.95 0l1.71-1.71"}],["line",{x1:"8",x2:"8",y1:"2",y2:"5"}],["line",{x1:"2",x2:"5",y1:"8",y2:"8"}],["line",{x1:"16",x2:"16",y1:"19",y2:"22"}],["line",{x1:"19",x2:"22",y1:"16",y2:"16"}]],ng=[["path",{d:"m19 5 3-3"}],["path",{d:"m2 22 3-3"}],["path",{d:"M6.3 20.3a2.4 2.4 0 0 0 3.4 0L12 18l-6-6-2.3 2.3a2.4 2.4 0 0 0 0 3.4Z"}],["path",{d:"M7.5 13.5 10 11"}],["path",{d:"M10.5 16.5 13 14"}],["path",{d:"m12 6 6 6 2.3-2.3a2.4 2.4 0 0 0 0-3.4l-2.6-2.6a2.4 2.4 0 0 0-3.4 0Z"}]],lg=[["path",{d:"M12 3v12"}],["path",{d:"m17 8-5-5-5 5"}],["path",{d:"M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4"}]],eg=[["circle",{cx:"10",cy:"7",r:"1"}],["circle",{cx:"4",cy:"20",r:"1"}],["path",{d:"M4.7 19.3 19 5"}],["path",{d:"m21 3-3 1 2 2Z"}],["path",{d:"M9.26 7.68 5 12l2 5"}],["path",{d:"m10 14 5 2 3.5-3.5"}],["path",{d:"m18 12 1-1 1 1-1 1Z"}]],rg=[["path",{d:"m16 11 2 2 4-4"}],["path",{d:"M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"}],["circle",{cx:"9",cy:"7",r:"4"}]],og=[["path",{d:"M10 15H6a4 4 0 0 0-4 4v2"}],["path",{d:"m14.305 16.53.923-.382"}],["path",{d:"m15.228 13.852-.923-.383"}],["path",{d:"m16.852 12.228-.383-.923"}],["path",{d:"m16.852 17.772-.383.924"}],["path",{d:"m19.148 12.228.383-.923"}],["path",{d:"m19.53 18.696-.382-.924"}],["path",{d:"m20.772 13.852.924-.383"}],["path",{d:"m20.772 16.148.924.383"}],["circle",{cx:"18",cy:"15",r:"3"}],["circle",{cx:"9",cy:"7",r:"4"}]],vg=[["circle",{cx:"10",cy:"7",r:"4"}],["path",{d:"M10.3 15H7a4 4 0 0 0-4 4v2"}],["path",{d:"M15 15.5V14a2 2 0 0 1 4 0v1.5"}],["rect",{width:"8",height:"5",x:"13",y:"16",rx:".899"}]],$g=[["path",{d:"M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"}],["circle",{cx:"9",cy:"7",r:"4"}],["line",{x1:"22",x2:"16",y1:"11",y2:"11"}]],mg=[["path",{d:"M11.5 15H7a4 4 0 0 0-4 4v2"}],["path",{d:"M21.378 16.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"}],["circle",{cx:"10",cy:"7",r:"4"}]],yg=[["path",{d:"M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"}],["circle",{cx:"9",cy:"7",r:"4"}],["line",{x1:"19",x2:"19",y1:"8",y2:"14"}],["line",{x1:"22",x2:"16",y1:"11",y2:"11"}]],Y0=[["path",{d:"M2 21a8 8 0 0 1 13.292-6"}],["circle",{cx:"10",cy:"8",r:"5"}],["path",{d:"m16 19 2 2 4-4"}]],_0=[["path",{d:"m14.305 19.53.923-.382"}],["path",{d:"m15.228 16.852-.923-.383"}],["path",{d:"m16.852 15.228-.383-.923"}],["path",{d:"m16.852 20.772-.383.924"}],["path",{d:"m19.148 15.228.383-.923"}],["path",{d:"m19.53 21.696-.382-.924"}],["path",{d:"M2 21a8 8 0 0 1 10.434-7.62"}],["path",{d:"m20.772 16.852.924-.383"}],["path",{d:"m20.772 19.148.924.383"}],["circle",{cx:"10",cy:"8",r:"5"}],["circle",{cx:"18",cy:"18",r:"3"}]],x0=[["path",{d:"M2 21a8 8 0 0 1 13.292-6"}],["circle",{cx:"10",cy:"8",r:"5"}],["path",{d:"M22 19h-6"}]],sg=[["path",{d:"M2 21a8 8 0 0 1 10.821-7.487"}],["path",{d:"M21.378 16.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"}],["circle",{cx:"10",cy:"8",r:"5"}]],aa=[["path",{d:"M2 21a8 8 0 0 1 13.292-6"}],["circle",{cx:"10",cy:"8",r:"5"}],["path",{d:"M19 16v6"}],["path",{d:"M22 19h-6"}]],gg=[["circle",{cx:"10",cy:"8",r:"5"}],["path",{d:"M2 21a8 8 0 0 1 10.434-7.62"}],["circle",{cx:"18",cy:"18",r:"3"}],["path",{d:"m22 22-1.9-1.9"}]],ta=[["path",{d:"M2 21a8 8 0 0 1 11.873-7"}],["circle",{cx:"10",cy:"8",r:"5"}],["path",{d:"m17 17 5 5"}],["path",{d:"m22 17-5 5"}]],ha=[["circle",{cx:"12",cy:"8",r:"5"}],["path",{d:"M20 21a8 8 0 0 0-16 0"}]],ug=[["circle",{cx:"10",cy:"7",r:"4"}],["path",{d:"M10.3 15H7a4 4 0 0 0-4 4v2"}],["circle",{cx:"17",cy:"17",r:"3"}],["path",{d:"m21 21-1.9-1.9"}]],Cg=[["path",{d:"M16.051 12.616a1 1 0 0 1 1.909.024l.737 1.452a1 1 0 0 0 .737.535l1.634.256a1 1 0 0 1 .588 1.806l-1.172 1.168a1 1 0 0 0-.282.866l.259 1.613a1 1 0 0 1-1.541 1.134l-1.465-.75a1 1 0 0 0-.912 0l-1.465.75a1 1 0 0 1-1.539-1.133l.258-1.613a1 1 0 0 0-.282-.866l-1.156-1.153a1 1 0 0 1 .572-1.822l1.633-.256a1 1 0 0 0 .737-.535z"}],["path",{d:"M8 15H7a4 4 0 0 0-4 4v2"}],["circle",{cx:"10",cy:"7",r:"4"}]],Hg=[["path",{d:"M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"}],["circle",{cx:"9",cy:"7",r:"4"}],["line",{x1:"17",x2:"22",y1:"8",y2:"13"}],["line",{x1:"22",x2:"17",y1:"8",y2:"13"}]],Ag=[["path",{d:"M19 21v-2a4 4 0 0 0-4-4H9a4 4 0 0 0-4 4v2"}],["circle",{cx:"12",cy:"7",r:"4"}]],da=[["path",{d:"M18 21a8 8 0 0 0-16 0"}],["circle",{cx:"10",cy:"8",r:"5"}],["path",{d:"M22 20c0-3.37-2-6.5-4-8a5 5 0 0 0-.45-8.3"}]],wg=[["path",{d:"M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2"}],["path",{d:"M16 3.128a4 4 0 0 1 0 7.744"}],["path",{d:"M22 21v-2a4 4 0 0 0-3-3.87"}],["circle",{cx:"9",cy:"7",r:"4"}]],ca=[["path",{d:"m16 2-2.3 2.3a3 3 0 0 0 0 4.2l1.8 1.8a3 3 0 0 0 4.2 0L22 8"}],["path",{d:"M15 15 3.3 3.3a4.2 4.2 0 0 0 0 6l7.3 7.3c.7.7 2 .7 2.8 0L15 15Zm0 0 7 7"}],["path",{d:"m2.1 21.8 6.4-6.3"}],["path",{d:"m19 5-7 7"}]],Ma=[["path",{d:"M3 2v7c0 1.1.9 2 2 2h4a2 2 0 0 0 2-2V2"}],["path",{d:"M7 2v20"}],["path",{d:"M21 15V2a5 5 0 0 0-5 5v6c0 1.1.9 2 2 2h3Zm0 0v7"}]],Vg=[["path",{d:"M12 2v20"}],["path",{d:"M2 5h20"}],["path",{d:"M3 3v2"}],["path",{d:"M7 3v2"}],["path",{d:"M17 3v2"}],["path",{d:"M21 3v2"}],["path",{d:"m19 5-7 7-7-7"}]],Sg=[["path",{d:"M8 21s-4-3-4-9 4-9 4-9"}],["path",{d:"M16 3s4 3 4 9-4 9-4 9"}],["line",{x1:"15",x2:"9",y1:"9",y2:"15"}],["line",{x1:"9",x2:"15",y1:"9",y2:"15"}]],Lg=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["circle",{cx:"7.5",cy:"7.5",r:".5",fill:"currentColor"}],["path",{d:"m7.9 7.9 2.7 2.7"}],["circle",{cx:"16.5",cy:"7.5",r:".5",fill:"currentColor"}],["path",{d:"m13.4 10.6 2.7-2.7"}],["circle",{cx:"7.5",cy:"16.5",r:".5",fill:"currentColor"}],["path",{d:"m7.9 16.1 2.7-2.7"}],["circle",{cx:"16.5",cy:"16.5",r:".5",fill:"currentColor"}],["path",{d:"m13.4 13.4 2.7 2.7"}],["circle",{cx:"12",cy:"12",r:"2"}]],fg=[["path",{d:"M19.5 7a24 24 0 0 1 0 10"}],["path",{d:"M4.5 7a24 24 0 0 0 0 10"}],["path",{d:"M7 19.5a24 24 0 0 0 10 0"}],["path",{d:"M7 4.5a24 24 0 0 1 10 0"}],["rect",{x:"17",y:"17",width:"5",height:"5",rx:"1"}],["rect",{x:"17",y:"2",width:"5",height:"5",rx:"1"}],["rect",{x:"2",y:"17",width:"5",height:"5",rx:"1"}],["rect",{x:"2",y:"2",width:"5",height:"5",rx:"1"}]],kg=[["path",{d:"M16 8q6 0 6-6-6 0-6 6"}],["path",{d:"M17.41 3.59a10 10 0 1 0 3 3"}],["path",{d:"M2 2a26.6 26.6 0 0 1 10 20c.9-6.82 1.5-9.5 4-14"}]],Pg=[["path",{d:"M18 11c-1.5 0-2.5.5-3 2"}],["path",{d:"M4 6a2 2 0 0 0-2 2v4a5 5 0 0 0 5 5 8 8 0 0 1 5 2 8 8 0 0 1 5-2 5 5 0 0 0 5-5V8a2 2 0 0 0-2-2h-3a8 8 0 0 0-5 2 8 8 0 0 0-5-2z"}],["path",{d:"M6 11c1.5 0 2.5.5 3 2"}]],Bg=[["path",{d:"M10 20h4"}],["path",{d:"M12 16v6"}],["path",{d:"M17 2h4v4"}],["path",{d:"m21 2-5.46 5.46"}],["circle",{cx:"12",cy:"11",r:"5"}]],Dg=[["path",{d:"M12 15v7"}],["path",{d:"M9 19h6"}],["circle",{cx:"12",cy:"9",r:"6"}]],Fg=[["path",{d:"m2 8 2 2-2 2 2 2-2 2"}],["path",{d:"m22 8-2 2 2 2-2 2 2 2"}],["path",{d:"M8 8v10c0 .55.45 1 1 1h6c.55 0 1-.45 1-1v-2"}],["path",{d:"M16 10.34V6c0-.55-.45-1-1-1h-4.34"}],["line",{x1:"2",x2:"22",y1:"2",y2:"22"}]],zg=[["path",{d:"m2 8 2 2-2 2 2 2-2 2"}],["path",{d:"m22 8-2 2 2 2-2 2 2 2"}],["rect",{width:"8",height:"14",x:"8",y:"5",rx:"1"}]],bg=[["path",{d:"M10.66 6H14a2 2 0 0 1 2 2v2.5l5.248-3.062A.5.5 0 0 1 22 7.87v8.196"}],["path",{d:"M16 16a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h2"}],["path",{d:"m2 2 20 20"}]],Rg=[["path",{d:"m16 13 5.223 3.482a.5.5 0 0 0 .777-.416V7.87a.5.5 0 0 0-.752-.432L16 10.5"}],["rect",{x:"2",y:"6",width:"14",height:"12",rx:"2"}]],Tg=[["rect",{width:"20",height:"16",x:"2",y:"4",rx:"2"}],["path",{d:"M2 8h20"}],["circle",{cx:"8",cy:"14",r:"2"}],["path",{d:"M8 12h8"}],["circle",{cx:"16",cy:"14",r:"2"}]],qg=[["path",{d:"M21 17v2a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-2"}],["path",{d:"M21 7V5a2 2 0 0 0-2-2H5a2 2 0 0 0-2 2v2"}],["circle",{cx:"12",cy:"12",r:"1"}],["path",{d:"M18.944 12.33a1 1 0 0 0 0-.66 7.5 7.5 0 0 0-13.888 0 1 1 0 0 0 0 .66 7.5 7.5 0 0 0 13.888 0"}]],Ug=[["circle",{cx:"6",cy:"12",r:"4"}],["circle",{cx:"18",cy:"12",r:"4"}],["line",{x1:"6",x2:"18",y1:"16",y2:"16"}]],Og=[["path",{d:"M11.1 7.1a16.55 16.55 0 0 1 10.9 4"}],["path",{d:"M12 12a12.6 12.6 0 0 1-8.7 5"}],["path",{d:"M16.8 13.6a16.55 16.55 0 0 1-9 7.5"}],["path",{d:"M20.7 17a12.8 12.8 0 0 0-8.7-5 13.3 13.3 0 0 1 0-10"}],["path",{d:"M6.3 3.8a16.55 16.55 0 0 0 1.9 11.5"}],["circle",{cx:"12",cy:"12",r:"10"}]],Zg=[["path",{d:"M11 4.702a.705.705 0 0 0-1.203-.498L6.413 7.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298z"}],["path",{d:"M16 9a5 5 0 0 1 0 6"}]],Gg=[["path",{d:"M11 4.702a.705.705 0 0 0-1.203-.498L6.413 7.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298z"}],["path",{d:"M16 9a5 5 0 0 1 0 6"}],["path",{d:"M19.364 18.364a9 9 0 0 0 0-12.728"}]],Ig=[["path",{d:"M11 4.702a.705.705 0 0 0-1.203-.498L6.413 7.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298z"}],["line",{x1:"22",x2:"16",y1:"9",y2:"15"}],["line",{x1:"16",x2:"22",y1:"9",y2:"15"}]],Wg=[["path",{d:"M16 9a5 5 0 0 1 .95 2.293"}],["path",{d:"M19.364 5.636a9 9 0 0 1 1.889 9.96"}],["path",{d:"m2 2 20 20"}],["path",{d:"m7 7-.587.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298V11"}],["path",{d:"M9.828 4.172A.686.686 0 0 1 11 4.657v.686"}]],Eg=[["path",{d:"M11 4.702a.705.705 0 0 0-1.203-.498L6.413 7.587A1.4 1.4 0 0 1 5.416 8H3a1 1 0 0 0-1 1v6a1 1 0 0 0 1 1h2.416a1.4 1.4 0 0 1 .997.413l3.383 3.384A.705.705 0 0 0 11 19.298z"}]],Xg=[["path",{d:"m9 12 2 2 4-4"}],["path",{d:"M5 7c0-1.1.9-2 2-2h10a2 2 0 0 1 2 2v12H5V7Z"}],["path",{d:"M22 19H2"}]],jg=[["rect",{width:"18",height:"18",x:"3",y:"3",rx:"2"}],["path",{d:"M3 9a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2"}],["path",{d:"M3 11h3c.8 0 1.6.3 2.1.9l1.1.9c1.6 1.6 4.1 1.6 5.7 0l1.1-.9c.5-.5 1.3-.9 2.1-.9H21"}]],pa=[["path",{d:"M17 14h.01"}],["path",{d:"M7 7h12a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h14"}]],Ng=[["path",{d:"M19 7V4a1 1 0 0 0-1-1H5a2 2 0 0 0 0 4h15a1 1 0 0 1 1 1v4h-3a2 2 0 0 0 0 4h3a1 1 0 0 0 1-1v-2a1 1 0 0 0-1-1"}],["path",{d:"M3 5v14a2 2 0 0 0 2 2h15a1 1 0 0 0 1-1v-4"}]],Kg=[["path",{d:"M12 17v4"}],["path",{d:"M8 21h8"}],["path",{d:"m9 17 6.1-6.1a2 2 0 0 1 2.81.01L22 15"}],["circle",{cx:"8",cy:"9",r:"2"}],["rect",{x:"2",y:"3",width:"20",height:"14",rx:"2"}]],ia=[["path",{d:"m21.64 3.64-1.28-1.28a1.21 1.21 0 0 0-1.72 0L2.36 18.64a1.21 1.21 0 0 0 0 1.72l1.28 1.28a1.2 1.2 0 0 0 1.72 0L21.64 5.36a1.2 1.2 0 0 0 0-1.72"}],["path",{d:"m14 7 3 3"}],["path",{d:"M5 6v4"}],["path",{d:"M19 14v4"}],["path",{d:"M10 2v2"}],["path",{d:"M7 8H3"}],["path",{d:"M21 16h-4"}],["path",{d:"M11 3H9"}]],Qg=[["path",{d:"M15 4V2"}],["path",{d:"M15 16v-2"}],["path",{d:"M8 9h2"}],["path",{d:"M20 9h2"}],["path",{d:"M17.8 11.8 19 13"}],["path",{d:"M15 9h.01"}],["path",{d:"M17.8 6.2 19 5"}],["path",{d:"m3 21 9-9"}],["path",{d:"M12.2 6.2 11 5"}]],Jg=[["path",{d:"M18 21V10a1 1 0 0 0-1-1H7a1 1 0 0 0-1 1v11"}],["path",{d:"M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V8a2 2 0 0 1 1.132-1.803l7.95-3.974a2 2 0 0 1 1.837 0l7.948 3.974A2 2 0 0 1 22 8z"}],["path",{d:"M6 13h12"}],["path",{d:"M6 17h12"}]],Yg=[["path",{d:"M3 6h3"}],["path",{d:"M17 6h.01"}],["rect",{width:"18",height:"20",x:"3",y:"2",rx:"2"}],["circle",{cx:"12",cy:"13",r:"5"}],["path",{d:"M12 18a2.5 2.5 0 0 0 0-5 2.5 2.5 0 0 1 0-5"}]],_g=[["path",{d:"M12 10v2.2l1.6 1"}],["path",{d:"m16.13 7.66-.81-4.05a2 2 0 0 0-2-1.61h-2.68a2 2 0 0 0-2 1.61l-.78 4.05"}],["path",{d:"m7.88 16.36.8 4a2 2 0 0 0 2 1.61h2.72a2 2 0 0 0 2-1.61l.81-4.05"}],["circle",{cx:"12",cy:"12",r:"6"}]],xg=[["path",{d:"M19 5a2 2 0 0 0-2 2v11"}],["path",{d:"M2 18c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"}],["path",{d:"M7 13h10"}],["path",{d:"M7 9h10"}],["path",{d:"M9 5a2 2 0 0 0-2 2v11"}]],au=[["path",{d:"M2 6c.6.5 1.2 1 2.5 1C7 7 7 5 9.5 5c2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"}],["path",{d:"M2 12c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"}],["path",{d:"M2 18c.6.5 1.2 1 2.5 1 2.5 0 2.5-2 5-2 2.6 0 2.4 2 5 2 2.5 0 2.5-2 5-2 1.3 0 1.9.5 2.5 1"}]],tu=[["circle",{cx:"12",cy:"4.5",r:"2.5"}],["path",{d:"m10.2 6.3-3.9 3.9"}],["circle",{cx:"4.5",cy:"12",r:"2.5"}],["path",{d:"M7 12h10"}],["circle",{cx:"19.5",cy:"12",r:"2.5"}],["path",{d:"m13.8 17.7 3.9-3.9"}],["circle",{cx:"12",cy:"19.5",r:"2.5"}]],hu=[["circle",{cx:"12",cy:"10",r:"8"}],["circle",{cx:"12",cy:"10",r:"3"}],["path",{d:"M7 22h10"}],["path",{d:"M12 22v-4"}]],du=[["path",{d:"M17 17h-5c-1.09-.02-1.94.92-2.5 1.9A3 3 0 1 1 2.57 15"}],["path",{d:"M9 3.4a4 4 0 0 1 6.52.66"}],["path",{d:"m6 17 3.1-5.8a2.5 2.5 0 0 0 .057-2.05"}],["path",{d:"M20.3 20.3a4 4 0 0 1-2.3.7"}],["path",{d:"M18.6 13a4 4 0 0 1 3.357 3.414"}],["path",{d:"m12 6 .6 1"}],["path",{d:"m2 2 20 20"}]],cu=[["path",{d:"M18 16.98h-5.99c-1.1 0-1.95.94-2.48 1.9A4 4 0 0 1 2 17c.01-.7.2-1.4.57-2"}],["path",{d:"m6 17 3.13-5.78c.53-.97.1-2.18-.5-3.1a4 4 0 1 1 6.89-4.06"}],["path",{d:"m12 6 3.13 5.73C15.66 12.7 16.9 13 18 13a4 4 0 0 1 0 8"}]],Mu=[["circle",{cx:"12",cy:"5",r:"3"}],["path",{d:"M6.5 8a2 2 0 0 0-1.905 1.46L2.1 18.5A2 2 0 0 0 4 21h16a2 2 0 0 0 1.925-2.54L19.4 9.5A2 2 0 0 0 17.48 8Z"}]],pu=[["path",{d:"m2 22 10-10"}],["path",{d:"m16 8-1.17 1.17"}],["path",{d:"M3.47 12.53 5 11l1.53 1.53a3.5 3.5 0 0 1 0 4.94L5 19l-1.53-1.53a3.5 3.5 0 0 1 0-4.94Z"}],["path",{d:"m8 8-.53.53a3.5 3.5 0 0 0 0 4.94L9 15l1.53-1.53c.55-.55.88-1.25.98-1.97"}],["path",{d:"M10.91 5.26c.15-.26.34-.51.56-.73L13 3l1.53 1.53a3.5 3.5 0 0 1 .28 4.62"}],["path",{d:"M20 2h2v2a4 4 0 0 1-4 4h-2V6a4 4 0 0 1 4-4Z"}],["path",{d:"M11.47 17.47 13 19l-1.53 1.53a3.5 3.5 0 0 1-4.94 0L5 19l1.53-1.53a3.5 3.5 0 0 1 4.94 0Z"}],["path",{d:"m16 16-.53.53a3.5 3.5 0 0 1-4.94 0L9 15l1.53-1.53a3.49 3.49 0 0 1 1.97-.98"}],["path",{d:"M18.74 13.09c.26-.15.51-.34.73-.56L21 11l-1.53-1.53a3.5 3.5 0 0 0-4.62-.28"}],["line",{x1:"2",x2:"22",y1:"2",y2:"22"}]],iu=[["path",{d:"M2 22 16 8"}],["path",{d:"M3.47 12.53 5 11l1.53 1.53a3.5 3.5 0 0 1 0 4.94L5 19l-1.53-1.53a3.5 3.5 0 0 1 0-4.94Z"}],["path",{d:"M7.47 8.53 9 7l1.53 1.53a3.5 3.5 0 0 1 0 4.94L9 15l-1.53-1.53a3.5 3.5 0 0 1 0-4.94Z"}],["path",{d:"M11.47 4.53 13 3l1.53 1.53a3.5 3.5 0 0 1 0 4.94L13 11l-1.53-1.53a3.5 3.5 0 0 1 0-4.94Z"}],["path",{d:"M20 2h2v2a4 4 0 0 1-4 4h-2V6a4 4 0 0 1 4-4Z"}],["path",{d:"M11.47 17.47 13 19l-1.53 1.53a3.5 3.5 0 0 1-4.94 0L5 19l1.53-1.53a3.5 3.5 0 0 1 4.94 0Z"}],["path",{d:"M15.47 13.47 17 15l-1.53 1.53a3.5 3.5 0 0 1-4.94 0L9 15l1.53-1.53a3.5 3.5 0 0 1 4.94 0Z"}],["path",{d:"M19.47 9.47 21 11l-1.53 1.53a3.5 3.5 0 0 1-4.94 0L13 11l1.53-1.53a3.5 3.5 0 0 1 4.94 0Z"}]],nu=[["circle",{cx:"7",cy:"12",r:"3"}],["path",{d:"M10 9v6"}],["circle",{cx:"17",cy:"12",r:"3"}],["path",{d:"M14 7v8"}],["path",{d:"M22 17v1c0 .5-.5 1-1 1H3c-.5 0-1-.5-1-1v-1"}]],lu=[["path",{d:"m14.305 19.53.923-.382"}],["path",{d:"m15.228 16.852-.923-.383"}],["path",{d:"m16.852 15.228-.383-.923"}],["path",{d:"m16.852 20.772-.383.924"}],["path",{d:"m19.148 15.228.383-.923"}],["path",{d:"m19.53 21.696-.382-.924"}],["path",{d:"M2 7.82a15 15 0 0 1 20 0"}],["path",{d:"m20.772 16.852.924-.383"}],["path",{d:"m20.772 19.148.924.383"}],["path",{d:"M5 11.858a10 10 0 0 1 11.5-1.785"}],["path",{d:"M8.5 15.429a5 5 0 0 1 2.413-1.31"}],["circle",{cx:"18",cy:"18",r:"3"}]],eu=[["path",{d:"M12 20h.01"}],["path",{d:"M5 12.859a10 10 0 0 1 14 0"}],["path",{d:"M8.5 16.429a5 5 0 0 1 7 0"}]],ru=[["path",{d:"M12 20h.01"}],["path",{d:"M8.5 16.429a5 5 0 0 1 7 0"}]],ou=[["path",{d:"M12 20h.01"}],["path",{d:"M8.5 16.429a5 5 0 0 1 7 0"}],["path",{d:"M5 12.859a10 10 0 0 1 5.17-2.69"}],["path",{d:"M19 12.859a10 10 0 0 0-2.007-1.523"}],["path",{d:"M2 8.82a15 15 0 0 1 4.177-2.643"}],["path",{d:"M22 8.82a15 15 0 0 0-11.288-3.764"}],["path",{d:"m2 2 20 20"}]],vu=[["path",{d:"M2 8.82a15 15 0 0 1 20 0"}],["path",{d:"M21.378 16.626a1 1 0 0 0-3.004-3.004l-4.01 4.012a2 2 0 0 0-.506.854l-.837 2.87a.5.5 0 0 0 .62.62l2.87-.837a2 2 0 0 0 .854-.506z"}],["path",{d:"M5 12.859a10 10 0 0 1 10.5-2.222"}],["path",{d:"M8.5 16.429a5 5 0 0 1 3-1.406"}]],$u=[["path",{d:"M11.965 10.105v4L13.5 12.5a5 5 0 0 1 8 1.5"}],["path",{d:"M11.965 14.105h4"}],["path",{d:"M17.965 18.105h4L20.43 19.71a5 5 0 0 1-8-1.5"}],["path",{d:"M2 8.82a15 15 0 0 1 20 0"}],["path",{d:"M21.965 22.105v-4"}],["path",{d:"M5 12.86a10 10 0 0 1 3-2.032"}],["path",{d:"M8.5 16.429h.01"}]],mu=[["path",{d:"M12 20h.01"}]],yu=[["path",{d:"M12 20h.01"}],["path",{d:"M2 8.82a15 15 0 0 1 20 0"}],["path",{d:"M5 12.859a10 10 0 0 1 14 0"}],["path",{d:"M8.5 16.429a5 5 0 0 1 7 0"}]],su=[["path",{d:"M10 2v8"}],["path",{d:"M12.8 21.6A2 2 0 1 0 14 18H2"}],["path",{d:"M17.5 10a2.5 2.5 0 1 1 2 4H2"}],["path",{d:"m6 6 4 4 4-4"}]],gu=[["path",{d:"M12.8 19.6A2 2 0 1 0 14 16H2"}],["path",{d:"M17.5 8a2.5 2.5 0 1 1 2 4H2"}],["path",{d:"M9.8 4.4A2 2 0 1 1 11 8H2"}]],uu=[["path",{d:"M8 22h8"}],["path",{d:"M7 10h3m7 0h-1.343"}],["path",{d:"M12 15v7"}],["path",{d:"M7.307 7.307A12.33 12.33 0 0 0 7 10a5 5 0 0 0 7.391 4.391M8.638 2.981C8.75 2.668 8.872 2.34 9 2h6c1.5 4 2 6 2 8 0 .407-.05.809-.145 1.198"}],["line",{x1:"2",x2:"22",y1:"2",y2:"22"}]],Cu=[["path",{d:"M8 22h8"}],["path",{d:"M7 10h10"}],["path",{d:"M12 15v7"}],["path",{d:"M12 15a5 5 0 0 0 5-5c0-2-.5-4-2-8H9c-1.5 4-2 6-2 8a5 5 0 0 0 5 5Z"}]],Hu=[["rect",{width:"8",height:"8",x:"3",y:"3",rx:"2"}],["path",{d:"M7 11v4a2 2 0 0 0 2 2h4"}],["rect",{width:"8",height:"8",x:"13",y:"13",rx:"2"}]],Au=[["path",{d:"m19 12-1.5 3"}],["path",{d:"M19.63 18.81 22 20"}],["path",{d:"M6.47 8.23a1.68 1.68 0 0 1 2.44 1.93l-.64 2.08a6.76 6.76 0 0 0 10.16 7.67l.42-.27a1 1 0 1 0-2.73-4.21l-.42.27a1.76 1.76 0 0 1-2.63-1.99l.64-2.08A6.66 6.66 0 0 0 3.94 3.9l-.7.4a1 1 0 1 0 2.55 4.34z"}]],wu=[["path",{d:"M18 6 6 18"}],["path",{d:"m6 6 12 12"}]],Vu=[["path",{d:"M14.7 6.3a1 1 0 0 0 0 1.4l1.6 1.6a1 1 0 0 0 1.4 0l3.106-3.105c.32-.322.863-.22.983.218a6 6 0 0 1-8.259 7.057l-7.91 7.91a1 1 0 0 1-2.999-3l7.91-7.91a6 6 0 0 1 7.057-8.259c.438.12.54.662.219.984z"}]],Su=[["path",{d:"M2.5 17a24.12 24.12 0 0 1 0-10 2 2 0 0 1 1.4-1.4 49.56 49.56 0 0 1 16.2 0A2 2 0 0 1 21.5 7a24.12 24.12 0 0 1 0 10 2 2 0 0 1-1.4 1.4 49.55 49.55 0 0 1-16.2 0A2 2 0 0 1 2.5 17"}],["path",{d:"m10 15 5-3-5-3z"}]],Lu=[["path",{d:"M10.513 4.856 13.12 2.17a.5.5 0 0 1 .86.46l-1.377 4.317"}],["path",{d:"M15.656 10H20a1 1 0 0 1 .78 1.63l-1.72 1.773"}],["path",{d:"M16.273 16.273 10.88 21.83a.5.5 0 0 1-.86-.46l1.92-6.02A1 1 0 0 0 11 14H4a1 1 0 0 1-.78-1.63l4.507-4.643"}],["path",{d:"m2 2 20 20"}]],fu=[["path",{d:"M4 14a1 1 0 0 1-.78-1.63l9.9-10.2a.5.5 0 0 1 .86.46l-1.92 6.02A1 1 0 0 0 13 10h7a1 1 0 0 1 .78 1.63l-9.9 10.2a.5.5 0 0 1-.86-.46l1.92-6.02A1 1 0 0 0 11 14z"}]],ku=[["circle",{cx:"11",cy:"11",r:"8"}],["line",{x1:"21",x2:"16.65",y1:"21",y2:"16.65"}],["line",{x1:"11",x2:"11",y1:"8",y2:"14"}],["line",{x1:"8",x2:"14",y1:"11",y2:"11"}]],Pu=[["circle",{cx:"11",cy:"11",r:"8"}],["line",{x1:"21",x2:"16.65",y1:"21",y2:"16.65"}],["line",{x1:"8",x2:"14",y1:"11",y2:"11"}]];var Bu=Object.freeze({__proto__:null,AArrowDown:oa,AArrowUp:va,ALargeSmall:$a,Accessibility:ma,Activity:ya,ActivitySquare:G2,AirVent:sa,Airplay:ga,AlarmCheck:y,AlarmClock:Ca,AlarmClockCheck:y,AlarmClockMinus:s,AlarmClockOff:ua,AlarmClockPlus:g,AlarmMinus:s,AlarmPlus:g,AlarmSmoke:Ha,Album:Aa,AlertCircle:N,AlertOctagon:y2,AlertTriangle:K0,AlignCenter:Z0,AlignCenterHorizontal:wa,AlignCenterVertical:Va,AlignEndHorizontal:Sa,AlignEndVertical:La,AlignHorizontalDistributeCenter:fa,AlignHorizontalDistributeEnd:ka,AlignHorizontalDistributeStart:Pa,AlignHorizontalJustifyCenter:Ba,AlignHorizontalJustifyEnd:Da,AlignHorizontalJustifyStart:Fa,AlignHorizontalSpaceAround:za,AlignHorizontalSpaceBetween:ba,AlignJustify:I0,AlignLeft:m,AlignRight:G0,AlignStartHorizontal:Ra,AlignStartVertical:Ta,AlignVerticalDistributeCenter:qa,AlignVerticalDistributeEnd:Ua,AlignVerticalDistributeStart:Oa,AlignVerticalJustifyCenter:Za,AlignVerticalJustifyEnd:Ga,AlignVerticalJustifyStart:Ia,AlignVerticalSpaceAround:Wa,AlignVerticalSpaceBetween:Ea,Ambulance:Xa,Ampersand:ja,Ampersands:Na,Amphora:Ka,Anchor:Qa,Angry:Ja,Annoyed:Ya,Antenna:_a,Anvil:xa,Aperture:at,AppWindow:ht,AppWindowMac:tt,Apple:dt,Archive:it,ArchiveRestore:ct,ArchiveX:Mt,AreaChart:z,Armchair:pt,ArrowBigDown:lt,ArrowBigDownDash:nt,ArrowBigLeft:rt,ArrowBigLeftDash:et,ArrowBigRight:vt,ArrowBigRightDash:ot,ArrowBigUp:mt,ArrowBigUpDash:$t,ArrowDown:St,ArrowDown01:yt,ArrowDown10:st,ArrowDownAZ:u,ArrowDownAz:u,ArrowDownCircle:K,ArrowDownFromLine:gt,ArrowDownLeft:Ct,ArrowDownLeftFromCircle:J,ArrowDownLeftFromSquare:j2,ArrowDownLeftSquare:I2,ArrowDownNarrowWide:ut,ArrowDownRight:Ht,ArrowDownRightFromCircle:Y,ArrowDownRightFromSquare:K2,ArrowDownRightSquare:W2,ArrowDownSquare:E2,ArrowDownToDot:At,ArrowDownToLine:wt,ArrowDownUp:Vt,ArrowDownWideNarrow:C,ArrowDownZA:H,ArrowDownZa:H,ArrowLeft:Pt,ArrowLeftCircle:Q,ArrowLeftFromLine:Lt,ArrowLeftRight:ft,ArrowLeftSquare:X2,ArrowLeftToLine:kt,ArrowRight:zt,ArrowRightCircle:a1,ArrowRightFromLine:Bt,ArrowRightLeft:Dt,ArrowRightSquare:J2,ArrowRightToLine:Ft,ArrowUp:Wt,ArrowUp01:bt,ArrowUp10:Rt,ArrowUpAZ:A,ArrowUpAz:A,ArrowUpCircle:t1,ArrowUpDown:Tt,ArrowUpFromDot:qt,ArrowUpFromLine:Ut,ArrowUpLeft:Ot,ArrowUpLeftFromCircle:_,ArrowUpLeftFromSquare:N2,ArrowUpLeftSquare:Y2,ArrowUpNarrowWide:w,ArrowUpRight:Zt,ArrowUpRightFromCircle:x,ArrowUpRightFromSquare:Q2,ArrowUpRightSquare:_2,ArrowUpSquare:x2,ArrowUpToLine:Gt,ArrowUpWideNarrow:It,ArrowUpZA:V,ArrowUpZa:V,ArrowsUpFromLine:Et,Asterisk:Xt,AsteriskSquare:a0,AtSign:jt,Atom:Nt,AudioLines:Kt,AudioWaveform:Jt,Award:Qt,Axe:Yt,Axis3D:S,Axis3d:S,Baby:_t,Backpack:xt,Badge:mh,BadgeAlert:ah,BadgeCent:hh,BadgeCheck:L,BadgeDollarSign:th,BadgeEuro:dh,BadgeHelp:f,BadgeIndianRupee:ch,BadgeInfo:Mh,BadgeJapaneseYen:ph,BadgeMinus:ih,BadgePercent:nh,BadgePlus:lh,BadgePoundSterling:eh,BadgeQuestionMark:f,BadgeRussianRuble:rh,BadgeSwissFranc:oh,BadgeTurkishLira:vh,BadgeX:$h,BaggageClaim:yh,Ban:sh,Banana:gh,Bandage:uh,Banknote:wh,BanknoteArrowDown:Ch,BanknoteArrowUp:Hh,BanknoteX:Ah,BarChart:G,BarChart2:I,BarChart3:O,BarChart4:U,BarChartBig:q,BarChartHorizontal:R,BarChartHorizontalBig:b,Barcode:Vh,Barrel:Sh,Baseline:Lh,Bath:fh,Battery:bh,BatteryCharging:kh,BatteryFull:Ph,BatteryLow:Bh,BatteryMedium:Dh,BatteryPlus:Fh,BatteryWarning:zh,Beaker:Rh,Bean:qh,BeanOff:Th,Bed:Zh,BedDouble:Uh,BedSingle:Oh,Beef:Gh,Beer:Wh,BeerOff:Ih,Bell:Jh,BellDot:Eh,BellElectric:Xh,BellMinus:jh,BellOff:Nh,BellPlus:Kh,BellRing:Qh,BetweenHorizonalEnd:k,BetweenHorizonalStart:P,BetweenHorizontalEnd:k,BetweenHorizontalStart:P,BetweenVerticalEnd:Yh,BetweenVerticalStart:_h,BicepsFlexed:a4,Bike:xh,Binary:t4,Binoculars:h4,Biohazard:d4,Bird:c4,Bitcoin:M4,Blend:p4,Blinds:i4,Blocks:n4,Bluetooth:v4,BluetoothConnected:l4,BluetoothOff:e4,BluetoothSearching:r4,Bold:o4,Bolt:$4,Bomb:m4,Bone:y4,Book:Z4,BookA:s4,BookAlert:g4,BookAudio:u4,BookCheck:C4,BookCopy:H4,BookDashed:B,BookDown:A4,BookHeadphones:w4,BookHeart:V4,BookImage:S4,BookKey:L4,BookLock:f4,BookMarked:k4,BookMinus:P4,BookOpen:F4,BookOpenCheck:B4,BookOpenText:D4,BookPlus:z4,BookTemplate:B,BookText:b4,BookType:R4,BookUp:q4,BookUp2:T4,BookUser:U4,BookX:O4,Bookmark:X4,BookmarkCheck:G4,BookmarkMinus:I4,BookmarkPlus:W4,BookmarkX:E4,BoomBox:j4,Bot:Q4,BotMessageSquare:N4,BotOff:K4,BottleWine:J4,BowArrow:Y4,Box:_4,BoxSelect:r0,Boxes:x4,Braces:D,Brackets:a5,Brain:d5,BrainCircuit:t5,BrainCog:h5,BrickWall:p5,BrickWallFire:c5,BrickWallShield:M5,Briefcase:e5,BriefcaseBusiness:i5,BriefcaseConveyorBelt:n5,BriefcaseMedical:l5,BringToFront:r5,Brush:v5,BrushCleaning:o5,Bubbles:$5,Bug:s5,BugOff:m5,BugPlay:y5,Building:C5,Building2:g5,Bus:H5,BusFront:u5,Cable:w5,CableCar:A5,Cake:f5,CakeSlice:V5,Calculator:S5,Calendar:N5,Calendar1:L5,CalendarArrowDown:k5,CalendarArrowUp:P5,CalendarCheck:D5,CalendarCheck2:B5,CalendarClock:F5,CalendarCog:z5,CalendarDays:b5,CalendarFold:R5,CalendarHeart:T5,CalendarMinus:U5,CalendarMinus2:q5,CalendarOff:O5,CalendarPlus:G5,CalendarPlus2:Z5,CalendarRange:I5,CalendarSearch:E5,CalendarSync:W5,CalendarX:j5,CalendarX2:X5,Camera:Q5,CameraOff:K5,CandlestickChart:T,Candy:_5,CandyCane:J5,CandyOff:Y5,Cannabis:a3,Captions:F,CaptionsOff:x5,Car:d3,CarFront:t3,CarTaxiFront:h3,Caravan:c3,CardSim:M3,Carrot:p3,CaseLower:i3,CaseSensitive:n3,CaseUpper:l3,CassetteTape:e3,Cast:r3,Castle:o3,Cat:v3,Cctv:$3,ChartArea:z,ChartBar:R,ChartBarBig:b,ChartBarDecreasing:m3,ChartBarIncreasing:y3,ChartBarStacked:s3,ChartCandlestick:T,ChartColumn:O,ChartColumnBig:q,ChartColumnDecreasing:g3,ChartColumnIncreasing:U,ChartColumnStacked:u3,ChartGantt:C3,ChartLine:Z,ChartNetwork:H3,ChartNoAxesColumn:I,ChartNoAxesColumnDecreasing:A3,ChartNoAxesColumnIncreasing:G,ChartNoAxesCombined:w3,ChartNoAxesGantt:W,ChartPie:E,ChartScatter:X,ChartSpline:V3,Check:f3,CheckCheck:S3,CheckCircle:h1,CheckCircle2:d1,CheckLine:L3,CheckSquare:h0,CheckSquare2:d0,ChefHat:k3,Cherry:P3,ChevronDown:D3,ChevronDownCircle:c1,ChevronDownSquare:c0,ChevronFirst:B3,ChevronLast:b3,ChevronLeft:F3,ChevronLeftCircle:M1,ChevronLeftSquare:M0,ChevronRight:z3,ChevronRightCircle:p1,ChevronRightSquare:p0,ChevronUp:R3,ChevronUpCircle:i1,ChevronUpSquare:i0,ChevronsDown:q3,ChevronsDownUp:T3,ChevronsLeft:Z3,ChevronsLeftRight:O3,ChevronsLeftRightEllipsis:U3,ChevronsRight:I3,ChevronsRightLeft:G3,ChevronsUp:E3,ChevronsUpDown:W3,Chrome:j,Chromium:j,Church:X3,Cigarette:N3,CigaretteOff:j3,Circle:id,CircleAlert:N,CircleArrowDown:K,CircleArrowLeft:Q,CircleArrowOutDownLeft:J,CircleArrowOutDownRight:Y,CircleArrowOutUpLeft:_,CircleArrowOutUpRight:x,CircleArrowRight:a1,CircleArrowUp:t1,CircleCheck:d1,CircleCheckBig:h1,CircleChevronDown:c1,CircleChevronLeft:M1,CircleChevronRight:p1,CircleChevronUp:i1,CircleDashed:K3,CircleDivide:n1,CircleDollarSign:Q3,CircleDot:_3,CircleDotDashed:J3,CircleEllipsis:Y3,CircleEqual:x3,CircleFadingArrowUp:ad,CircleFadingPlus:td,CircleGauge:l1,CircleHelp:l,CircleMinus:e1,CircleOff:hd,CircleParking:o1,CircleParkingOff:r1,CirclePause:v1,CirclePercent:$1,CirclePlay:m1,CirclePlus:y1,CirclePoundSterling:dd,CirclePower:s1,CircleQuestionMark:l,CircleSlash:cd,CircleSlash2:g1,CircleSlashed:g1,CircleSmall:Md,CircleStar:pd,CircleStop:u1,CircleUser:H1,CircleUserRound:C1,CircleX:A1,CircuitBoard:nd,Citrus:ld,Clapperboard:ed,Clipboard:Cd,ClipboardCheck:rd,ClipboardClock:od,ClipboardCopy:vd,ClipboardEdit:V1,ClipboardList:$d,ClipboardMinus:md,ClipboardPaste:yd,ClipboardPen:V1,ClipboardPenLine:w1,ClipboardPlus:sd,ClipboardSignature:w1,ClipboardType:gd,ClipboardX:ud,Clock:Ud,Clock1:Hd,Clock10:Ad,Clock11:wd,Clock12:Vd,Clock2:Sd,Clock3:Ld,Clock4:fd,Clock5:kd,Clock6:Pd,Clock7:Bd,Clock8:Dd,Clock9:Fd,ClockAlert:zd,ClockArrowDown:bd,ClockArrowUp:Rd,ClockFading:Td,ClockPlus:qd,ClosedCaption:Od,Cloud:t6,CloudAlert:Zd,CloudCheck:Gd,CloudCog:Id,CloudDownload:S1,CloudDrizzle:Wd,CloudFog:Ed,CloudHail:Xd,CloudLightning:jd,CloudMoon:Qd,CloudMoonRain:Nd,CloudOff:Kd,CloudRain:Yd,CloudRainWind:Jd,CloudSnow:_d,CloudSun:a6,CloudSunRain:xd,CloudUpload:L1,Cloudy:h6,Clover:d6,Club:c6,Code:M6,Code2:f1,CodeSquare:n0,CodeXml:f1,Codepen:p6,Codesandbox:i6,Coffee:n6,Cog:l6,Coins:e6,Columns:k1,Columns2:k1,Columns3:P1,Columns3Cog:e,Columns4:r6,ColumnsSettings:e,Combine:o6,Command:$6,Compass:v6,Component:m6,Computer:y6,ConciergeBell:s6,Cone:g6,Construction:u6,Contact:C6,Contact2:B1,ContactRound:B1,Container:H6,Contrast:A6,Cookie:w6,CookingPot:V6,Copy:B6,CopyCheck:S6,CopyMinus:L6,CopyPlus:f6,CopySlash:k6,CopyX:P6,Copyleft:F6,Copyright:D6,CornerDownLeft:z6,CornerDownRight:b6,CornerLeftDown:R6,CornerLeftUp:T6,CornerRightDown:q6,CornerRightUp:U6,CornerUpLeft:O6,CornerUpRight:Z6,Cpu:G6,CreativeCommons:I6,CreditCard:W6,Croissant:E6,Crop:X6,Cross:j6,Crosshair:N6,Crown:K6,Cuboid:Q6,CupSoda:J6,CurlyBraces:D,Currency:Y6,Cylinder:_6,Dam:x6,Database:h8,DatabaseBackup:a8,DatabaseZap:t8,DecimalsArrowLeft:d8,DecimalsArrowRight:c8,Delete:M8,Dessert:p8,Diameter:i8,Diamond:r8,DiamondMinus:n8,DiamondPercent:D1,DiamondPlus:l8,Dice1:e8,Dice2:o8,Dice3:v8,Dice4:$8,Dice5:m8,Dice6:y8,Dices:s8,Diff:g8,Disc:A8,Disc2:u8,Disc3:C8,DiscAlbum:H8,Divide:w8,DivideCircle:n1,DivideSquare:v0,Dna:S8,DnaOff:V8,Dock:f8,Dog:L8,DollarSign:k8,Donut:P8,DoorClosed:D8,DoorClosedLocked:B8,DoorOpen:F8,Dot:b8,DotSquare:o0,Download:z8,DownloadCloud:S1,DraftingCompass:R8,Drama:T8,Dribbble:q8,Drill:U8,Drone:O8,Droplet:Z8,DropletOff:G8,Droplets:I8,Drum:W8,Drumstick:E8,Dumbbell:X8,Ear:j8,EarOff:N8,Earth:F1,EarthLock:K8,Eclipse:Q8,Edit:p,Edit2:P2,Edit3:k2,Egg:_8,EggFried:J8,EggOff:Y8,Ellipsis:b1,EllipsisVertical:z1,Equal:tc,EqualApproximately:x8,EqualNot:ac,EqualSquare:$0,Eraser:hc,EthernetPort:dc,Euro:cc,EvCharger:Mc,Expand:pc,ExternalLink:ic,Eye:ec,EyeClosed:nc,EyeOff:lc,Facebook:rc,Factory:oc,Fan:vc,FastForward:mc,Feather:$c,Fence:yc,FerrisWheel:sc,Figma:gc,File:o7,FileArchive:Cc,FileAudio:Hc,FileAudio2:uc,FileAxis3D:R1,FileAxis3d:R1,FileBadge:wc,FileBadge2:Ac,FileBarChart:T1,FileBarChart2:q1,FileBox:Vc,FileChartColumn:q1,FileChartColumnIncreasing:T1,FileChartLine:U1,FileChartPie:O1,FileCheck:Sc,FileCheck2:Lc,FileClock:fc,FileCode:Pc,FileCode2:kc,FileCog:Z1,FileCog2:Z1,FileDiff:Bc,FileDigit:Dc,FileDown:Fc,FileEdit:I1,FileHeart:bc,FileImage:zc,FileInput:Rc,FileJson:qc,FileJson2:Tc,FileKey:Oc,FileKey2:Uc,FileLineChart:U1,FileLock:Zc,FileLock2:Gc,FileMinus:Wc,FileMinus2:Ic,FileMusic:Ec,FileOutput:Xc,FilePen:I1,FilePenLine:G1,FilePieChart:O1,FilePlay:W1,FilePlus:Nc,FilePlus2:jc,FileQuestion:E1,FileQuestionMark:E1,FileScan:Kc,FileSearch:Jc,FileSearch2:Qc,FileSignature:G1,FileSliders:Yc,FileSpreadsheet:_c,FileStack:xc,FileSymlink:a7,FileTerminal:t7,FileText:h7,FileType:c7,FileType2:d7,FileUp:M7,FileUser:p7,FileVideo:W1,FileVideo2:X1,FileVideoCamera:X1,FileVolume:n7,FileVolume2:i7,FileWarning:l7,FileX:r7,FileX2:e7,Files:v7,Film:$7,Filter:Q1,FilterX:K1,Fingerprint:m7,FireExtinguisher:y7,Fish:u7,FishOff:s7,FishSymbol:g7,Flag:w7,FlagOff:C7,FlagTriangleLeft:H7,FlagTriangleRight:A7,Flame:S7,FlameKindling:V7,Flashlight:f7,FlashlightOff:L7,FlaskConical:P7,FlaskConicalOff:k7,FlaskRound:B7,FlipHorizontal:F7,FlipHorizontal2:D7,FlipVertical:b7,FlipVertical2:z7,Flower:R7,Flower2:T7,Focus:q7,FoldHorizontal:U7,FoldVertical:O7,Folder:vM,FolderArchive:Z7,FolderCheck:G7,FolderClock:I7,FolderClosed:W7,FolderCode:E7,FolderCog:j1,FolderCog2:j1,FolderDot:X7,FolderDown:j7,FolderEdit:N1,FolderGit:Q7,FolderGit2:N7,FolderHeart:K7,FolderInput:Y7,FolderKanban:J7,FolderKey:_7,FolderLock:x7,FolderMinus:aM,FolderOpen:hM,FolderOpenDot:tM,FolderOutput:dM,FolderPen:N1,FolderPlus:MM,FolderRoot:cM,FolderSearch:iM,FolderSearch2:pM,FolderSymlink:nM,FolderSync:lM,FolderTree:eM,FolderUp:oM,FolderX:rM,Folders:$M,Footprints:mM,ForkKnife:Ma,ForkKnifeCrossed:ca,Forklift:yM,FormInput:D2,Forward:gM,Frame:sM,Framer:uM,Frown:CM,Fuel:HM,Fullscreen:AM,FunctionSquare:m0,Funnel:Q1,FunnelPlus:wM,FunnelX:K1,GalleryHorizontal:SM,GalleryHorizontalEnd:VM,GalleryThumbnails:fM,GalleryVertical:kM,GalleryVerticalEnd:LM,Gamepad:BM,Gamepad2:PM,GanttChart:W,GanttChartSquare:$,Gauge:DM,GaugeCircle:l1,Gavel:FM,Gem:zM,GeorgianLari:bM,Ghost:RM,Gift:TM,GitBranch:UM,GitBranchPlus:qM,GitCommit:J1,GitCommitHorizontal:J1,GitCommitVertical:OM,GitCompare:GM,GitCompareArrows:ZM,GitFork:IM,GitGraph:WM,GitMerge:EM,GitPullRequest:JM,GitPullRequestArrow:XM,GitPullRequestClosed:jM,GitPullRequestCreate:KM,GitPullRequestCreateArrow:NM,GitPullRequestDraft:QM,Github:YM,Gitlab:_M,GlassWater:xM,Glasses:a9,Globe:h9,Globe2:F1,GlobeLock:t9,Goal:d9,Gpu:M9,Grab:t2,GraduationCap:c9,Grape:p9,Grid:r,Grid2X2:a2,Grid2X2Check:Y1,Grid2X2Plus:_1,Grid2X2X:x1,Grid2x2:a2,Grid2x2Check:Y1,Grid2x2Plus:_1,Grid2x2X:x1,Grid3X3:r,Grid3x2:i9,Grid3x3:r,Grip:e9,GripHorizontal:n9,GripVertical:l9,Group:r9,Guitar:o9,Ham:v9,Hamburger:$9,Hammer:m9,Hand:H9,HandCoins:y9,HandFist:s9,HandGrab:t2,HandHeart:g9,HandHelping:h2,HandMetal:u9,HandPlatter:C9,Handbag:w9,Handshake:A9,HardDrive:L9,HardDriveDownload:V9,HardDriveUpload:S9,HardHat:f9,Hash:k9,HatGlasses:P9,Haze:B9,HdmiPort:D9,Heading:U9,Heading1:F9,Heading2:z9,Heading3:b9,Heading4:R9,Heading5:T9,Heading6:q9,HeadphoneOff:O9,Headphones:Z9,Headset:G9,Heart:K9,HeartCrack:I9,HeartHandshake:W9,HeartMinus:E9,HeartOff:X9,HeartPlus:j9,HeartPulse:N9,Heater:Q9,HelpCircle:l,HelpingHand:h2,Hexagon:J9,Highlighter:Y9,History:_9,Home:d2,Hop:ap,HopOff:x9,Hospital:tp,Hotel:hp,Hourglass:dp,House:d2,HouseHeart:cp,HousePlug:Mp,HousePlus:pp,HouseWifi:ip,IceCream:M2,IceCream2:c2,IceCreamBowl:c2,IceCreamCone:M2,IdCard:lp,IdCardLanyard:np,Image:sp,ImageDown:ep,ImageMinus:op,ImageOff:rp,ImagePlay:vp,ImagePlus:$p,ImageUp:mp,ImageUpscale:yp,Images:gp,Import:up,Inbox:Cp,Indent:v,IndentDecrease:o,IndentIncrease:v,IndianRupee:Hp,Infinity:Ap,Info:wp,Inspect:H0,InspectionPanel:Vp,Instagram:Sp,Italic:Lp,IterationCcw:fp,IterationCw:kp,JapaneseYen:Pp,Joystick:Bp,Kanban:Dp,KanbanSquare:y0,KanbanSquareDashed:l0,Kayak:Fp,Key:Rp,KeyRound:zp,KeySquare:bp,Keyboard:Up,KeyboardMusic:Tp,KeyboardOff:qp,Lamp:Ep,LampCeiling:Op,LampDesk:Zp,LampFloor:Gp,LampWallDown:Ip,LampWallUp:Wp,LandPlot:Xp,Landmark:jp,Languages:Np,Laptop:Qp,Laptop2:p2,LaptopMinimal:p2,LaptopMinimalCheck:Kp,Lasso:Yp,LassoSelect:Jp,Laugh:_p,Layers:i2,Layers2:xp,Layers3:i2,Layout:f2,LayoutDashboard:ai,LayoutGrid:ti,LayoutList:hi,LayoutPanelLeft:di,LayoutPanelTop:ci,LayoutTemplate:Mi,Leaf:pi,LeafyGreen:ii,Lectern:ni,LetterText:W0,Library:ei,LibraryBig:li,LibrarySquare:s0,LifeBuoy:ri,Ligature:oi,Lightbulb:$i,LightbulbOff:vi,LineChart:Z,LineSquiggle:mi,Link:gi,Link2:si,Link2Off:yi,Linkedin:ui,List:Ui,ListCheck:Ci,ListChecks:Hi,ListChevronsDownUp:Ai,ListChevronsUpDown:wi,ListCollapse:Vi,ListEnd:Si,ListFilter:Li,ListFilterPlus:fi,ListIndentDecrease:o,ListIndentIncrease:v,ListMinus:ki,ListMusic:Bi,ListOrdered:Pi,ListPlus:Di,ListRestart:Fi,ListStart:zi,ListTodo:bi,ListTree:Ri,ListVideo:Ti,ListX:qi,Loader:Zi,Loader2:n2,LoaderCircle:n2,LoaderPinwheel:Oi,Locate:Wi,LocateFixed:Gi,LocateOff:Ii,LocationEdit:o2,Lock:Xi,LockKeyhole:Ei,LockKeyholeOpen:l2,LockOpen:e2,LogIn:ji,LogOut:Ni,Logs:Ki,Lollipop:Qi,Luggage:Ji,MSquare:g0,Magnet:Yi,Mail:Mn,MailCheck:_i,MailMinus:xi,MailOpen:an,MailPlus:tn,MailQuestion:r2,MailQuestionMark:r2,MailSearch:hn,MailWarning:dn,MailX:cn,Mailbox:pn,Mails:nn,Map:wn,MapMinus:ln,MapPin:Cn,MapPinCheck:rn,MapPinCheckInside:en,MapPinHouse:on,MapPinMinus:$n,MapPinMinusInside:vn,MapPinOff:mn,MapPinPen:o2,MapPinPlus:sn,MapPinPlusInside:yn,MapPinX:un,MapPinXInside:gn,MapPinned:Hn,MapPlus:An,Mars:Sn,MarsStroke:Vn,Martini:Ln,Maximize:kn,Maximize2:fn,Medal:Pn,Megaphone:Dn,MegaphoneOff:Bn,Meh:Fn,MemoryStick:zn,Menu:bn,MenuSquare:u0,Merge:Rn,MessageCircle:jn,MessageCircleCode:Tn,MessageCircleDashed:qn,MessageCircleHeart:Un,MessageCircleMore:On,MessageCircleOff:Zn,MessageCirclePlus:Gn,MessageCircleQuestion:v2,MessageCircleQuestionMark:v2,MessageCircleReply:In,MessageCircleWarning:Wn,MessageCircleX:En,MessageSquare:pl,MessageSquareCode:Xn,MessageSquareDashed:Nn,MessageSquareDiff:Kn,MessageSquareDot:Qn,MessageSquareHeart:Jn,MessageSquareLock:Yn,MessageSquareMore:_n,MessageSquareOff:xn,MessageSquarePlus:al,MessageSquareQuote:tl,MessageSquareReply:hl,MessageSquareShare:cl,MessageSquareText:dl,MessageSquareWarning:Ml,MessageSquareX:il,MessagesSquare:nl,Mic:el,Mic2:$2,MicOff:ll,MicVocal:$2,Microchip:rl,Microscope:ol,Microwave:ml,Milestone:vl,Milk:gl,MilkOff:$l,Minimize:sl,Minimize2:yl,Minus:ul,MinusCircle:e1,MinusSquare:C0,Monitor:Fl,MonitorCheck:Cl,MonitorCog:Hl,MonitorDot:Al,MonitorDown:wl,MonitorOff:Vl,MonitorPause:Ll,MonitorPlay:Sl,MonitorSmartphone:fl,MonitorSpeaker:kl,MonitorStop:Pl,MonitorUp:Bl,MonitorX:Dl,Moon:bl,MoonStar:zl,MoreHorizontal:b1,MoreVertical:z1,Mountain:Tl,MountainSnow:Rl,Mouse:Il,MouseOff:ql,MousePointer:Gl,MousePointer2:Ul,MousePointerBan:Ol,MousePointerClick:Zl,MousePointerSquareDashed:e0,Move:te,Move3D:m2,Move3d:m2,MoveDiagonal:El,MoveDiagonal2:Wl,MoveDown:Nl,MoveDownLeft:Xl,MoveDownRight:jl,MoveHorizontal:Kl,MoveLeft:Ql,MoveRight:Jl,MoveUp:xl,MoveUpLeft:Yl,MoveUpRight:_l,MoveVertical:ae,Music:Me,Music2:he,Music3:de,Music4:ce,Navigation:le,Navigation2:ie,Navigation2Off:pe,NavigationOff:ne,Network:ee,Newspaper:re,Nfc:oe,NonBinary:ve,Notebook:ge,NotebookPen:$e,NotebookTabs:me,NotebookText:ye,NotepadText:ue,NotepadTextDashed:se,Nut:He,NutOff:Ce,Octagon:we,OctagonAlert:y2,OctagonMinus:Ae,OctagonPause:g2,OctagonX:s2,Omega:Ve,Option:Se,Orbit:Le,Origami:Pe,Outdent:o,Package:Re,Package2:fe,PackageCheck:ke,PackageMinus:Be,PackageOpen:De,PackagePlus:Fe,PackageSearch:be,PackageX:ze,PaintBucket:Te,PaintRoller:qe,Paintbrush:Ue,Paintbrush2:u2,PaintbrushVertical:u2,Palette:Oe,Palmtree:N0,Panda:Ze,PanelBottom:We,PanelBottomClose:Ge,PanelBottomDashed:C2,PanelBottomInactive:C2,PanelBottomOpen:Ie,PanelLeft:V2,PanelLeftClose:H2,PanelLeftDashed:A2,PanelLeftInactive:A2,PanelLeftOpen:w2,PanelLeftRightDashed:Ee,PanelRight:Ne,PanelRightClose:Xe,PanelRightDashed:S2,PanelRightInactive:S2,PanelRightOpen:je,PanelTop:Ye,PanelTopBottomDashed:Ke,PanelTopClose:Qe,PanelTopDashed:L2,PanelTopInactive:L2,PanelTopOpen:Je,PanelsLeftBottom:_e,PanelsLeftRight:P1,PanelsRightBottom:xe,PanelsTopBottom:b2,PanelsTopLeft:f2,Paperclip:ar,Parentheses:tr,ParkingCircle:o1,ParkingCircleOff:r1,ParkingMeter:hr,ParkingSquare:w0,ParkingSquareOff:A0,PartyPopper:dr,Pause:cr,PauseCircle:v1,PauseOctagon:g2,PawPrint:Mr,PcCase:pr,Pen:P2,PenBox:p,PenLine:k2,PenOff:ir,PenSquare:p,PenTool:nr,Pencil:or,PencilLine:lr,PencilOff:er,PencilRuler:rr,Pentagon:vr,Percent:$r,PercentCircle:$1,PercentDiamond:D1,PercentSquare:V0,PersonStanding:mr,PhilippinePeso:yr,Phone:wr,PhoneCall:sr,PhoneForwarded:gr,PhoneIncoming:ur,PhoneMissed:Cr,PhoneOff:Hr,PhoneOutgoing:Ar,Pi:Vr,PiSquare:S0,Piano:Sr,Pickaxe:Lr,PictureInPicture:kr,PictureInPicture2:fr,PieChart:E,PiggyBank:Pr,Pilcrow:Fr,PilcrowLeft:Dr,PilcrowRight:Br,PilcrowSquare:L0,Pill:br,PillBottle:zr,Pin:Tr,PinOff:Rr,Pipette:qr,Pizza:Ur,Plane:Gr,PlaneLanding:Or,PlaneTakeoff:Zr,Play:Ir,PlayCircle:m1,PlaySquare:f0,Plug:Er,Plug2:Wr,PlugZap:B2,PlugZap2:B2,Plus:Xr,PlusCircle:y1,PlusSquare:k0,Pocket:Kr,PocketKnife:jr,Podcast:Nr,Pointer:Qr,PointerOff:Jr,Popcorn:Yr,Popsicle:_r,PoundSterling:xr,Power:ho,PowerCircle:s1,PowerOff:ao,PowerSquare:P0,Presentation:to,Printer:Mo,PrinterCheck:co,Projector:po,Proportions:io,Puzzle:lo,Pyramid:no,QrCode:eo,Quote:ro,Rabbit:oo,Radar:vo,Radiation:$o,Radical:yo,Radio:go,RadioReceiver:mo,RadioTower:so,Radius:uo,RailSymbol:Co,Rainbow:Ho,Rat:Ao,Ratio:wo,Receipt:zo,ReceiptCent:Vo,ReceiptEuro:So,ReceiptIndianRupee:Lo,ReceiptJapaneseYen:fo,ReceiptPoundSterling:ko,ReceiptRussianRuble:Bo,ReceiptSwissFranc:Po,ReceiptText:Do,ReceiptTurkishLira:Fo,RectangleCircle:bo,RectangleEllipsis:D2,RectangleGoggles:Ro,RectangleHorizontal:To,RectangleVertical:qo,Recycle:Uo,Redo:Go,Redo2:Oo,RedoDot:Zo,RefreshCcw:Io,RefreshCcwDot:Wo,RefreshCw:Xo,RefreshCwOff:Eo,Refrigerator:jo,Regex:No,RemoveFormatting:Ko,Repeat:Yo,Repeat1:Qo,Repeat2:Jo,Replace:xo,ReplaceAll:_o,Reply:tv,ReplyAll:av,Rewind:hv,Ribbon:dv,Rocket:cv,RockingChair:Mv,RollerCoaster:pv,Rose:iv,Rotate3D:F2,Rotate3d:F2,RotateCcw:ev,RotateCcwKey:nv,RotateCcwSquare:lv,RotateCw:ov,RotateCwSquare:rv,Route:$v,RouteOff:vv,Router:mv,Rows:z2,Rows2:z2,Rows3:b2,Rows4:yv,Rss:sv,Ruler:Cv,RulerDimensionLine:gv,RussianRuble:uv,Sailboat:Hv,Salad:Av,Sandwich:Vv,Satellite:Sv,SatelliteDish:wv,SaudiRiyal:Lv,Save:Pv,SaveAll:fv,SaveOff:kv,Scale:Bv,Scale3D:R2,Scale3d:R2,Scaling:Dv,Scan:Zv,ScanBarcode:Fv,ScanEye:zv,ScanFace:bv,ScanHeart:Rv,ScanLine:Tv,ScanQrCode:qv,ScanSearch:Ov,ScanText:Uv,ScatterChart:X,School:Gv,School2:J0,Scissors:Wv,ScissorsLineDashed:Iv,ScissorsSquare:B0,ScissorsSquareDashedBottom:t0,ScreenShare:Xv,ScreenShareOff:Ev,Scroll:Nv,ScrollText:jv,Search:_v,SearchCheck:Kv,SearchCode:Qv,SearchSlash:Jv,SearchX:Yv,Section:xv,Send:t$,SendHorizonal:T2,SendHorizontal:T2,SendToBack:a$,SeparatorHorizontal:h$,SeparatorVertical:d$,Server:p$,ServerCog:c$,ServerCrash:M$,ServerOff:i$,Settings:l$,Settings2:n$,Shapes:e$,Share:o$,Share2:r$,Sheet:v$,Shell:$$,Shield:V$,ShieldAlert:m$,ShieldBan:y$,ShieldCheck:s$,ShieldClose:U2,ShieldEllipsis:g$,ShieldHalf:u$,ShieldMinus:C$,ShieldOff:H$,ShieldPlus:A$,ShieldQuestion:q2,ShieldQuestionMark:q2,ShieldUser:w$,ShieldX:U2,Ship:S$,ShipWheel:f$,Shirt:L$,ShoppingBag:k$,ShoppingBasket:P$,ShoppingCart:B$,Shovel:D$,ShowerHead:F$,Shredder:z$,Shrimp:b$,Shrink:R$,Shrub:q$,Shuffle:U$,Sidebar:V2,SidebarClose:H2,SidebarOpen:w2,Sigma:T$,SigmaSquare:D0,Signal:W$,SignalHigh:O$,SignalLow:Z$,SignalMedium:G$,SignalZero:I$,Signature:E$,Signpost:j$,SignpostBig:X$,Siren:N$,SkipBack:K$,SkipForward:Q$,Skull:J$,Slack:Y$,Slash:_$,SlashSquare:F0,Slice:x$,Sliders:O2,SlidersHorizontal:am,SlidersVertical:O2,Smartphone:dm,SmartphoneCharging:hm,SmartphoneNfc:tm,Smile:Mm,SmilePlus:cm,Snail:pm,Snowflake:im,SoapDispenserDroplet:nm,Sofa:lm,SortAsc:w,SortDesc:C,Soup:em,Space:vm,Spade:rm,Sparkle:om,Sparkles:Z2,Speaker:$m,Speech:mm,SpellCheck:sm,SpellCheck2:ym,Spline:um,SplinePointer:gm,Split:Cm,SplitSquareHorizontal:z0,SplitSquareVertical:b0,Spool:Hm,Spotlight:Am,SprayCan:wm,Sprout:Vm,Square:Rm,SquareActivity:G2,SquareArrowDown:E2,SquareArrowDownLeft:I2,SquareArrowDownRight:W2,SquareArrowLeft:X2,SquareArrowOutDownLeft:j2,SquareArrowOutDownRight:K2,SquareArrowOutUpLeft:N2,SquareArrowOutUpRight:Q2,SquareArrowRight:J2,SquareArrowUp:x2,SquareArrowUpLeft:Y2,SquareArrowUpRight:_2,SquareAsterisk:a0,SquareBottomDashedScissors:t0,SquareChartGantt:$,SquareCheck:d0,SquareCheckBig:h0,SquareChevronDown:c0,SquareChevronLeft:M0,SquareChevronRight:p0,SquareChevronUp:i0,SquareCode:n0,SquareDashed:r0,SquareDashedBottom:Lm,SquareDashedBottomCode:Sm,SquareDashedKanban:l0,SquareDashedMousePointer:e0,SquareDashedTopSolid:fm,SquareDivide:v0,SquareDot:o0,SquareEqual:$0,SquareFunction:m0,SquareGanttChart:$,SquareKanban:y0,SquareLibrary:s0,SquareM:g0,SquareMenu:u0,SquareMinus:C0,SquareMousePointer:H0,SquareParking:w0,SquareParkingOff:A0,SquarePause:km,SquarePen:p,SquarePercent:V0,SquarePi:S0,SquarePilcrow:L0,SquarePlay:f0,SquarePlus:k0,SquarePower:P0,SquareRadical:Pm,SquareRoundCorner:Bm,SquareScissors:B0,SquareSigma:D0,SquareSlash:F0,SquareSplitHorizontal:z0,SquareSplitVertical:b0,SquareSquare:Dm,SquareStack:zm,SquareStar:Fm,SquareStop:bm,SquareTerminal:R0,SquareUser:T0,SquareUserRound:q0,SquareX:U0,SquaresExclude:Tm,SquaresIntersect:qm,SquaresSubtract:Um,SquaresUnite:Om,Squircle:Gm,SquircleDashed:Zm,Squirrel:Im,Stamp:Wm,Star:jm,StarHalf:Em,StarOff:Xm,Stars:Z2,StepBack:Nm,StepForward:Km,Stethoscope:Qm,Sticker:Jm,StickyNote:_m,StopCircle:u1,Store:Ym,StretchHorizontal:xm,StretchVertical:ay,Strikethrough:ty,Subscript:hy,Subtitles:F,Sun:iy,SunDim:cy,SunMedium:dy,SunMoon:py,SunSnow:My,Sunrise:ny,Sunset:ey,Superscript:ly,SwatchBook:ry,SwissFranc:oy,SwitchCamera:vy,Sword:$y,Swords:yy,Syringe:my,Table:Vy,Table2:sy,TableCellsMerge:gy,TableCellsSplit:uy,TableColumnsSplit:Cy,TableConfig:e,TableOfContents:Ay,TableProperties:Hy,TableRowsSplit:wy,Tablet:Ly,TabletSmartphone:Sy,Tablets:fy,Tag:ky,Tags:Py,Tally1:By,Tally2:Dy,Tally3:Fy,Tally4:zy,Tally5:by,Tangent:Ry,Target:qy,Telescope:Ty,Tent:Uy,TentTree:Oy,Terminal:Zy,TerminalSquare:R0,TestTube:Gy,TestTube2:O0,TestTubeDiagonal:O0,TestTubes:Iy,Text:m,TextAlignCenter:Z0,TextAlignEnd:G0,TextAlignJustify:I0,TextAlignStart:m,TextCursor:Ey,TextCursorInput:Wy,TextInitial:W0,TextQuote:Xy,TextSearch:jy,TextSelect:E0,TextSelection:E0,TextWrap:X0,Theater:Ny,Thermometer:Jy,ThermometerSnowflake:Ky,ThermometerSun:Qy,ThumbsDown:Yy,ThumbsUp:_y,Ticket:Ms,TicketCheck:xy,TicketMinus:as,TicketPercent:ts,TicketPlus:hs,TicketSlash:ds,TicketX:cs,Tickets:is,TicketsPlane:ps,Timer:es,TimerOff:ns,TimerReset:ls,ToggleLeft:rs,ToggleRight:os,Toilet:vs,ToolCase:$s,Tornado:ms,Torus:ys,Touchpad:gs,TouchpadOff:ss,TowerControl:us,ToyBrick:Cs,Tractor:Hs,TrafficCone:As,Train:j0,TrainFront:Vs,TrainFrontTunnel:ws,TrainTrack:Ss,TramFront:j0,Transgender:Ls,Trash:ks,Trash2:fs,TreeDeciduous:Ps,TreePalm:N0,TreePine:Bs,Trees:Ds,Trello:Fs,TrendingDown:zs,TrendingUp:Rs,TrendingUpDown:bs,Triangle:Os,TriangleAlert:K0,TriangleDashed:Ts,TriangleRight:qs,Trophy:Us,Truck:Gs,TruckElectric:Zs,TurkishLira:Is,Turntable:Ws,Turtle:Es,Tv:js,Tv2:Q0,TvMinimal:Q0,TvMinimalPlay:Xs,Twitch:Ns,Twitter:Ks,Type:Js,TypeOutline:Qs,Umbrella:_s,UmbrellaOff:Ys,Underline:xs,Undo:hg,Undo2:ag,UndoDot:tg,UnfoldHorizontal:dg,UnfoldVertical:cg,Ungroup:Mg,University:J0,Unlink:ig,Unlink2:pg,Unlock:e2,UnlockKeyhole:l2,Unplug:ng,Upload:lg,UploadCloud:L1,Usb:eg,User:Ag,User2:ha,UserCheck:rg,UserCheck2:Y0,UserCircle:H1,UserCircle2:C1,UserCog:og,UserCog2:_0,UserLock:vg,UserMinus:$g,UserMinus2:x0,UserPen:mg,UserPlus:yg,UserPlus2:aa,UserRound:ha,UserRoundCheck:Y0,UserRoundCog:_0,UserRoundMinus:x0,UserRoundPen:sg,UserRoundPlus:aa,UserRoundSearch:gg,UserRoundX:ta,UserSearch:ug,UserSquare:T0,UserSquare2:q0,UserStar:Cg,UserX:Hg,UserX2:ta,Users:wg,Users2:da,UsersRound:da,Utensils:Ma,UtensilsCrossed:ca,UtilityPole:Vg,Variable:Sg,Vault:Lg,VectorSquare:fg,Vegan:kg,VenetianMask:Pg,Venus:Dg,VenusAndMars:Bg,Verified:L,Vibrate:zg,VibrateOff:Fg,Video:Rg,VideoOff:bg,Videotape:Tg,View:qg,Voicemail:Ug,Volleyball:Og,Volume:Eg,Volume1:Zg,Volume2:Gg,VolumeOff:Wg,VolumeX:Ig,Vote:Xg,Wallet:Ng,Wallet2:pa,WalletCards:jg,WalletMinimal:pa,Wallpaper:Kg,Wand:Qg,Wand2:ia,WandSparkles:ia,Warehouse:Jg,WashingMachine:Yg,Watch:_g,Waves:au,WavesLadder:xg,Waypoints:tu,Webcam:hu,Webhook:cu,WebhookOff:du,Weight:Mu,Wheat:iu,WheatOff:pu,WholeWord:nu,Wifi:yu,WifiCog:lu,WifiHigh:eu,WifiLow:ru,WifiOff:ou,WifiPen:vu,WifiSync:$u,WifiZero:mu,Wind:gu,WindArrowDown:su,Wine:Cu,WineOff:uu,Workflow:Hu,Worm:Au,WrapText:X0,Wrench:Vu,X:wu,XCircle:A1,XOctagon:s2,XSquare:U0,Youtube:Su,Zap:fu,ZapOff:Lu,ZoomIn:ku,ZoomOut:Pu});const Uu=({icons:t=Bu,nameAttr:h="data-lucide",attrs:d={},root:c=document}={})=>{if(!Object.values(t).length)throw new Error(`Please provide an icons object.
+If you want to use all the icons you can import it like:
+ \`import { createIcons, icons } from 'lucide';
+lucide.createIcons({icons});\``);if(typeof c>"u")throw new Error("`createIcons()` only works in a browser environment.");const M=c.querySelectorAll(`[${h}]`);if(Array.from(M).forEach(i=>ra(i,{nameAttr:h,icons:t,attrs:d})),h==="data-lucide"){const i=c.querySelectorAll("[icon-name]");i.length>0&&(console.warn("[Lucide] Some icons were found with the now deprecated icon-name attribute. These will still be replaced for backwards compatibility, but will no longer be supported in v1.0 and you should switch to data-lucide"),Array.from(i).forEach(na=>ra(na,{nameAttr:"icon-name",icons:t,attrs:d})))}};a.AArrowDown=oa,a.AArrowUp=va,a.ALargeSmall=$a,a.Accessibility=ma,a.Activity=ya,a.ActivitySquare=G2,a.AirVent=sa,a.Airplay=ga,a.AlarmCheck=y,a.AlarmClock=Ca,a.AlarmClockCheck=y,a.AlarmClockMinus=s,a.AlarmClockOff=ua,a.AlarmClockPlus=g,a.AlarmMinus=s,a.AlarmPlus=g,a.AlarmSmoke=Ha,a.Album=Aa,a.AlertCircle=N,a.AlertOctagon=y2,a.AlertTriangle=K0,a.AlignCenter=Z0,a.AlignCenterHorizontal=wa,a.AlignCenterVertical=Va,a.AlignEndHorizontal=Sa,a.AlignEndVertical=La,a.AlignHorizontalDistributeCenter=fa,a.AlignHorizontalDistributeEnd=ka,a.AlignHorizontalDistributeStart=Pa,a.AlignHorizontalJustifyCenter=Ba,a.AlignHorizontalJustifyEnd=Da,a.AlignHorizontalJustifyStart=Fa,a.AlignHorizontalSpaceAround=za,a.AlignHorizontalSpaceBetween=ba,a.AlignJustify=I0,a.AlignLeft=m,a.AlignRight=G0,a.AlignStartHorizontal=Ra,a.AlignStartVertical=Ta,a.AlignVerticalDistributeCenter=qa,a.AlignVerticalDistributeEnd=Ua,a.AlignVerticalDistributeStart=Oa,a.AlignVerticalJustifyCenter=Za,a.AlignVerticalJustifyEnd=Ga,a.AlignVerticalJustifyStart=Ia,a.AlignVerticalSpaceAround=Wa,a.AlignVerticalSpaceBetween=Ea,a.Ambulance=Xa,a.Ampersand=ja,a.Ampersands=Na,a.Amphora=Ka,a.Anchor=Qa,a.Angry=Ja,a.Annoyed=Ya,a.Antenna=_a,a.Anvil=xa,a.Aperture=at,a.AppWindow=ht,a.AppWindowMac=tt,a.Apple=dt,a.Archive=it,a.ArchiveRestore=ct,a.ArchiveX=Mt,a.AreaChart=z,a.Armchair=pt,a.ArrowBigDown=lt,a.ArrowBigDownDash=nt,a.ArrowBigLeft=rt,a.ArrowBigLeftDash=et,a.ArrowBigRight=vt,a.ArrowBigRightDash=ot,a.ArrowBigUp=mt,a.ArrowBigUpDash=$t,a.ArrowDown=St,a.ArrowDown01=yt,a.ArrowDown10=st,a.ArrowDownAZ=u,a.ArrowDownAz=u,a.ArrowDownCircle=K,a.ArrowDownFromLine=gt,a.ArrowDownLeft=Ct,a.ArrowDownLeftFromCircle=J,a.ArrowDownLeftFromSquare=j2,a.ArrowDownLeftSquare=I2,a.ArrowDownNarrowWide=ut,a.ArrowDownRight=Ht,a.ArrowDownRightFromCircle=Y,a.ArrowDownRightFromSquare=K2,a.ArrowDownRightSquare=W2,a.ArrowDownSquare=E2,a.ArrowDownToDot=At,a.ArrowDownToLine=wt,a.ArrowDownUp=Vt,a.ArrowDownWideNarrow=C,a.ArrowDownZA=H,a.ArrowDownZa=H,a.ArrowLeft=Pt,a.ArrowLeftCircle=Q,a.ArrowLeftFromLine=Lt,a.ArrowLeftRight=ft,a.ArrowLeftSquare=X2,a.ArrowLeftToLine=kt,a.ArrowRight=zt,a.ArrowRightCircle=a1,a.ArrowRightFromLine=Bt,a.ArrowRightLeft=Dt,a.ArrowRightSquare=J2,a.ArrowRightToLine=Ft,a.ArrowUp=Wt,a.ArrowUp01=bt,a.ArrowUp10=Rt,a.ArrowUpAZ=A,a.ArrowUpAz=A,a.ArrowUpCircle=t1,a.ArrowUpDown=Tt,a.ArrowUpFromDot=qt,a.ArrowUpFromLine=Ut,a.ArrowUpLeft=Ot,a.ArrowUpLeftFromCircle=_,a.ArrowUpLeftFromSquare=N2,a.ArrowUpLeftSquare=Y2,a.ArrowUpNarrowWide=w,a.ArrowUpRight=Zt,a.ArrowUpRightFromCircle=x,a.ArrowUpRightFromSquare=Q2,a.ArrowUpRightSquare=_2,a.ArrowUpSquare=x2,a.ArrowUpToLine=Gt,a.ArrowUpWideNarrow=It,a.ArrowUpZA=V,a.ArrowUpZa=V,a.ArrowsUpFromLine=Et,a.Asterisk=Xt,a.AsteriskSquare=a0,a.AtSign=jt,a.Atom=Nt,a.AudioLines=Kt,a.AudioWaveform=Jt,a.Award=Qt,a.Axe=Yt,a.Axis3D=S,a.Axis3d=S,a.Baby=_t,a.Backpack=xt,a.Badge=mh,a.BadgeAlert=ah,a.BadgeCent=hh,a.BadgeCheck=L,a.BadgeDollarSign=th,a.BadgeEuro=dh,a.BadgeHelp=f,a.BadgeIndianRupee=ch,a.BadgeInfo=Mh,a.BadgeJapaneseYen=ph,a.BadgeMinus=ih,a.BadgePercent=nh,a.BadgePlus=lh,a.BadgePoundSterling=eh,a.BadgeQuestionMark=f,a.BadgeRussianRuble=rh,a.BadgeSwissFranc=oh,a.BadgeTurkishLira=vh,a.BadgeX=$h,a.BaggageClaim=yh,a.Ban=sh,a.Banana=gh,a.Bandage=uh,a.Banknote=wh,a.BanknoteArrowDown=Ch,a.BanknoteArrowUp=Hh,a.BanknoteX=Ah,a.BarChart=G,a.BarChart2=I,a.BarChart3=O,a.BarChart4=U,a.BarChartBig=q,a.BarChartHorizontal=R,a.BarChartHorizontalBig=b,a.Barcode=Vh,a.Barrel=Sh,a.Baseline=Lh,a.Bath=fh,a.Battery=bh,a.BatteryCharging=kh,a.BatteryFull=Ph,a.BatteryLow=Bh,a.BatteryMedium=Dh,a.BatteryPlus=Fh,a.BatteryWarning=zh,a.Beaker=Rh,a.Bean=qh,a.BeanOff=Th,a.Bed=Zh,a.BedDouble=Uh,a.BedSingle=Oh,a.Beef=Gh,a.Beer=Wh,a.BeerOff=Ih,a.Bell=Jh,a.BellDot=Eh,a.BellElectric=Xh,a.BellMinus=jh,a.BellOff=Nh,a.BellPlus=Kh,a.BellRing=Qh,a.BetweenHorizonalEnd=k,a.BetweenHorizonalStart=P,a.BetweenHorizontalEnd=k,a.BetweenHorizontalStart=P,a.BetweenVerticalEnd=Yh,a.BetweenVerticalStart=_h,a.BicepsFlexed=a4,a.Bike=xh,a.Binary=t4,a.Binoculars=h4,a.Biohazard=d4,a.Bird=c4,a.Bitcoin=M4,a.Blend=p4,a.Blinds=i4,a.Blocks=n4,a.Bluetooth=v4,a.BluetoothConnected=l4,a.BluetoothOff=e4,a.BluetoothSearching=r4,a.Bold=o4,a.Bolt=$4,a.Bomb=m4,a.Bone=y4,a.Book=Z4,a.BookA=s4,a.BookAlert=g4,a.BookAudio=u4,a.BookCheck=C4,a.BookCopy=H4,a.BookDashed=B,a.BookDown=A4,a.BookHeadphones=w4,a.BookHeart=V4,a.BookImage=S4,a.BookKey=L4,a.BookLock=f4,a.BookMarked=k4,a.BookMinus=P4,a.BookOpen=F4,a.BookOpenCheck=B4,a.BookOpenText=D4,a.BookPlus=z4,a.BookTemplate=B,a.BookText=b4,a.BookType=R4,a.BookUp=q4,a.BookUp2=T4,a.BookUser=U4,a.BookX=O4,a.Bookmark=X4,a.BookmarkCheck=G4,a.BookmarkMinus=I4,a.BookmarkPlus=W4,a.BookmarkX=E4,a.BoomBox=j4,a.Bot=Q4,a.BotMessageSquare=N4,a.BotOff=K4,a.BottleWine=J4,a.BowArrow=Y4,a.Box=_4,a.BoxSelect=r0,a.Boxes=x4,a.Braces=D,a.Brackets=a5,a.Brain=d5,a.BrainCircuit=t5,a.BrainCog=h5,a.BrickWall=p5,a.BrickWallFire=c5,a.BrickWallShield=M5,a.Briefcase=e5,a.BriefcaseBusiness=i5,a.BriefcaseConveyorBelt=n5,a.BriefcaseMedical=l5,a.BringToFront=r5,a.Brush=v5,a.BrushCleaning=o5,a.Bubbles=$5,a.Bug=s5,a.BugOff=m5,a.BugPlay=y5,a.Building=C5,a.Building2=g5,a.Bus=H5,a.BusFront=u5,a.Cable=w5,a.CableCar=A5,a.Cake=f5,a.CakeSlice=V5,a.Calculator=S5,a.Calendar=N5,a.Calendar1=L5,a.CalendarArrowDown=k5,a.CalendarArrowUp=P5,a.CalendarCheck=D5,a.CalendarCheck2=B5,a.CalendarClock=F5,a.CalendarCog=z5,a.CalendarDays=b5,a.CalendarFold=R5,a.CalendarHeart=T5,a.CalendarMinus=U5,a.CalendarMinus2=q5,a.CalendarOff=O5,a.CalendarPlus=G5,a.CalendarPlus2=Z5,a.CalendarRange=I5,a.CalendarSearch=E5,a.CalendarSync=W5,a.CalendarX=j5,a.CalendarX2=X5,a.Camera=Q5,a.CameraOff=K5,a.CandlestickChart=T,a.Candy=_5,a.CandyCane=J5,a.CandyOff=Y5,a.Cannabis=a3,a.Captions=F,a.CaptionsOff=x5,a.Car=d3,a.CarFront=t3,a.CarTaxiFront=h3,a.Caravan=c3,a.CardSim=M3,a.Carrot=p3,a.CaseLower=i3,a.CaseSensitive=n3,a.CaseUpper=l3,a.CassetteTape=e3,a.Cast=r3,a.Castle=o3,a.Cat=v3,a.Cctv=$3,a.ChartArea=z,a.ChartBar=R,a.ChartBarBig=b,a.ChartBarDecreasing=m3,a.ChartBarIncreasing=y3,a.ChartBarStacked=s3,a.ChartCandlestick=T,a.ChartColumn=O,a.ChartColumnBig=q,a.ChartColumnDecreasing=g3,a.ChartColumnIncreasing=U,a.ChartColumnStacked=u3,a.ChartGantt=C3,a.ChartLine=Z,a.ChartNetwork=H3,a.ChartNoAxesColumn=I,a.ChartNoAxesColumnDecreasing=A3,a.ChartNoAxesColumnIncreasing=G,a.ChartNoAxesCombined=w3,a.ChartNoAxesGantt=W,a.ChartPie=E,a.ChartScatter=X,a.ChartSpline=V3,a.Check=f3,a.CheckCheck=S3,a.CheckCircle=h1,a.CheckCircle2=d1,a.CheckLine=L3,a.CheckSquare=h0,a.CheckSquare2=d0,a.ChefHat=k3,a.Cherry=P3,a.ChevronDown=D3,a.ChevronDownCircle=c1,a.ChevronDownSquare=c0,a.ChevronFirst=B3,a.ChevronLast=b3,a.ChevronLeft=F3,a.ChevronLeftCircle=M1,a.ChevronLeftSquare=M0,a.ChevronRight=z3,a.ChevronRightCircle=p1,a.ChevronRightSquare=p0,a.ChevronUp=R3,a.ChevronUpCircle=i1,a.ChevronUpSquare=i0,a.ChevronsDown=q3,a.ChevronsDownUp=T3,a.ChevronsLeft=Z3,a.ChevronsLeftRight=O3,a.ChevronsLeftRightEllipsis=U3,a.ChevronsRight=I3,a.ChevronsRightLeft=G3,a.ChevronsUp=E3,a.ChevronsUpDown=W3,a.Chrome=j,a.Chromium=j,a.Church=X3,a.Cigarette=N3,a.CigaretteOff=j3,a.Circle=id,a.CircleAlert=N,a.CircleArrowDown=K,a.CircleArrowLeft=Q,a.CircleArrowOutDownLeft=J,a.CircleArrowOutDownRight=Y,a.CircleArrowOutUpLeft=_,a.CircleArrowOutUpRight=x,a.CircleArrowRight=a1,a.CircleArrowUp=t1,a.CircleCheck=d1,a.CircleCheckBig=h1,a.CircleChevronDown=c1,a.CircleChevronLeft=M1,a.CircleChevronRight=p1,a.CircleChevronUp=i1,a.CircleDashed=K3,a.CircleDivide=n1,a.CircleDollarSign=Q3,a.CircleDot=_3,a.CircleDotDashed=J3,a.CircleEllipsis=Y3,a.CircleEqual=x3,a.CircleFadingArrowUp=ad,a.CircleFadingPlus=td,a.CircleGauge=l1,a.CircleHelp=l,a.CircleMinus=e1,a.CircleOff=hd,a.CircleParking=o1,a.CircleParkingOff=r1,a.CirclePause=v1,a.CirclePercent=$1,a.CirclePlay=m1,a.CirclePlus=y1,a.CirclePoundSterling=dd,a.CirclePower=s1,a.CircleQuestionMark=l,a.CircleSlash=cd,a.CircleSlash2=g1,a.CircleSlashed=g1,a.CircleSmall=Md,a.CircleStar=pd,a.CircleStop=u1,a.CircleUser=H1,a.CircleUserRound=C1,a.CircleX=A1,a.CircuitBoard=nd,a.Citrus=ld,a.Clapperboard=ed,a.Clipboard=Cd,a.ClipboardCheck=rd,a.ClipboardClock=od,a.ClipboardCopy=vd,a.ClipboardEdit=V1,a.ClipboardList=$d,a.ClipboardMinus=md,a.ClipboardPaste=yd,a.ClipboardPen=V1,a.ClipboardPenLine=w1,a.ClipboardPlus=sd,a.ClipboardSignature=w1,a.ClipboardType=gd,a.ClipboardX=ud,a.Clock=Ud,a.Clock1=Hd,a.Clock10=Ad,a.Clock11=wd,a.Clock12=Vd,a.Clock2=Sd,a.Clock3=Ld,a.Clock4=fd,a.Clock5=kd,a.Clock6=Pd,a.Clock7=Bd,a.Clock8=Dd,a.Clock9=Fd,a.ClockAlert=zd,a.ClockArrowDown=bd,a.ClockArrowUp=Rd,a.ClockFading=Td,a.ClockPlus=qd,a.ClosedCaption=Od,a.Cloud=t6,a.CloudAlert=Zd,a.CloudCheck=Gd,a.CloudCog=Id,a.CloudDownload=S1,a.CloudDrizzle=Wd,a.CloudFog=Ed,a.CloudHail=Xd,a.CloudLightning=jd,a.CloudMoon=Qd,a.CloudMoonRain=Nd,a.CloudOff=Kd,a.CloudRain=Yd,a.CloudRainWind=Jd,a.CloudSnow=_d,a.CloudSun=a6,a.CloudSunRain=xd,a.CloudUpload=L1,a.Cloudy=h6,a.Clover=d6,a.Club=c6,a.Code=M6,a.Code2=f1,a.CodeSquare=n0,a.CodeXml=f1,a.Codepen=p6,a.Codesandbox=i6,a.Coffee=n6,a.Cog=l6,a.Coins=e6,a.Columns=k1,a.Columns2=k1,a.Columns3=P1,a.Columns3Cog=e,a.Columns4=r6,a.ColumnsSettings=e,a.Combine=o6,a.Command=$6,a.Compass=v6,a.Component=m6,a.Computer=y6,a.ConciergeBell=s6,a.Cone=g6,a.Construction=u6,a.Contact=C6,a.Contact2=B1,a.ContactRound=B1,a.Container=H6,a.Contrast=A6,a.Cookie=w6,a.CookingPot=V6,a.Copy=B6,a.CopyCheck=S6,a.CopyMinus=L6,a.CopyPlus=f6,a.CopySlash=k6,a.CopyX=P6,a.Copyleft=F6,a.Copyright=D6,a.CornerDownLeft=z6,a.CornerDownRight=b6,a.CornerLeftDown=R6,a.CornerLeftUp=T6,a.CornerRightDown=q6,a.CornerRightUp=U6,a.CornerUpLeft=O6,a.CornerUpRight=Z6,a.Cpu=G6,a.CreativeCommons=I6,a.CreditCard=W6,a.Croissant=E6,a.Crop=X6,a.Cross=j6,a.Crosshair=N6,a.Crown=K6,a.Cuboid=Q6,a.CupSoda=J6,a.CurlyBraces=D,a.Currency=Y6,a.Cylinder=_6,a.Dam=x6,a.Database=h8,a.DatabaseBackup=a8,a.DatabaseZap=t8,a.DecimalsArrowLeft=d8,a.DecimalsArrowRight=c8,a.Delete=M8,a.Dessert=p8,a.Diameter=i8,a.Diamond=r8,a.DiamondMinus=n8,a.DiamondPercent=D1,a.DiamondPlus=l8,a.Dice1=e8,a.Dice2=o8,a.Dice3=v8,a.Dice4=$8,a.Dice5=m8,a.Dice6=y8,a.Dices=s8,a.Diff=g8,a.Disc=A8,a.Disc2=u8,a.Disc3=C8,a.DiscAlbum=H8,a.Divide=w8,a.DivideCircle=n1,a.DivideSquare=v0,a.Dna=S8,a.DnaOff=V8,a.Dock=f8,a.Dog=L8,a.DollarSign=k8,a.Donut=P8,a.DoorClosed=D8,a.DoorClosedLocked=B8,a.DoorOpen=F8,a.Dot=b8,a.DotSquare=o0,a.Download=z8,a.DownloadCloud=S1,a.DraftingCompass=R8,a.Drama=T8,a.Dribbble=q8,a.Drill=U8,a.Drone=O8,a.Droplet=Z8,a.DropletOff=G8,a.Droplets=I8,a.Drum=W8,a.Drumstick=E8,a.Dumbbell=X8,a.Ear=j8,a.EarOff=N8,a.Earth=F1,a.EarthLock=K8,a.Eclipse=Q8,a.Edit=p,a.Edit2=P2,a.Edit3=k2,a.Egg=_8,a.EggFried=J8,a.EggOff=Y8,a.Ellipsis=b1,a.EllipsisVertical=z1,a.Equal=tc,a.EqualApproximately=x8,a.EqualNot=ac,a.EqualSquare=$0,a.Eraser=hc,a.EthernetPort=dc,a.Euro=cc,a.EvCharger=Mc,a.Expand=pc,a.ExternalLink=ic,a.Eye=ec,a.EyeClosed=nc,a.EyeOff=lc,a.Facebook=rc,a.Factory=oc,a.Fan=vc,a.FastForward=mc,a.Feather=$c,a.Fence=yc,a.FerrisWheel=sc,a.Figma=gc,a.File=o7,a.FileArchive=Cc,a.FileAudio=Hc,a.FileAudio2=uc,a.FileAxis3D=R1,a.FileAxis3d=R1,a.FileBadge=wc,a.FileBadge2=Ac,a.FileBarChart=T1,a.FileBarChart2=q1,a.FileBox=Vc,a.FileChartColumn=q1,a.FileChartColumnIncreasing=T1,a.FileChartLine=U1,a.FileChartPie=O1,a.FileCheck=Sc,a.FileCheck2=Lc,a.FileClock=fc,a.FileCode=Pc,a.FileCode2=kc,a.FileCog=Z1,a.FileCog2=Z1,a.FileDiff=Bc,a.FileDigit=Dc,a.FileDown=Fc,a.FileEdit=I1,a.FileHeart=bc,a.FileImage=zc,a.FileInput=Rc,a.FileJson=qc,a.FileJson2=Tc,a.FileKey=Oc,a.FileKey2=Uc,a.FileLineChart=U1,a.FileLock=Zc,a.FileLock2=Gc,a.FileMinus=Wc,a.FileMinus2=Ic,a.FileMusic=Ec,a.FileOutput=Xc,a.FilePen=I1,a.FilePenLine=G1,a.FilePieChart=O1,a.FilePlay=W1,a.FilePlus=Nc,a.FilePlus2=jc,a.FileQuestion=E1,a.FileQuestionMark=E1,a.FileScan=Kc,a.FileSearch=Jc,a.FileSearch2=Qc,a.FileSignature=G1,a.FileSliders=Yc,a.FileSpreadsheet=_c,a.FileStack=xc,a.FileSymlink=a7,a.FileTerminal=t7,a.FileText=h7,a.FileType=c7,a.FileType2=d7,a.FileUp=M7,a.FileUser=p7,a.FileVideo=W1,a.FileVideo2=X1,a.FileVideoCamera=X1,a.FileVolume=n7,a.FileVolume2=i7,a.FileWarning=l7,a.FileX=r7,a.FileX2=e7,a.Files=v7,a.Film=$7,a.Filter=Q1,a.FilterX=K1,a.Fingerprint=m7,a.FireExtinguisher=y7,a.Fish=u7,a.FishOff=s7,a.FishSymbol=g7,a.Flag=w7,a.FlagOff=C7,a.FlagTriangleLeft=H7,a.FlagTriangleRight=A7,a.Flame=S7,a.FlameKindling=V7,a.Flashlight=f7,a.FlashlightOff=L7,a.FlaskConical=P7,a.FlaskConicalOff=k7,a.FlaskRound=B7,a.FlipHorizontal=F7,a.FlipHorizontal2=D7,a.FlipVertical=b7,a.FlipVertical2=z7,a.Flower=R7,a.Flower2=T7,a.Focus=q7,a.FoldHorizontal=U7,a.FoldVertical=O7,a.Folder=vM,a.FolderArchive=Z7,a.FolderCheck=G7,a.FolderClock=I7,a.FolderClosed=W7,a.FolderCode=E7,a.FolderCog=j1,a.FolderCog2=j1,a.FolderDot=X7,a.FolderDown=j7,a.FolderEdit=N1,a.FolderGit=Q7,a.FolderGit2=N7,a.FolderHeart=K7,a.FolderInput=Y7,a.FolderKanban=J7,a.FolderKey=_7,a.FolderLock=x7,a.FolderMinus=aM,a.FolderOpen=hM,a.FolderOpenDot=tM,a.FolderOutput=dM,a.FolderPen=N1,a.FolderPlus=MM,a.FolderRoot=cM,a.FolderSearch=iM,a.FolderSearch2=pM,a.FolderSymlink=nM,a.FolderSync=lM,a.FolderTree=eM,a.FolderUp=oM,a.FolderX=rM,a.Folders=$M,a.Footprints=mM,a.ForkKnife=Ma,a.ForkKnifeCrossed=ca,a.Forklift=yM,a.FormInput=D2,a.Forward=gM,a.Frame=sM,a.Framer=uM,a.Frown=CM,a.Fuel=HM,a.Fullscreen=AM,a.FunctionSquare=m0,a.Funnel=Q1,a.FunnelPlus=wM,a.FunnelX=K1,a.GalleryHorizontal=SM,a.GalleryHorizontalEnd=VM,a.GalleryThumbnails=fM,a.GalleryVertical=kM,a.GalleryVerticalEnd=LM,a.Gamepad=BM,a.Gamepad2=PM,a.GanttChart=W,a.GanttChartSquare=$,a.Gauge=DM,a.GaugeCircle=l1,a.Gavel=FM,a.Gem=zM,a.GeorgianLari=bM,a.Ghost=RM,a.Gift=TM,a.GitBranch=UM,a.GitBranchPlus=qM,a.GitCommit=J1,a.GitCommitHorizontal=J1,a.GitCommitVertical=OM,a.GitCompare=GM,a.GitCompareArrows=ZM,a.GitFork=IM,a.GitGraph=WM,a.GitMerge=EM,a.GitPullRequest=JM,a.GitPullRequestArrow=XM,a.GitPullRequestClosed=jM,a.GitPullRequestCreate=KM,a.GitPullRequestCreateArrow=NM,a.GitPullRequestDraft=QM,a.Github=YM,a.Gitlab=_M,a.GlassWater=xM,a.Glasses=a9,a.Globe=h9,a.Globe2=F1,a.GlobeLock=t9,a.Goal=d9,a.Gpu=M9,a.Grab=t2,a.GraduationCap=c9,a.Grape=p9,a.Grid=r,a.Grid2X2=a2,a.Grid2X2Check=Y1,a.Grid2X2Plus=_1,a.Grid2X2X=x1,a.Grid2x2=a2,a.Grid2x2Check=Y1,a.Grid2x2Plus=_1,a.Grid2x2X=x1,a.Grid3X3=r,a.Grid3x2=i9,a.Grid3x3=r,a.Grip=e9,a.GripHorizontal=n9,a.GripVertical=l9,a.Group=r9,a.Guitar=o9,a.Ham=v9,a.Hamburger=$9,a.Hammer=m9,a.Hand=H9,a.HandCoins=y9,a.HandFist=s9,a.HandGrab=t2,a.HandHeart=g9,a.HandHelping=h2,a.HandMetal=u9,a.HandPlatter=C9,a.Handbag=w9,a.Handshake=A9,a.HardDrive=L9,a.HardDriveDownload=V9,a.HardDriveUpload=S9,a.HardHat=f9,a.Hash=k9,a.HatGlasses=P9,a.Haze=B9,a.HdmiPort=D9,a.Heading=U9,a.Heading1=F9,a.Heading2=z9,a.Heading3=b9,a.Heading4=R9,a.Heading5=T9,a.Heading6=q9,a.HeadphoneOff=O9,a.Headphones=Z9,a.Headset=G9,a.Heart=K9,a.HeartCrack=I9,a.HeartHandshake=W9,a.HeartMinus=E9,a.HeartOff=X9,a.HeartPlus=j9,a.HeartPulse=N9,a.Heater=Q9,a.HelpCircle=l,a.HelpingHand=h2,a.Hexagon=J9,a.Highlighter=Y9,a.History=_9,a.Home=d2,a.Hop=ap,a.HopOff=x9,a.Hospital=tp,a.Hotel=hp,a.Hourglass=dp,a.House=d2,a.HouseHeart=cp,a.HousePlug=Mp,a.HousePlus=pp,a.HouseWifi=ip,a.IceCream=M2,a.IceCream2=c2,a.IceCreamBowl=c2,a.IceCreamCone=M2,a.IdCard=lp,a.IdCardLanyard=np,a.Image=sp,a.ImageDown=ep,a.ImageMinus=op,a.ImageOff=rp,a.ImagePlay=vp,a.ImagePlus=$p,a.ImageUp=mp,a.ImageUpscale=yp,a.Images=gp,a.Import=up,a.Inbox=Cp,a.Indent=v,a.IndentDecrease=o,a.IndentIncrease=v,a.IndianRupee=Hp,a.Infinity=Ap,a.Info=wp,a.Inspect=H0,a.InspectionPanel=Vp,a.Instagram=Sp,a.Italic=Lp,a.IterationCcw=fp,a.IterationCw=kp,a.JapaneseYen=Pp,a.Joystick=Bp,a.Kanban=Dp,a.KanbanSquare=y0,a.KanbanSquareDashed=l0,a.Kayak=Fp,a.Key=Rp,a.KeyRound=zp,a.KeySquare=bp,a.Keyboard=Up,a.KeyboardMusic=Tp,a.KeyboardOff=qp,a.Lamp=Ep,a.LampCeiling=Op,a.LampDesk=Zp,a.LampFloor=Gp,a.LampWallDown=Ip,a.LampWallUp=Wp,a.LandPlot=Xp,a.Landmark=jp,a.Languages=Np,a.Laptop=Qp,a.Laptop2=p2,a.LaptopMinimal=p2,a.LaptopMinimalCheck=Kp,a.Lasso=Yp,a.LassoSelect=Jp,a.Laugh=_p,a.Layers=i2,a.Layers2=xp,a.Layers3=i2,a.Layout=f2,a.LayoutDashboard=ai,a.LayoutGrid=ti,a.LayoutList=hi,a.LayoutPanelLeft=di,a.LayoutPanelTop=ci,a.LayoutTemplate=Mi,a.Leaf=pi,a.LeafyGreen=ii,a.Lectern=ni,a.LetterText=W0,a.Library=ei,a.LibraryBig=li,a.LibrarySquare=s0,a.LifeBuoy=ri,a.Ligature=oi,a.Lightbulb=$i,a.LightbulbOff=vi,a.LineChart=Z,a.LineSquiggle=mi,a.Link=gi,a.Link2=si,a.Link2Off=yi,a.Linkedin=ui,a.List=Ui,a.ListCheck=Ci,a.ListChecks=Hi,a.ListChevronsDownUp=Ai,a.ListChevronsUpDown=wi,a.ListCollapse=Vi,a.ListEnd=Si,a.ListFilter=Li,a.ListFilterPlus=fi,a.ListIndentDecrease=o,a.ListIndentIncrease=v,a.ListMinus=ki,a.ListMusic=Bi,a.ListOrdered=Pi,a.ListPlus=Di,a.ListRestart=Fi,a.ListStart=zi,a.ListTodo=bi,a.ListTree=Ri,a.ListVideo=Ti,a.ListX=qi,a.Loader=Zi,a.Loader2=n2,a.LoaderCircle=n2,a.LoaderPinwheel=Oi,a.Locate=Wi,a.LocateFixed=Gi,a.LocateOff=Ii,a.LocationEdit=o2,a.Lock=Xi,a.LockKeyhole=Ei,a.LockKeyholeOpen=l2,a.LockOpen=e2,a.LogIn=ji,a.LogOut=Ni,a.Logs=Ki,a.Lollipop=Qi,a.Luggage=Ji,a.MSquare=g0,a.Magnet=Yi,a.Mail=Mn,a.MailCheck=_i,a.MailMinus=xi,a.MailOpen=an,a.MailPlus=tn,a.MailQuestion=r2,a.MailQuestionMark=r2,a.MailSearch=hn,a.MailWarning=dn,a.MailX=cn,a.Mailbox=pn,a.Mails=nn,a.Map=wn,a.MapMinus=ln,a.MapPin=Cn,a.MapPinCheck=rn,a.MapPinCheckInside=en,a.MapPinHouse=on,a.MapPinMinus=$n,a.MapPinMinusInside=vn,a.MapPinOff=mn,a.MapPinPen=o2,a.MapPinPlus=sn,a.MapPinPlusInside=yn,a.MapPinX=un,a.MapPinXInside=gn,a.MapPinned=Hn,a.MapPlus=An,a.Mars=Sn,a.MarsStroke=Vn,a.Martini=Ln,a.Maximize=kn,a.Maximize2=fn,a.Medal=Pn,a.Megaphone=Dn,a.MegaphoneOff=Bn,a.Meh=Fn,a.MemoryStick=zn,a.Menu=bn,a.MenuSquare=u0,a.Merge=Rn,a.MessageCircle=jn,a.MessageCircleCode=Tn,a.MessageCircleDashed=qn,a.MessageCircleHeart=Un,a.MessageCircleMore=On,a.MessageCircleOff=Zn,a.MessageCirclePlus=Gn,a.MessageCircleQuestion=v2,a.MessageCircleQuestionMark=v2,a.MessageCircleReply=In,a.MessageCircleWarning=Wn,a.MessageCircleX=En,a.MessageSquare=pl,a.MessageSquareCode=Xn,a.MessageSquareDashed=Nn,a.MessageSquareDiff=Kn,a.MessageSquareDot=Qn,a.MessageSquareHeart=Jn,a.MessageSquareLock=Yn,a.MessageSquareMore=_n,a.MessageSquareOff=xn,a.MessageSquarePlus=al,a.MessageSquareQuote=tl,a.MessageSquareReply=hl,a.MessageSquareShare=cl,a.MessageSquareText=dl,a.MessageSquareWarning=Ml,a.MessageSquareX=il,a.MessagesSquare=nl,a.Mic=el,a.Mic2=$2,a.MicOff=ll,a.MicVocal=$2,a.Microchip=rl,a.Microscope=ol,a.Microwave=ml,a.Milestone=vl,a.Milk=gl,a.MilkOff=$l,a.Minimize=sl,a.Minimize2=yl,a.Minus=ul,a.MinusCircle=e1,a.MinusSquare=C0,a.Monitor=Fl,a.MonitorCheck=Cl,a.MonitorCog=Hl,a.MonitorDot=Al,a.MonitorDown=wl,a.MonitorOff=Vl,a.MonitorPause=Ll,a.MonitorPlay=Sl,a.MonitorSmartphone=fl,a.MonitorSpeaker=kl,a.MonitorStop=Pl,a.MonitorUp=Bl,a.MonitorX=Dl,a.Moon=bl,a.MoonStar=zl,a.MoreHorizontal=b1,a.MoreVertical=z1,a.Mountain=Tl,a.MountainSnow=Rl,a.Mouse=Il,a.MouseOff=ql,a.MousePointer=Gl,a.MousePointer2=Ul,a.MousePointerBan=Ol,a.MousePointerClick=Zl,a.MousePointerSquareDashed=e0,a.Move=te,a.Move3D=m2,a.Move3d=m2,a.MoveDiagonal=El,a.MoveDiagonal2=Wl,a.MoveDown=Nl,a.MoveDownLeft=Xl,a.MoveDownRight=jl,a.MoveHorizontal=Kl,a.MoveLeft=Ql,a.MoveRight=Jl,a.MoveUp=xl,a.MoveUpLeft=Yl,a.MoveUpRight=_l,a.MoveVertical=ae,a.Music=Me,a.Music2=he,a.Music3=de,a.Music4=ce,a.Navigation=le,a.Navigation2=ie,a.Navigation2Off=pe,a.NavigationOff=ne,a.Network=ee,a.Newspaper=re,a.Nfc=oe,a.NonBinary=ve,a.Notebook=ge,a.NotebookPen=$e,a.NotebookTabs=me,a.NotebookText=ye,a.NotepadText=ue,a.NotepadTextDashed=se,a.Nut=He,a.NutOff=Ce,a.Octagon=we,a.OctagonAlert=y2,a.OctagonMinus=Ae,a.OctagonPause=g2,a.OctagonX=s2,a.Omega=Ve,a.Option=Se,a.Orbit=Le,a.Origami=Pe,a.Outdent=o,a.Package=Re,a.Package2=fe,a.PackageCheck=ke,a.PackageMinus=Be,a.PackageOpen=De,a.PackagePlus=Fe,a.PackageSearch=be,a.PackageX=ze,a.PaintBucket=Te,a.PaintRoller=qe,a.Paintbrush=Ue,a.Paintbrush2=u2,a.PaintbrushVertical=u2,a.Palette=Oe,a.Palmtree=N0,a.Panda=Ze,a.PanelBottom=We,a.PanelBottomClose=Ge,a.PanelBottomDashed=C2,a.PanelBottomInactive=C2,a.PanelBottomOpen=Ie,a.PanelLeft=V2,a.PanelLeftClose=H2,a.PanelLeftDashed=A2,a.PanelLeftInactive=A2,a.PanelLeftOpen=w2,a.PanelLeftRightDashed=Ee,a.PanelRight=Ne,a.PanelRightClose=Xe,a.PanelRightDashed=S2,a.PanelRightInactive=S2,a.PanelRightOpen=je,a.PanelTop=Ye,a.PanelTopBottomDashed=Ke,a.PanelTopClose=Qe,a.PanelTopDashed=L2,a.PanelTopInactive=L2,a.PanelTopOpen=Je,a.PanelsLeftBottom=_e,a.PanelsLeftRight=P1,a.PanelsRightBottom=xe,a.PanelsTopBottom=b2,a.PanelsTopLeft=f2,a.Paperclip=ar,a.Parentheses=tr,a.ParkingCircle=o1,a.ParkingCircleOff=r1,a.ParkingMeter=hr,a.ParkingSquare=w0,a.ParkingSquareOff=A0,a.PartyPopper=dr,a.Pause=cr,a.PauseCircle=v1,a.PauseOctagon=g2,a.PawPrint=Mr,a.PcCase=pr,a.Pen=P2,a.PenBox=p,a.PenLine=k2,a.PenOff=ir,a.PenSquare=p,a.PenTool=nr,a.Pencil=or,a.PencilLine=lr,a.PencilOff=er,a.PencilRuler=rr,a.Pentagon=vr,a.Percent=$r,a.PercentCircle=$1,a.PercentDiamond=D1,a.PercentSquare=V0,a.PersonStanding=mr,a.PhilippinePeso=yr,a.Phone=wr,a.PhoneCall=sr,a.PhoneForwarded=gr,a.PhoneIncoming=ur,a.PhoneMissed=Cr,a.PhoneOff=Hr,a.PhoneOutgoing=Ar,a.Pi=Vr,a.PiSquare=S0,a.Piano=Sr,a.Pickaxe=Lr,a.PictureInPicture=kr,a.PictureInPicture2=fr,a.PieChart=E,a.PiggyBank=Pr,a.Pilcrow=Fr,a.PilcrowLeft=Dr,a.PilcrowRight=Br,a.PilcrowSquare=L0,a.Pill=br,a.PillBottle=zr,a.Pin=Tr,a.PinOff=Rr,a.Pipette=qr,a.Pizza=Ur,a.Plane=Gr,a.PlaneLanding=Or,a.PlaneTakeoff=Zr,a.Play=Ir,a.PlayCircle=m1,a.PlaySquare=f0,a.Plug=Er,a.Plug2=Wr,a.PlugZap=B2,a.PlugZap2=B2,a.Plus=Xr,a.PlusCircle=y1,a.PlusSquare=k0,a.Pocket=Kr,a.PocketKnife=jr,a.Podcast=Nr,a.Pointer=Qr,a.PointerOff=Jr,a.Popcorn=Yr,a.Popsicle=_r,a.PoundSterling=xr,a.Power=ho,a.PowerCircle=s1,a.PowerOff=ao,a.PowerSquare=P0,a.Presentation=to,a.Printer=Mo,a.PrinterCheck=co,a.Projector=po,a.Proportions=io,a.Puzzle=lo,a.Pyramid=no,a.QrCode=eo,a.Quote=ro,a.Rabbit=oo,a.Radar=vo,a.Radiation=$o,a.Radical=yo,a.Radio=go,a.RadioReceiver=mo,a.RadioTower=so,a.Radius=uo,a.RailSymbol=Co,a.Rainbow=Ho,a.Rat=Ao,a.Ratio=wo,a.Receipt=zo,a.ReceiptCent=Vo,a.ReceiptEuro=So,a.ReceiptIndianRupee=Lo,a.ReceiptJapaneseYen=fo,a.ReceiptPoundSterling=ko,a.ReceiptRussianRuble=Bo,a.ReceiptSwissFranc=Po,a.ReceiptText=Do,a.ReceiptTurkishLira=Fo,a.RectangleCircle=bo,a.RectangleEllipsis=D2,a.RectangleGoggles=Ro,a.RectangleHorizontal=To,a.RectangleVertical=qo,a.Recycle=Uo,a.Redo=Go,a.Redo2=Oo,a.RedoDot=Zo,a.RefreshCcw=Io,a.RefreshCcwDot=Wo,a.RefreshCw=Xo,a.RefreshCwOff=Eo,a.Refrigerator=jo,a.Regex=No,a.RemoveFormatting=Ko,a.Repeat=Yo,a.Repeat1=Qo,a.Repeat2=Jo,a.Replace=xo,a.ReplaceAll=_o,a.Reply=tv,a.ReplyAll=av,a.Rewind=hv,a.Ribbon=dv,a.Rocket=cv,a.RockingChair=Mv,a.RollerCoaster=pv,a.Rose=iv,a.Rotate3D=F2,a.Rotate3d=F2,a.RotateCcw=ev,a.RotateCcwKey=nv,a.RotateCcwSquare=lv,a.RotateCw=ov,a.RotateCwSquare=rv,a.Route=$v,a.RouteOff=vv,a.Router=mv,a.Rows=z2,a.Rows2=z2,a.Rows3=b2,a.Rows4=yv,a.Rss=sv,a.Ruler=Cv,a.RulerDimensionLine=gv,a.RussianRuble=uv,a.Sailboat=Hv,a.Salad=Av,a.Sandwich=Vv,a.Satellite=Sv,a.SatelliteDish=wv,a.SaudiRiyal=Lv,a.Save=Pv,a.SaveAll=fv,a.SaveOff=kv,a.Scale=Bv,a.Scale3D=R2,a.Scale3d=R2,a.Scaling=Dv,a.Scan=Zv,a.ScanBarcode=Fv,a.ScanEye=zv,a.ScanFace=bv,a.ScanHeart=Rv,a.ScanLine=Tv,a.ScanQrCode=qv,a.ScanSearch=Ov,a.ScanText=Uv,a.ScatterChart=X,a.School=Gv,a.School2=J0,a.Scissors=Wv,a.ScissorsLineDashed=Iv,a.ScissorsSquare=B0,a.ScissorsSquareDashedBottom=t0,a.ScreenShare=Xv,a.ScreenShareOff=Ev,a.Scroll=Nv,a.ScrollText=jv,a.Search=_v,a.SearchCheck=Kv,a.SearchCode=Qv,a.SearchSlash=Jv,a.SearchX=Yv,a.Section=xv,a.Send=t$,a.SendHorizonal=T2,a.SendHorizontal=T2,a.SendToBack=a$,a.SeparatorHorizontal=h$,a.SeparatorVertical=d$,a.Server=p$,a.ServerCog=c$,a.ServerCrash=M$,a.ServerOff=i$,a.Settings=l$,a.Settings2=n$,a.Shapes=e$,a.Share=o$,a.Share2=r$,a.Sheet=v$,a.Shell=$$,a.Shield=V$,a.ShieldAlert=m$,a.ShieldBan=y$,a.ShieldCheck=s$,a.ShieldClose=U2,a.ShieldEllipsis=g$,a.ShieldHalf=u$,a.ShieldMinus=C$,a.ShieldOff=H$,a.ShieldPlus=A$,a.ShieldQuestion=q2,a.ShieldQuestionMark=q2,a.ShieldUser=w$,a.ShieldX=U2,a.Ship=S$,a.ShipWheel=f$,a.Shirt=L$,a.ShoppingBag=k$,a.ShoppingBasket=P$,a.ShoppingCart=B$,a.Shovel=D$,a.ShowerHead=F$,a.Shredder=z$,a.Shrimp=b$,a.Shrink=R$,a.Shrub=q$,a.Shuffle=U$,a.Sidebar=V2,a.SidebarClose=H2,a.SidebarOpen=w2,a.Sigma=T$,a.SigmaSquare=D0,a.Signal=W$,a.SignalHigh=O$,a.SignalLow=Z$,a.SignalMedium=G$,a.SignalZero=I$,a.Signature=E$,a.Signpost=j$,a.SignpostBig=X$,a.Siren=N$,a.SkipBack=K$,a.SkipForward=Q$,a.Skull=J$,a.Slack=Y$,a.Slash=_$,a.SlashSquare=F0,a.Slice=x$,a.Sliders=O2,a.SlidersHorizontal=am,a.SlidersVertical=O2,a.Smartphone=dm,a.SmartphoneCharging=hm,a.SmartphoneNfc=tm,a.Smile=Mm,a.SmilePlus=cm,a.Snail=pm,a.Snowflake=im,a.SoapDispenserDroplet=nm,a.Sofa=lm,a.SortAsc=w,a.SortDesc=C,a.Soup=em,a.Space=vm,a.Spade=rm,a.Sparkle=om,a.Sparkles=Z2,a.Speaker=$m,a.Speech=mm,a.SpellCheck=sm,a.SpellCheck2=ym,a.Spline=um,a.SplinePointer=gm,a.Split=Cm,a.SplitSquareHorizontal=z0,a.SplitSquareVertical=b0,a.Spool=Hm,a.Spotlight=Am,a.SprayCan=wm,a.Sprout=Vm,a.Square=Rm,a.SquareActivity=G2,a.SquareArrowDown=E2,a.SquareArrowDownLeft=I2,a.SquareArrowDownRight=W2,a.SquareArrowLeft=X2,a.SquareArrowOutDownLeft=j2,a.SquareArrowOutDownRight=K2,a.SquareArrowOutUpLeft=N2,a.SquareArrowOutUpRight=Q2,a.SquareArrowRight=J2,a.SquareArrowUp=x2,a.SquareArrowUpLeft=Y2,a.SquareArrowUpRight=_2,a.SquareAsterisk=a0,a.SquareBottomDashedScissors=t0,a.SquareChartGantt=$,a.SquareCheck=d0,a.SquareCheckBig=h0,a.SquareChevronDown=c0,a.SquareChevronLeft=M0,a.SquareChevronRight=p0,a.SquareChevronUp=i0,a.SquareCode=n0,a.SquareDashed=r0,a.SquareDashedBottom=Lm,a.SquareDashedBottomCode=Sm,a.SquareDashedKanban=l0,a.SquareDashedMousePointer=e0,a.SquareDashedTopSolid=fm,a.SquareDivide=v0,a.SquareDot=o0,a.SquareEqual=$0,a.SquareFunction=m0,a.SquareGanttChart=$,a.SquareKanban=y0,a.SquareLibrary=s0,a.SquareM=g0,a.SquareMenu=u0,a.SquareMinus=C0,a.SquareMousePointer=H0,a.SquareParking=w0,a.SquareParkingOff=A0,a.SquarePause=km,a.SquarePen=p,a.SquarePercent=V0,a.SquarePi=S0,a.SquarePilcrow=L0,a.SquarePlay=f0,a.SquarePlus=k0,a.SquarePower=P0,a.SquareRadical=Pm,a.SquareRoundCorner=Bm,a.SquareScissors=B0,a.SquareSigma=D0,a.SquareSlash=F0,a.SquareSplitHorizontal=z0,a.SquareSplitVertical=b0,a.SquareSquare=Dm,a.SquareStack=zm,a.SquareStar=Fm,a.SquareStop=bm,a.SquareTerminal=R0,a.SquareUser=T0,a.SquareUserRound=q0,a.SquareX=U0,a.SquaresExclude=Tm,a.SquaresIntersect=qm,a.SquaresSubtract=Um,a.SquaresUnite=Om,a.Squircle=Gm,a.SquircleDashed=Zm,a.Squirrel=Im,a.Stamp=Wm,a.Star=jm,a.StarHalf=Em,a.StarOff=Xm,a.Stars=Z2,a.StepBack=Nm,a.StepForward=Km,a.Stethoscope=Qm,a.Sticker=Jm,a.StickyNote=_m,a.StopCircle=u1,a.Store=Ym,a.StretchHorizontal=xm,a.StretchVertical=ay,a.Strikethrough=ty,a.Subscript=hy,a.Subtitles=F,a.Sun=iy,a.SunDim=cy,a.SunMedium=dy,a.SunMoon=py,a.SunSnow=My,a.Sunrise=ny,a.Sunset=ey,a.Superscript=ly,a.SwatchBook=ry,a.SwissFranc=oy,a.SwitchCamera=vy,a.Sword=$y,a.Swords=yy,a.Syringe=my,a.Table=Vy,a.Table2=sy,a.TableCellsMerge=gy,a.TableCellsSplit=uy,a.TableColumnsSplit=Cy,a.TableConfig=e,a.TableOfContents=Ay,a.TableProperties=Hy,a.TableRowsSplit=wy,a.Tablet=Ly,a.TabletSmartphone=Sy,a.Tablets=fy,a.Tag=ky,a.Tags=Py,a.Tally1=By,a.Tally2=Dy,a.Tally3=Fy,a.Tally4=zy,a.Tally5=by,a.Tangent=Ry,a.Target=qy,a.Telescope=Ty,a.Tent=Uy,a.TentTree=Oy,a.Terminal=Zy,a.TerminalSquare=R0,a.TestTube=Gy,a.TestTube2=O0,a.TestTubeDiagonal=O0,a.TestTubes=Iy,a.Text=m,a.TextAlignCenter=Z0,a.TextAlignEnd=G0,a.TextAlignJustify=I0,a.TextAlignStart=m,a.TextCursor=Ey,a.TextCursorInput=Wy,a.TextInitial=W0,a.TextQuote=Xy,a.TextSearch=jy,a.TextSelect=E0,a.TextSelection=E0,a.TextWrap=X0,a.Theater=Ny,a.Thermometer=Jy,a.ThermometerSnowflake=Ky,a.ThermometerSun=Qy,a.ThumbsDown=Yy,a.ThumbsUp=_y,a.Ticket=Ms,a.TicketCheck=xy,a.TicketMinus=as,a.TicketPercent=ts,a.TicketPlus=hs,a.TicketSlash=ds,a.TicketX=cs,a.Tickets=is,a.TicketsPlane=ps,a.Timer=es,a.TimerOff=ns,a.TimerReset=ls,a.ToggleLeft=rs,a.ToggleRight=os,a.Toilet=vs,a.ToolCase=$s,a.Tornado=ms,a.Torus=ys,a.Touchpad=gs,a.TouchpadOff=ss,a.TowerControl=us,a.ToyBrick=Cs,a.Tractor=Hs,a.TrafficCone=As,a.Train=j0,a.TrainFront=Vs,a.TrainFrontTunnel=ws,a.TrainTrack=Ss,a.TramFront=j0,a.Transgender=Ls,a.Trash=ks,a.Trash2=fs,a.TreeDeciduous=Ps,a.TreePalm=N0,a.TreePine=Bs,a.Trees=Ds,a.Trello=Fs,a.TrendingDown=zs,a.TrendingUp=Rs,a.TrendingUpDown=bs,a.Triangle=Os,a.TriangleAlert=K0,a.TriangleDashed=Ts,a.TriangleRight=qs,a.Trophy=Us,a.Truck=Gs,a.TruckElectric=Zs,a.TurkishLira=Is,a.Turntable=Ws,a.Turtle=Es,a.Tv=js,a.Tv2=Q0,a.TvMinimal=Q0,a.TvMinimalPlay=Xs,a.Twitch=Ns,a.Twitter=Ks,a.Type=Js,a.TypeOutline=Qs,a.Umbrella=_s,a.UmbrellaOff=Ys,a.Underline=xs,a.Undo=hg,a.Undo2=ag,a.UndoDot=tg,a.UnfoldHorizontal=dg,a.UnfoldVertical=cg,a.Ungroup=Mg,a.University=J0,a.Unlink=ig,a.Unlink2=pg,a.Unlock=e2,a.UnlockKeyhole=l2,a.Unplug=ng,a.Upload=lg,a.UploadCloud=L1,a.Usb=eg,a.User=Ag,a.User2=ha,a.UserCheck=rg,a.UserCheck2=Y0,a.UserCircle=H1,a.UserCircle2=C1,a.UserCog=og,a.UserCog2=_0,a.UserLock=vg,a.UserMinus=$g,a.UserMinus2=x0,a.UserPen=mg,a.UserPlus=yg,a.UserPlus2=aa,a.UserRound=ha,a.UserRoundCheck=Y0,a.UserRoundCog=_0,a.UserRoundMinus=x0,a.UserRoundPen=sg,a.UserRoundPlus=aa,a.UserRoundSearch=gg,a.UserRoundX=ta,a.UserSearch=ug,a.UserSquare=T0,a.UserSquare2=q0,a.UserStar=Cg,a.UserX=Hg,a.UserX2=ta,a.Users=wg,a.Users2=da,a.UsersRound=da,a.Utensils=Ma,a.UtensilsCrossed=ca,a.UtilityPole=Vg,a.Variable=Sg,a.Vault=Lg,a.VectorSquare=fg,a.Vegan=kg,a.VenetianMask=Pg,a.Venus=Dg,a.VenusAndMars=Bg,a.Verified=L,a.Vibrate=zg,a.VibrateOff=Fg,a.Video=Rg,a.VideoOff=bg,a.Videotape=Tg,a.View=qg,a.Voicemail=Ug,a.Volleyball=Og,a.Volume=Eg,a.Volume1=Zg,a.Volume2=Gg,a.VolumeOff=Wg,a.VolumeX=Ig,a.Vote=Xg,a.Wallet=Ng,a.Wallet2=pa,a.WalletCards=jg,a.WalletMinimal=pa,a.Wallpaper=Kg,a.Wand=Qg,a.Wand2=ia,a.WandSparkles=ia,a.Warehouse=Jg,a.WashingMachine=Yg,a.Watch=_g,a.Waves=au,a.WavesLadder=xg,a.Waypoints=tu,a.Webcam=hu,a.Webhook=cu,a.WebhookOff=du,a.Weight=Mu,a.Wheat=iu,a.WheatOff=pu,a.WholeWord=nu,a.Wifi=yu,a.WifiCog=lu,a.WifiHigh=eu,a.WifiLow=ru,a.WifiOff=ou,a.WifiPen=vu,a.WifiSync=$u,a.WifiZero=mu,a.Wind=gu,a.WindArrowDown=su,a.Wine=Cu,a.WineOff=uu,a.Workflow=Hu,a.Worm=Au,a.WrapText=X0,a.Wrench=Vu,a.X=wu,a.XCircle=A1,a.XOctagon=s2,a.XSquare=U0,a.Youtube=Su,a.Zap=fu,a.ZapOff=Lu,a.ZoomIn=ku,a.ZoomOut=Pu,a.createElement=ea,a.createIcons=Uu,a.icons=Bu}));
+//# sourceMappingURL=lucide.min.js.map
diff --git a/dockmon/stats-service/aggregator.go b/dockmon/stats-service/aggregator.go
new file mode 100644
index 0000000..e026e7e
--- /dev/null
+++ b/dockmon/stats-service/aggregator.go
@@ -0,0 +1,150 @@
+package main
+
+import (
+	"context"
+	"log"
+	"time"
+)
+
+// Aggregator aggregates container stats into host-level metrics
+type Aggregator struct {
+	cache             *StatsCache
+	streamManager     *StreamManager
+	aggregateInterval time.Duration
+}
+
+// NewAggregator creates a new aggregator
+func NewAggregator(cache *StatsCache, streamManager *StreamManager, interval time.Duration) *Aggregator {
+	return &Aggregator{
+		cache:             cache,
+		streamManager:     streamManager,
+		aggregateInterval: interval,
+	}
+}
+
+// Start begins the aggregation loop
+func (a *Aggregator) Start(ctx context.Context) {
+	ticker := time.NewTicker(a.aggregateInterval)
+	defer ticker.Stop()
+
+	log.Printf("Aggregator started (interval: %v)", a.aggregateInterval)
+
+	// Run once immediately
+	a.aggregate()
+
+	for {
+		select {
+		case <-ctx.Done():
+			log.Println("Aggregator stopped")
+			return
+		case <-ticker.C:
+			a.aggregate()
+		}
+	}
+}
+
+// aggregate calculates host-level stats from container stats
+func (a *Aggregator) aggregate() {
+	containerStats := a.cache.GetAllContainerStats()
+
+	// Group containers by host
+	hostContainers := make(map[string][]*ContainerStats)
+	for _, stats := range containerStats {
+		hostContainers[stats.HostID] = append(hostContainers[stats.HostID], stats)
+	}
+
+	// Aggregate stats for each host that has a registered Docker client
+	for hostID, containers := range hostContainers {
+		// Only aggregate if the host still has a registered Docker client
+		// This prevents recreating stats for hosts that were just deleted
+		if a.streamManager.HasHost(hostID) {
+			hostStats := a.aggregateHostStats(hostID, containers)
+			a.cache.UpdateHostStats(hostStats)
+		}
+	}
+}
+
+// aggregateHostStats aggregates stats for a single host
+func (a *Aggregator) aggregateHostStats(hostID string, containers []*ContainerStats) *HostStats {
+	if len(containers) == 0 {
+		return &HostStats{
+			HostID:         hostID,
+			ContainerCount: 0,
+		}
+	}
+
+	var (
+		totalCPU         float64
+		totalMemUsage    uint64
+		totalMemLimit    uint64
+		totalNetRx       uint64
+		totalNetTx       uint64
+		validContainers  int
+	)
+
+	const maxUint64 = ^uint64(0)
+
+	// Only count containers updated in the last 30 seconds
+	cutoff := time.Now().Add(-30 * time.Second)
+
+	for _, stats := range containers {
+		if stats.LastUpdate.Before(cutoff) {
+			continue // Skip stale stats
+		}
+
+		totalCPU += stats.CPUPercent
+		totalMemUsage += stats.MemoryUsage
+		totalMemLimit += stats.MemoryLimit
+
+		// Check for overflow before adding network bytes
+		if maxUint64-totalNetRx < stats.NetworkRx {
+			log.Printf("Warning: Network RX overflow prevented for host %s", truncateID(hostID, 8))
+			totalNetRx = maxUint64 // Cap at max instead of wrapping
+		} else {
+			totalNetRx += stats.NetworkRx
+		}
+
+		if maxUint64-totalNetTx < stats.NetworkTx {
+			log.Printf("Warning: Network TX overflow prevented for host %s", truncateID(hostID, 8))
+			totalNetTx = maxUint64
+		} else {
+			totalNetTx += stats.NetworkTx
+		}
+
+		validContainers++
+	}
+
+	// Calculate totals and percentages
+	var cpuPercent, memPercent float64
+
+	// CPU is sum of all container CPU percentages (represents total host CPU usage)
+	cpuPercent = totalCPU
+
+	if totalMemLimit > 0 {
+		memPercent = (float64(totalMemUsage) / float64(totalMemLimit)) * 100.0
+	}
+
+	// Round to 1 decimal place
+	cpuPercent = roundToDecimal(cpuPercent, 1)
+	memPercent = roundToDecimal(memPercent, 1)
+
+	return &HostStats{
+		HostID:           hostID,
+		CPUPercent:       cpuPercent,
+		MemoryPercent:    memPercent,
+		MemoryUsedBytes:  totalMemUsage,
+		MemoryLimitBytes: totalMemLimit,
+		NetworkRxBytes:   totalNetRx,
+		NetworkTxBytes:   totalNetTx,
+		ContainerCount:   validContainers,
+	}
+}
+
+// roundToDecimal rounds a float to n decimal places
+func roundToDecimal(value float64, places int) float64 {
+	shift := float64(1)
+	for i := 0; i < places; i++ {
+		shift *= 10
+	}
+	return float64(int(value*shift+0.5)) / shift
+}
diff --git a/dockmon/stats-service/cache.go b/dockmon/stats-service/cache.go
new file mode 100644
index 0000000..0c67bc3
--- /dev/null
+++ b/dockmon/stats-service/cache.go
@@ -0,0 +1,172 @@
+package main
+
+import (
+	"sync"
+	"time"
+)
+
+// ContainerStats holds real-time stats for a single container
+type ContainerStats struct {
+	ContainerID   string    `json:"container_id"`
+	ContainerName string    `json:"container_name"`
+	HostID        string    `json:"host_id"`
+	CPUPercent    float64   `json:"cpu_percent"`
+	MemoryUsage   uint64    `json:"memory_usage"`
+	MemoryLimit   uint64    `json:"memory_limit"`
+	MemoryPercent float64   `json:"memory_percent"`
+	NetworkRx     uint64    `json:"network_rx"`
+	NetworkTx     uint64    `json:"network_tx"`
+	DiskRead      uint64    `json:"disk_read"`
+	DiskWrite     uint64    `json:"disk_write"`
+	LastUpdate    time.Time `json:"last_update"`
+}
+
+// HostStats holds aggregated stats for a host
+type HostStats struct {
+	HostID            string    `json:"host_id"`
+	CPUPercent        float64   `json:"cpu_percent"`
+	MemoryPercent     float64   `json:"memory_percent"`
+	MemoryUsedBytes   uint64    `json:"memory_used_bytes"`
+	MemoryLimitBytes  uint64    `json:"memory_limit_bytes"`
+	NetworkRxBytes    uint64    `json:"network_rx_bytes"`
+	NetworkTxBytes    uint64    `json:"network_tx_bytes"`
+	ContainerCount    int       `json:"container_count"`
+	LastUpdate        time.Time `json:"last_update"`
+}
+
+// StatsCache is a thread-safe cache for container and host stats
+type StatsCache struct {
+	mu             sync.RWMutex
+	containerStats map[string]*ContainerStats // key: composite key (hostID:containerID)
+	hostStats      map[string]*HostStats      // key: hostID
+}
+
+// NewStatsCache creates a new stats cache
+func NewStatsCache() *StatsCache {
+	return &StatsCache{
+		containerStats: make(map[string]*ContainerStats),
+		hostStats:      make(map[string]*HostStats),
+	}
+}
+
+// UpdateContainerStats updates stats for a container
+func (c *StatsCache) UpdateContainerStats(stats *ContainerStats) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	stats.LastUpdate = time.Now()
+	// Use composite key to support containers with duplicate IDs on different hosts
+	compositeKey := stats.HostID + ":" + stats.ContainerID
+	c.containerStats[compositeKey] = stats
+}
+
+// GetContainerStats retrieves stats for a specific container
+func (c *StatsCache) GetContainerStats(containerID, hostID string) (*ContainerStats, bool) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	compositeKey := hostID + ":" + containerID
+	stats, ok := c.containerStats[compositeKey]
+	return stats, ok
+}
+
+// GetAllContainerStats returns all container stats
+func (c *StatsCache) GetAllContainerStats() map[string]*ContainerStats {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	// Return a copy to avoid race conditions
+	result := make(map[string]*ContainerStats, len(c.containerStats))
+	for k, v := range c.containerStats {
+		statsCopy := *v
+		result[k] = &statsCopy
+	}
+	return result
+}
+
+// RemoveContainerStats removes stats for a container (when it stops)
+func (c *StatsCache) RemoveContainerStats(containerID, hostID string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	compositeKey := hostID + ":" + containerID
+	delete(c.containerStats, compositeKey)
+}
+
+// UpdateHostStats updates aggregated stats for a host
+func (c *StatsCache) UpdateHostStats(stats *HostStats) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	stats.LastUpdate = time.Now()
+	c.hostStats[stats.HostID] = stats
+}
+
+// GetHostStats retrieves stats for a specific host
+func (c *StatsCache) GetHostStats(hostID string) (*HostStats, bool) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	stats, ok := c.hostStats[hostID]
+	return stats, ok
+}
+
+// GetAllHostStats returns all host stats
+func (c *StatsCache) GetAllHostStats() map[string]*HostStats {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	// Return a copy to avoid race conditions
+	result := make(map[string]*HostStats, len(c.hostStats))
+	for k, v := range c.hostStats {
+		statsCopy := *v
+		result[k] = &statsCopy
+	}
+	return result
+}
+
+// RemoveHostStats removes all stats for a specific host
+func (c *StatsCache) RemoveHostStats(hostID string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	// Remove host stats
+	delete(c.hostStats, hostID)
+
+	// Remove all container stats for this host
+	for id, stats := range c.containerStats {
+		if stats.HostID == hostID {
+			delete(c.containerStats, id)
+		}
+	}
+}
+
+// CleanStaleStats removes stats older than maxAge
+func (c *StatsCache) CleanStaleStats(maxAge time.Duration) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	now := time.Now()
+
+	// Clean container stats
+	for id, stats := range c.containerStats {
+		if now.Sub(stats.LastUpdate) > maxAge {
+			delete(c.containerStats, id)
+		}
+	}
+
+	// Clean host stats
+	for id, stats := range c.hostStats {
+		if now.Sub(stats.LastUpdate) > maxAge {
+			delete(c.hostStats, id)
+		}
+	}
+}
+
+// GetStats returns a summary of cache state
+func (c *StatsCache) GetStats() (containerCount, hostCount int) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	return len(c.containerStats), len(c.hostStats)
+}
diff --git a/dockmon/stats-service/event_broadcaster.go b/dockmon/stats-service/event_broadcaster.go
new file mode 100644
index 0000000..39f8580
--- /dev/null
+++ b/dockmon/stats-service/event_broadcaster.go
@@ -0,0 +1,126 @@
+package main
+
+import (
+	"encoding/json"
+	"log"
+	"sync"
+
+	"github.com/gorilla/websocket"
+)
+
+// EventBroadcaster manages WebSocket connections and broadcasts events
+type EventBroadcaster struct {
+	mu             sync.RWMutex
+	connections    map[*websocket.Conn]*sync.Mutex // Each connection has its own write mutex
+	maxConnections int
+}
+
+// NewEventBroadcaster creates a new event broadcaster
+func NewEventBroadcaster() *EventBroadcaster {
+	return &EventBroadcaster{
+		connections:    make(map[*websocket.Conn]*sync.Mutex),
+		maxConnections: 100, // Limit to 100 concurrent WebSocket connections
+	}
+}
+
+// AddConnection registers a new WebSocket connection
+func (eb *EventBroadcaster) AddConnection(conn *websocket.Conn) error {
+	eb.mu.Lock()
+	defer eb.mu.Unlock()
+
+	// Check connection limit
+	if len(eb.connections) >= eb.maxConnections {
+		log.Printf("WebSocket connection limit reached (%d), rejecting new connection", eb.maxConnections)
+		return &websocket.CloseError{Code: websocket.ClosePolicyViolation, Text: "Connection limit reached"}
+	}
+
+	eb.connections[conn] = &sync.Mutex{} // Create a dedicated mutex for this connection
+	log.Printf("WebSocket connected to events. Total connections: %d", len(eb.connections))
+	return nil
+}
+
+// RemoveConnection unregisters a WebSocket connection
+func (eb *EventBroadcaster) RemoveConnection(conn *websocket.Conn) {
+	eb.mu.Lock()
+	defer eb.mu.Unlock()
+	delete(eb.connections, conn)
+	log.Printf("WebSocket disconnected from events. Total connections: %d", len(eb.connections))
+}
+
+// Broadcast sends an event to all connected WebSocket clients
+func (eb *EventBroadcaster) Broadcast(event DockerEvent) {
+	// Marshal event to JSON
+	data, err := json.Marshal(event)
+	if err != nil {
+		log.Printf("Error marshaling event: %v", err)
+		return
+	}
+
+	// Track dead connections
+	var deadConnections []*websocket.Conn
+
+	// Get snapshot of connections with their mutexes
+	eb.mu.RLock()
+	connMutexes := make(map[*websocket.Conn]*sync.Mutex, len(eb.connections))
+	for conn, mu := range eb.connections {
+		connMutexes[conn] = mu
+	}
+	eb.mu.RUnlock()
+
+	// Send to all connections (with per-connection write lock)
+	for conn, mu := range connMutexes {
+		mu.Lock()
+		err := conn.WriteMessage(websocket.TextMessage, data)
+		mu.Unlock()
+
+		if err != nil {
+			log.Printf("Error sending event to WebSocket: %v", err)
+			deadConnections = append(deadConnections, conn)
+		}
+	}
+
+	// Clean up dead connections
+	if len(deadConnections) > 0 {
+		// Remove from map first (fast, under lock)
+		eb.mu.Lock()
+		var connectionsToClose []*websocket.Conn
+		for _, conn := range deadConnections {
+			// Only delete if connection still exists in map
+			if _, exists := eb.connections[conn]; exists {
+				delete(eb.connections, conn)
+				connectionsToClose = append(connectionsToClose, conn)
+			}
+		}
+		eb.mu.Unlock()
+
+		// Close connections outside lock (slow, can block)
+		for _, conn := range connectionsToClose {
+			conn.Close()
+		}
+	}
+}
+
+// GetConnectionCount returns the number of active WebSocket connections
+func (eb *EventBroadcaster) GetConnectionCount() int {
+	eb.mu.RLock()
+	defer eb.mu.RUnlock()
+	return len(eb.connections)
+}
+
+// CloseAll closes all WebSocket connections
+func (eb *EventBroadcaster) CloseAll() {
+	eb.mu.Lock()
+	var connectionsToClose []*websocket.Conn
+	for conn := range eb.connections {
+		connectionsToClose = append(connectionsToClose, conn)
+	}
+	eb.connections = make(map[*websocket.Conn]*sync.Mutex)
+	eb.mu.Unlock()
+
+	// Close connections outside lock (can block on network I/O)
+	for _, conn := range connectionsToClose {
+		conn.Close()
+	}
+
+	log.Println("Closed all event WebSocket connections")
+}
diff --git a/dockmon/stats-service/event_cache.go b/dockmon/stats-service/event_cache.go
new file mode 100644
index 0000000..3f72624
--- /dev/null
+++ b/dockmon/stats-service/event_cache.go
@@ -0,0 +1,106 @@
+package main
+
+import (
+	"sync"
+)
+
+// EventCache stores recent events for each host (ring buffer)
+type EventCache struct {
+	mu       sync.RWMutex
+	events   map[string][]DockerEvent // key: hostID, value: ring buffer of events
+	maxSize  int                      // maximum events to keep per host
+}
+
+// NewEventCache creates a new event cache
+func NewEventCache(maxSize int) *EventCache {
+	return &EventCache{
+		events:  make(map[string][]DockerEvent),
+		maxSize: maxSize,
+	}
+}
+
+// AddEvent adds an event to the cache for a specific host
+func (ec *EventCache) AddEvent(hostID string, event DockerEvent) {
+	ec.mu.Lock()
+	defer ec.mu.Unlock()
+
+	// Initialize slice if needed
+	if _, exists := ec.events[hostID]; !exists {
+		ec.events[hostID] = make([]DockerEvent, 0, ec.maxSize)
+	}
+
+	// Add event
+	ec.events[hostID] = append(ec.events[hostID], event)
+
+	// Trim if over max size (keep most recent)
+	if len(ec.events[hostID]) > ec.maxSize {
+		ec.events[hostID] = ec.events[hostID][len(ec.events[hostID])-ec.maxSize:]
+	}
+}
+
+// GetRecentEvents returns recent events for a specific host
+func (ec *EventCache) GetRecentEvents(hostID string, limit int) []DockerEvent {
+	ec.mu.RLock()
+	defer ec.mu.RUnlock()
+
+	events, exists := ec.events[hostID]
+	if !exists || len(events) == 0 {
+		return []DockerEvent{}
+	}
+
+	// Return last N events
+	if limit <= 0 || limit > len(events) {
+		limit = len(events)
+	}
+
+	// Return copy to avoid race conditions
+	result := make([]DockerEvent, limit)
+	copy(result, events[len(events)-limit:])
+	return result
+}
+
+// GetAllRecentEvents returns recent events for all hosts
+func (ec *EventCache) GetAllRecentEvents(limit int) map[string][]DockerEvent {
+	ec.mu.RLock()
+	defer ec.mu.RUnlock()
+
+	result := make(map[string][]DockerEvent)
+
+	for hostID, events := range ec.events {
+		if len(events) == 0 {
+			continue
+		}
+
+		// Get last N events
+		count := limit
+		if count <= 0 || count > len(events) {
+			count = len(events)
+		}
+
+		// Copy to avoid race conditions
+		hostEvents := make([]DockerEvent, count)
+		copy(hostEvents, events[len(events)-count:])
+		result[hostID] = hostEvents
+	}
+
+	return result
+}
+
+// ClearHost removes all cached events for a specific host
+func (ec *EventCache) ClearHost(hostID string) {
+	ec.mu.Lock()
+	defer ec.mu.Unlock()
+	delete(ec.events, hostID)
+}
+
+// GetStats returns cache statistics
+func (ec *EventCache) GetStats() (hostCount int, totalEvents int) {
+	ec.mu.RLock()
+	defer ec.mu.RUnlock()
+
+	hostCount = len(ec.events)
+	for _, events := range ec.events {
+		totalEvents += len(events)
+	}
+	return
+}
diff --git a/dockmon/stats-service/event_manager.go b/dockmon/stats-service/event_manager.go
new file mode 100644
index 0000000..cf0b3a7
--- /dev/null
+++ b/dockmon/stats-service/event_manager.go
@@ -0,0 +1,351 @@
+package main
+
+import (
+	"context"
+	"crypto/tls"
+	"crypto/x509"
+	"fmt"
+	"log"
+	"net"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/docker/docker/api/types/events"
+	"github.com/docker/docker/api/types/filters"
+	"github.com/docker/docker/client"
+)
+
+// DockerEvent represents a Docker container event
+type DockerEvent struct {
+	Action        string            `json:"action"`
+	ContainerID   string            `json:"container_id"`
+	ContainerName string            `json:"container_name"`
+	Image         string            `json:"image"`
+	HostID        string            `json:"host_id"`
+	Timestamp     string            `json:"timestamp"`
+	Attributes    map[string]string `json:"attributes"`
+}
+
+// EventManager manages Docker event streams for multiple hosts
+type EventManager struct {
+	mu           sync.RWMutex
+	hosts        map[string]*eventStream // key: hostID
+	broadcaster  *EventBroadcaster
+	eventCache   *EventCache
+}
+
+// eventStream represents a single Docker host event stream
+type eventStream struct {
+	hostID    string
+	hostAddr  string
+	client    *client.Client
+	ctx       context.Context
+	cancel    context.CancelFunc
+	active    bool
+}
+
+// createEventTLSOption creates a Docker client TLS option from PEM-encoded certificates
+func createEventTLSOption(caCertPEM, certPEM, keyPEM string) (client.Opt, error) {
+	// Parse CA certificate
+	caCertPool := x509.NewCertPool()
+	if !caCertPool.AppendCertsFromPEM([]byte(caCertPEM)) {
+		return nil, fmt.Errorf("failed to parse CA certificate")
+	}
+
+	// Parse client certificate and key
+	clientCert, err := tls.X509KeyPair([]byte(certPEM), []byte(keyPEM))
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse client certificate/key: %v", err)
+	}
+
+	// Create TLS config
+	tlsConfig := &tls.Config{
+		Certificates: []tls.Certificate{clientCert},
+		RootCAs:      caCertPool,
+		MinVersion:   tls.VersionTLS12,
+	}
+
+	// Create HTTP client with TLS transport and timeouts
+	// Note: No overall Timeout set because Docker API streaming operations (stats, events)
+	// are long-running connections that should not be killed by a timeout
+	httpClient := &http.Client{
+		Transport: &http.Transport{
+			DialContext: (&net.Dialer{
+				Timeout:   30 * time.Second, // Connection establishment timeout
+				KeepAlive: 30 * time.Second, // TCP keepalive interval
+			}).DialContext,
+			TLSClientConfig:       tlsConfig,
+			TLSHandshakeTimeout:   10 * time.Second,
+			IdleConnTimeout:       90 * time.Second,
+			ResponseHeaderTimeout: 10 * time.Second,
+		},
+	}
+
+	return client.WithHTTPClient(httpClient), nil
+}
+
+// NewEventManager creates a new event manager
+func NewEventManager(broadcaster *EventBroadcaster, cache *EventCache) *EventManager {
+	return &EventManager{
+		hosts:       make(map[string]*eventStream),
+		broadcaster: broadcaster,
+		eventCache:  cache,
+	}
+}
+
+// AddHost starts monitoring Docker events for a host
+func (em *EventManager) AddHost(hostID, hostAddress, tlsCACert, tlsCert, tlsKey string) error {
+	// Create Docker client FIRST (before acquiring lock or stopping old stream)
+	var dockerClient *client.Client
+	var err error
+
+	if hostAddress == "" || hostAddress == "unix:///var/run/docker.sock" {
+		// Local Docker socket
+		dockerClient, err = client.NewClientWithOpts(
+			client.FromEnv,
+			client.WithAPIVersionNegotiation(),
+		)
+	} else {
+		// Remote Docker host - check if TLS is needed
+		clientOpts := []client.Opt{
+			client.WithHost(hostAddress),
+			client.WithAPIVersionNegotiation(),
+		}
+
+		// If TLS certificates provided, configure TLS
+		if tlsCACert != "" && tlsCert != "" && tlsKey != "" {
+			tlsOpt, err := createEventTLSOption(tlsCACert, tlsCert, tlsKey)
+			if err != nil {
+				return fmt.Errorf("failed to create TLS config: %v", err)
+			}
+			clientOpts = append(clientOpts, tlsOpt)
+		}
+
+		dockerClient, err = client.NewClientWithOpts(clientOpts...)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	// Now that new client is successfully created, acquire lock and swap
+	em.mu.Lock()
+	defer em.mu.Unlock()
+
+	// If already monitoring, stop the old stream (only after new client succeeds)
+	if stream, exists := em.hosts[hostID]; exists && stream.active {
+		log.Printf("Stopping existing event monitoring for host %s to update", truncateID(hostID, 8))
+		stream.cancel()
+		stream.active = false
+		if stream.client != nil {
+			stream.client.Close()
+		}
+	}
+
+	// Create context for this stream
+	ctx, cancel := context.WithCancel(context.Background())
+
+	stream := &eventStream{
+		hostID:   hostID,
+		hostAddr: hostAddress,
+		client:   dockerClient,
+		ctx:      ctx,
+		cancel:   cancel,
+		active:   true,
+	}
+
+	em.hosts[hostID] = stream
+
+	// Start event stream in goroutine
+	go em.streamEvents(stream)
+
+	log.Printf("Started event monitoring for host %s (%s)", truncateID(hostID, 8), hostAddress)
+	return nil
+}
+
+// RemoveHost stops monitoring events for a host
+func (em *EventManager) RemoveHost(hostID string) {
+	em.mu.Lock()
+	defer em.mu.Unlock()
+
+	if stream, exists := em.hosts[hostID]; exists {
+		stream.cancel()
+		stream.active = false
+		if stream.client != nil {
+			stream.client.Close()
+		}
+
+		// Clear cached events for this host
+		em.eventCache.ClearHost(hostID)
+		delete(em.hosts, hostID)
+		log.Printf("Stopped event monitoring for host %s", truncateID(hostID, 8))
+	}
+}
+
+// StopAll stops all event monitoring
+func (em *EventManager) StopAll() {
+	em.mu.Lock()
+	defer em.mu.Unlock()
+
+	for hostID, stream := range em.hosts {
+		stream.cancel()
+		stream.active = false
+		if stream.client != nil {
+			stream.client.Close()
+		}
+		log.Printf("Stopped event monitoring for host %s", truncateID(hostID, 8))
+	}
+
+	em.hosts = make(map[string]*eventStream)
+}
+
+// GetActiveHosts returns count of active event streams
+func (em *EventManager) GetActiveHosts() int {
+	em.mu.RLock()
+	defer em.mu.RUnlock()
+	return len(em.hosts)
+}
+
+// streamEvents listens to Docker events for a specific host
+func (em *EventManager) streamEvents(stream *eventStream) {
+	defer func() {
+		if r := recover(); r != nil {
+			log.Printf("Recovered from panic in event stream for %s: %v", truncateID(stream.hostID, 8), r)
+		}
+	}()
+
+	// Retry loop with exponential backoff
+	backoff := time.Second
+	maxBackoff := 30 * time.Second
+	// Track if we've received any successful events (to know when to reset backoff)
+	receivedSuccessfulEvent := false
+
+	for {
+		select {
+		case <-stream.ctx.Done():
+			log.Printf("Event stream for host %s stopped", truncateID(stream.hostID, 8))
+			return
+		default:
+		}
+
+		// Listen to container events only
+		eventFilters := filters.NewArgs()
+		eventFilters.Add("type", "container")
+
+		eventOptions := events.ListOptions{
+			Filters: eventFilters,
+		}
+
+		eventsChan, errChan := stream.client.Events(stream.ctx, eventOptions)
+
+		for {
+			select {
+			case <-stream.ctx.Done():
+				return
+
+			case err := <-errChan:
+				if err != nil {
+					log.Printf("Event stream error for host %s: %v (retrying in %v)", truncateID(stream.hostID, 8), err, backoff)
+					time.Sleep(backoff)
+					// Only increase backoff if we never got a successful event
+					if !receivedSuccessfulEvent {
+						backoff = min(backoff*2, maxBackoff)
+					} else {
+						// We had a successful connection before, reset backoff
+						backoff = time.Second
+					}
+					goto reconnect
+				}
+
+			case event := <-eventsChan:
+				// Reset backoff on first successful event after reconnection
+				if !receivedSuccessfulEvent {
+					backoff = time.Second
+					receivedSuccessfulEvent = true
+				}
+
+				// Process the event with panic recovery
+				func() {
+					defer func() {
+						if r := recover(); r != nil {
+							log.Printf("Recovered from panic in processEvent for host %s: %v", truncateID(stream.hostID, 8), r)
+						}
+					}()
+					em.processEvent(stream.hostID, event)
+				}()
+			}
+		}
+
+	reconnect:
+		// Continue to next iteration (backoff sleep already happened above)
+	}
+}
+
+// processEvent converts Docker event to our format and broadcasts it
+func (em *EventManager) processEvent(hostID string, event events.Message) {
+	// Extract container info
+	containerID := event.Actor.ID
+
+	// Safely extract attributes with defensive access pattern
+	containerName := ""
+	image := ""
+	if attrs := event.Actor.Attributes; attrs != nil {
+		if name, ok := attrs["name"]; ok {
+			containerName = name
+		}
+		if img, ok := attrs["image"]; ok {
+			image = img
+		}
+	}
+
+	// Create our event
+	dockerEvent := DockerEvent{
+		Action:        string(event.Action),
+		ContainerID:   containerID,
+		ContainerName: containerName,
+		Image:         image,
+		HostID:        hostID,
+		Timestamp:     time.Unix(event.Time, 0).Format(time.RFC3339),
+		Attributes:    event.Actor.Attributes,
+	}
+
+	// Only log important events (not noisy exec_* events)
+	action := dockerEvent.Action
+	if action != "" && !isExecEvent(action) && isImportantEvent(action) {
+		log.Printf("Event: %s - container %s (%s) on host %s",
+			dockerEvent.Action,
+			dockerEvent.ContainerName,
+			truncateID(dockerEvent.ContainerID, 12),
+			truncateID(hostID, 8))
+	}
+
+	// Add to cache
+	em.eventCache.AddEvent(hostID, dockerEvent)
+
+	// Broadcast to all WebSocket clients
+	em.broadcaster.Broadcast(dockerEvent)
+}
+
+// isExecEvent checks if the event is an exec_* event (noisy)
+func isExecEvent(action string) bool {
+	return len(action) > 5 && action[:5] == "exec_"
+}
+
+// isImportantEvent checks if the event should be logged
+func isImportantEvent(action string) bool {
+	importantEvents := map[string]bool{
+		"create":        true,
+		"start":         true,
+		"stop":          true,
+		"die":           true,
+		"kill":          true,
+		"destroy":       true,
+		"pause":         true,
+		"unpause":       true,
+		"restart":       true,
+		"oom":           true,
+		"health_status": true,
+	}
+	return importantEvents[action]
+}
diff --git a/dockmon/stats-service/go.mod b/dockmon/stats-service/go.mod
new file mode 100644
index 0000000..5fa29b8
--- /dev/null
+++ b/dockmon/stats-service/go.mod
@@ -0,0 +1,40 @@
+module github.com/dockmon/stats-service
+
+go 1.23.0
+
+toolchain go1.23.12
+
+require (
+	github.com/docker/docker v27.5.1+incompatible
+	github.com/gorilla/websocket v1.5.3
+)
+
+require github.com/docker/go-connections v0.5.0 // indirect
+
+require (
+	github.com/Microsoft/go-winio v0.6.1 // indirect
+	github.com/containerd/log v0.1.0 // indirect
+	github.com/distribution/reference v0.6.0 // indirect
+	github.com/docker/go-units v0.5.0 // indirect
+	github.com/felixge/httpsnoop v1.0.4 // indirect
+	github.com/go-logr/logr v1.4.3 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/moby/docker-image-spec v1.3.1 // indirect
+	github.com/moby/term v0.5.0 // indirect
+	github.com/morikuni/aec v1.0.0 // indirect
+	github.com/opencontainers/go-digest v1.0.0 // indirect
+	github.com/opencontainers/image-spec v1.1.0 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.63.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/mod v0.8.0 // indirect
+	golang.org/x/sys v0.35.0 // indirect
+	golang.org/x/time v0.5.0 // indirect
+	golang.org/x/tools v0.6.0 // indirect
+	gotest.tools/v3 v3.5.1 // indirect
+)
diff --git a/dockmon/stats-service/go.sum b/dockmon/stats-service/go.sum
new file mode 100644
index 0000000..9035ffe
--- /dev/null
+++ b/dockmon/stats-service/go.sum
@@ -0,0 +1,128 @@
+github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 h1:UQHMgLO+TxOElx5B5HZ4hJQsoJ/PvUvKRhJHDQXO8P8=
+github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
+github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=
+github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
+github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM=
+github.com/cenkalti/backoff/v5 v5.0.3/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw=
+github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I=
+github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/distribution/reference v0.6.0 h1:0IXCQ5g4/QMHHkarYzh5l+u8T3t73zM5QvfrDyIgxBk=
+github.com/distribution/reference v0.6.0/go.mod h1:BbU0aIcezP1/5jX/8MP0YiH4SdvB5Y4f/wlDRiLyi3E=
+github.com/docker/docker v27.5.1+incompatible h1:4PYU5dnBYqRQi0294d1FBECqT9ECWeQAIfE8q4YnPY8=
+github.com/docker/docker v27.5.1+incompatible/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk=
+github.com/docker/go-connections v0.5.0 h1:USnMq7hx7gwdVZq1L49hLXaFtUdTADjXGp+uj1Br63c=
+github.com/docker/go-connections v0.5.0/go.mod h1:ov60Kzw0kKElRwhNs9UlUHAE/F9Fe6GLaXnqyDdmEXc=
+github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
+github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
+github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
+github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
+github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2 h1:8Tjv8EJ+pM1xP8mK6egEbD1OgnVTyacbefKhmbLhIhU=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2/go.mod h1:pkJQ2tZHJ0aFOVEEot6oZmaVEZcRme73eIFmhiVuRWs=
+github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/moby/docker-image-spec v1.3.1 h1:jMKff3w6PgbfSa69GfNg+zN/XLhfXJGnEx3Nl2EsFP0=
+github.com/moby/docker-image-spec v1.3.1/go.mod h1:eKmb5VW8vQEh/BAr2yvVNvuiJuY6UIocYsFu/DxxRpo=
+github.com/moby/term v0.5.0 h1:xt8Q1nalod/v7BqbG21f8mQPqH+xAaC9C3N3wfWbVP0=
+github.com/moby/term v0.5.0/go.mod h1:8FzsFHVUBGZdbDsJw/ot+X+d5HLUbvklYLJ9uGfcI3Y=
+github.com/morikuni/aec v1.0.0 h1:nP9CBfwrvYnBRgY6qfDQkygYDmYwOilePFkwzv4dU8A=
+github.com/morikuni/aec v1.0.0/go.mod h1:BbKIizmSmc5MMPqRYbxO4ZU0S0+P200+tUnFx7PXmsc=
+github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
+github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
+github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug=
+github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.63.0 h1:RbKq8BG0FI8OiXhBfcRtqqHcZcka+gU3cskNuf05R18=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.63.0/go.mod h1:h06DGIukJOevXaj/xrNjhi/2098RZzcLTbc0jDAUbsg=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0 h1:GqRJVj7UmLjCVyVJ3ZFLdPRmhDUp2zFmQe3RHIOsw24=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0/go.mod h1:ri3aaHSmCTVYu2AWv44YMauwAQc0aqI9gHKIcSbI1pU=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0 h1:aTL7F04bJHUlztTsNGJ2l+6he8c+y/b//eR0jjjemT4=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0/go.mod h1:kldtb7jDTeol0l3ewcmd8SDvx3EmIE7lyvqbasU3QC4=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
+go.opentelemetry.io/proto/otlp v1.7.1 h1:gTOMpGDb0WTBOP8JaO72iL3auEZhVmAQg4ipjOVAtj4=
+go.opentelemetry.io/proto/otlp v1.7.1/go.mod h1:b2rVh6rfI/s2pHWNlB7ILJcRALpcNDzKhACevjI+ZnE=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.8.0 h1:LUYupSeNrTNCGzR/hVBk2NHZO4hXcVaW1k4Qx7rjPx8=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
+golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
+golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
+golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.6.0 h1:BOw41kyTf3PuCW1pVQf8+Cyg8pMlkYB1oo9iJ6D/lKM=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/genproto/googleapis/api v0.0.0-20250825161204-c5933d9347a5 h1:BIRfGDEjiHRrk0QKZe3Xv2ieMhtgRGeLcZQ0mIVn4EY=
+google.golang.org/genproto/googleapis/api v0.0.0-20250825161204-c5933d9347a5/go.mod h1:j3QtIyytwqGr1JUDtYXwtMXWPKsEa5LtzIFN1Wn5WvE=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250825161204-c5933d9347a5 h1:eaY8u2EuxbRv7c3NiGK0/NedzVsCcV6hDuU5qPX5EGE=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250825161204-c5933d9347a5/go.mod h1:M4/wBTSeyLxupu3W3tJtOgB14jILAS/XWPSSa3TAlJc=
+google.golang.org/grpc v1.75.0 h1:+TW+dqTd2Biwe6KKfhE5JpiYIBWq865PhKGSXiivqt4=
+google.golang.org/grpc v1.75.0/go.mod h1:JtPAzKiq4v1xcAB2hydNlWI2RnF85XXcV0mhKXr2ecQ=
+google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc=
+google.golang.org/protobuf v1.36.8/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gotest.tools/v3 v3.5.1 h1:EENdUnS3pdur5nybKYIh2Vfgc8IUNBjxDPSjtiJcOzU=
+gotest.tools/v3 v3.5.1/go.mod h1:isy3WKz7GK6uNw/sbHzfKBLvlvXwUyV06n6brMxxopU=
diff --git a/dockmon/stats-service/main.go b/dockmon/stats-service/main.go
new file mode 100644
index 0000000..cc1a07a
--- /dev/null
+++ b/dockmon/stats-service/main.go
@@ -0,0 +1,569 @@
+package main
+
+import (
+	"context"
+	"crypto/rand"
+	"crypto/subtle"
+	"encoding/hex"
+	"encoding/json"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+// Configuration with environment variable support
+var config = struct {
+	TokenFilePath       string
+	Port                string
+	AggregationInterval time.Duration
+	EventCacheSize      int
+	CleanupInterval     time.Duration
+	MaxRequestBodySize  int64
+	AllowedOrigins      string
+}{
+	TokenFilePath:       getEnv("TOKEN_FILE_PATH", "/tmp/stats-service-token"),
+	Port:                getEnv("STATS_SERVICE_PORT", "8081"),
+	AggregationInterval: getEnvDuration("AGGREGATION_INTERVAL", "1s"),
+	EventCacheSize:      getEnvInt("EVENT_CACHE_SIZE", 100),
+	CleanupInterval:     getEnvDuration("CLEANUP_INTERVAL", "60s"),
+	MaxRequestBodySize:  getEnvInt64("MAX_REQUEST_BODY_SIZE", 1048576), // 1MB default
+	AllowedOrigins:      getEnv("ALLOWED_ORIGINS", "http://localhost:8080,http://127.0.0.1:8080,http://localhost,http://127.0.0.1"),
+}
+
+// getEnv gets environment variable with fallback
+func getEnv(key, fallback string) string {
+	if value := os.Getenv(key); value != "" {
+		return value
+	}
+	return fallback
+}
+
+// getEnvInt gets integer environment variable with fallback
+func getEnvInt(key string, fallback int) int {
+	if value := os.Getenv(key); value != "" {
+		if intVal, err := strconv.Atoi(value); err == nil {
+			return intVal
+		}
+	}
+	return fallback
+}
+
+// getEnvInt64 gets int64 environment variable with fallback
+func getEnvInt64(key string, fallback int64) int64 {
+	if value := os.Getenv(key); value != "" {
+		if intVal, err := strconv.ParseInt(value, 10, 64); err == nil {
+			return intVal
+		}
+	}
+	return fallback
+}
+
+// getEnvDuration gets duration environment variable with fallback
+func getEnvDuration(key string, fallback string) time.Duration {
+	value := getEnv(key, fallback)
+	if duration, err := time.ParseDuration(value); err == nil {
+		return duration
+	}
+	// Fallback parsing
+	if duration, err := time.ParseDuration(fallback); err == nil {
+		return duration
+	}
+	return 1 * time.Second // Ultimate fallback
+}
+
+// generateToken creates a cryptographically secure random token
+func generateToken() (string, error) {
+	bytes := make([]byte, 32) // 256-bit token
+	if _, err := rand.Read(bytes); err != nil {
+		return "", err
+	}
+	return hex.EncodeToString(bytes), nil
+}
+
+// limitRequestBody limits the size of request bodies
+func limitRequestBody(next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		r.Body = http.MaxBytesReader(w, r.Body, config.MaxRequestBodySize)
+		next(w, r)
+	}
+}
+
+// jsonResponse writes a JSON response and handles encoding errors
+func jsonResponse(w http.ResponseWriter, data interface{}) {
+	w.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(w).Encode(data); err != nil {
+		log.Printf("Error encoding JSON response: %v", err)
+		// Can't send error status if response already partially sent
+	}
+}
+
+// authMiddleware validates the Bearer token using constant-time comparison
+func authMiddleware(token string, next http.HandlerFunc) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		// Get Authorization header
+		authHeader := r.Header.Get("Authorization")
+		expectedAuth := "Bearer " + token
+
+		// Use constant-time comparison to prevent timing attacks
+		// Check length first (still constant-time for the comparison itself)
+		if len(authHeader) != len(expectedAuth) {
+			http.Error(w, "Unauthorized", http.StatusUnauthorized)
+			log.Printf("Unauthorized request from %s to %s (length mismatch)", r.RemoteAddr, r.URL.Path)
+			return
+		}
+
+		// Constant-time comparison of the full auth header
+		if subtle.ConstantTimeCompare([]byte(authHeader), []byte(expectedAuth)) != 1 {
+			http.Error(w, "Unauthorized", http.StatusUnauthorized)
+			log.Printf("Unauthorized request from %s to %s", r.RemoteAddr, r.URL.Path)
+			return
+		}
+
+		next(w, r)
+	}
+}
+
+func main() {
+	log.Println("Starting DockMon Stats Service...")
+
+	// Generate random token
+	token, err := generateToken()
+	if err != nil {
+		log.Fatalf("Failed to generate token: %v", err)
+	}
+
+	// Write token to file for Python backend
+	if err := os.WriteFile(config.TokenFilePath, []byte(token), 0600); err != nil {
+		log.Fatalf("Failed to write token file: %v", err)
+	}
+	log.Printf("Generated temporary auth token for stats service")
+	log.Printf("Configuration: port=%s, aggregation=%v, cache_size=%d, cleanup=%v",
+		config.Port, config.AggregationInterval, config.EventCacheSize, config.CleanupInterval)
+
+	// Create stats cache
+	cache := NewStatsCache()
+
+	// Create stream manager
+	streamManager := NewStreamManager(cache)
+
+	// Create aggregator with configured interval
+	aggregator := NewAggregator(cache, streamManager, config.AggregationInterval)
+
+	// Create event management components with configured cache size
+	eventCache := NewEventCache(config.EventCacheSize)
+	eventBroadcaster := NewEventBroadcaster()
+	eventManager := NewEventManager(eventBroadcaster, eventCache)
+
+	// Create context for graceful shutdown
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	// Start aggregator
+	go aggregator.Start(ctx)
+
+	// Start cleanup routine (remove stale stats every 60 seconds)
+	go func() {
+		ticker := time.NewTicker(60 * time.Second)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			case <-ticker.C:
+				cache.CleanStaleStats(60 * time.Second)
+			}
+		}
+	}()
+
+	// Create HTTP server
+	mux := http.NewServeMux()
+
+	// Health check endpoint
+	mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
+		_, totalEvents := eventCache.GetStats()
+		jsonResponse(w, map[string]interface{}{
+			"status":            "ok",
+			"service":           "dockmon-stats",
+			"stats_streams":     streamManager.GetStreamCount(),
+			"event_hosts":       eventManager.GetActiveHosts(),
+			"event_connections": eventBroadcaster.GetConnectionCount(),
+			"cached_events":     totalEvents,
+		})
+	})
+
+	// Get all host stats (main endpoint for Python backend) - PROTECTED
+	mux.HandleFunc("/api/stats/hosts", authMiddleware(token, func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		hostStats := cache.GetAllHostStats()
+		json.NewEncoder(w).Encode(hostStats)
+	}))
+
+	// Get stats for a specific host - PROTECTED
+	mux.HandleFunc("/api/stats/host/", authMiddleware(token, func(w http.ResponseWriter, r *http.Request) {
+		hostID := r.URL.Path[len("/api/stats/host/"):]
+		if hostID == "" {
+			http.Error(w, "host_id required", http.StatusBadRequest)
+			return
+		}
+
+		stats, ok := cache.GetHostStats(hostID)
+		if !ok {
+			http.NotFound(w, r)
+			return
+		}
+
+		jsonResponse(w,stats)
+	}))
+
+	// Get all container stats (for debugging) - PROTECTED
+	mux.HandleFunc("/api/stats/containers", authMiddleware(token, func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		containerStats := cache.GetAllContainerStats()
+		json.NewEncoder(w).Encode(containerStats)
+	}))
+
+	// Start stream for a container (called by Python backend) - PROTECTED
+	mux.HandleFunc("/api/streams/start", authMiddleware(token, limitRequestBody(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+
+		var req struct {
+			ContainerID   string `json:"container_id"`
+			ContainerName string `json:"container_name"`
+			HostID        string `json:"host_id"`
+		}
+
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		// Validate required fields
+		if req.ContainerID == "" || req.HostID == "" {
+			http.Error(w, "container_id and host_id are required", http.StatusBadRequest)
+			return
+		}
+
+		if err := streamManager.StartStream(ctx, req.ContainerID, req.ContainerName, req.HostID); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]string{"status": "started"})
+	})))
+
+	// Stop stream for a container - PROTECTED
+	mux.HandleFunc("/api/streams/stop", authMiddleware(token, limitRequestBody(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+
+		var req struct {
+			ContainerID string `json:"container_id"`
+			HostID      string `json:"host_id"`
+		}
+
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		// Validate required fields
+		if req.ContainerID == "" || req.HostID == "" {
+			http.Error(w, "container_id and host_id are required", http.StatusBadRequest)
+			return
+		}
+
+		streamManager.StopStream(req.ContainerID, req.HostID)
+
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]string{"status": "stopped"})
+	})))
+
+	// Add Docker host - PROTECTED
+	mux.HandleFunc("/api/hosts/add", authMiddleware(token, func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+
+		var req struct {
+			HostID      string `json:"host_id"`
+			HostAddress string `json:"host_address"`
+			TLSCACert   string `json:"tls_ca_cert,omitempty"`
+			TLSCert     string `json:"tls_cert,omitempty"`
+			TLSKey      string `json:"tls_key,omitempty"`
+		}
+
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		// Validate required fields
+		if req.HostID == "" || req.HostAddress == "" {
+			http.Error(w, "host_id and host_address are required", http.StatusBadRequest)
+			return
+		}
+
+		if err := streamManager.AddDockerHost(req.HostID, req.HostAddress, req.TLSCACert, req.TLSCert, req.TLSKey); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]string{"status": "added"})
+	}))
+
+	// Remove Docker host - PROTECTED
+	mux.HandleFunc("/api/hosts/remove", authMiddleware(token, func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+
+		var req struct {
+			HostID string `json:"host_id"`
+		}
+
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		// Validate required fields
+		if req.HostID == "" {
+			http.Error(w, "host_id is required", http.StatusBadRequest)
+			return
+		}
+
+		streamManager.RemoveDockerHost(req.HostID)
+
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]string{"status": "removed"})
+	}))
+
+	// Debug endpoint - PROTECTED
+	mux.HandleFunc("/debug/stats", authMiddleware(token, func(w http.ResponseWriter, r *http.Request) {
+		containerCount, hostCount := cache.GetStats()
+		jsonResponse(w, map[string]interface{}{
+			"streams":    streamManager.GetStreamCount(),
+			"containers": containerCount,
+			"hosts":      hostCount,
+		})
+	}))
+
+	// === Event Monitoring Endpoints ===
+
+	// Start monitoring events for a host - PROTECTED
+	mux.HandleFunc("/api/events/hosts/add", authMiddleware(token, func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+
+		var req struct {
+			HostID      string `json:"host_id"`
+			HostAddress string `json:"host_address"`
+			TLSCACert   string `json:"tls_ca_cert,omitempty"`
+			TLSCert     string `json:"tls_cert,omitempty"`
+			TLSKey      string `json:"tls_key,omitempty"`
+		}
+
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		// Validate required fields
+		if req.HostID == "" || req.HostAddress == "" {
+			http.Error(w, "host_id and host_address are required", http.StatusBadRequest)
+			return
+		}
+
+		if err := eventManager.AddHost(req.HostID, req.HostAddress, req.TLSCACert, req.TLSCert, req.TLSKey); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]string{"status": "started"})
+	}))
+
+	// Stop monitoring events for a host - PROTECTED
+	mux.HandleFunc("/api/events/hosts/remove", authMiddleware(token, func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+
+		var req struct {
+			HostID string `json:"host_id"`
+		}
+
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		// Validate required fields
+		if req.HostID == "" {
+			http.Error(w, "host_id is required", http.StatusBadRequest)
+			return
+		}
+
+		eventManager.RemoveHost(req.HostID)
+
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]string{"status": "stopped"})
+	}))
+
+	// Get recent events - PROTECTED
+	mux.HandleFunc("/api/events/recent", authMiddleware(token, func(w http.ResponseWriter, r *http.Request) {
+		hostID := r.URL.Query().Get("host_id")
+
+		var events interface{}
+		if hostID != "" {
+			// Get events for specific host
+			events = eventCache.GetRecentEvents(hostID, 50)
+		} else {
+			// Get events for all hosts
+			events = eventCache.GetAllRecentEvents(50)
+		}
+
+		jsonResponse(w,events)
+	}))
+
+	// WebSocket endpoint for event streaming - PROTECTED
+	mux.HandleFunc("/ws/events", func(w http.ResponseWriter, r *http.Request) {
+		// Validate token from query parameter or header
+		tokenParam := r.URL.Query().Get("token")
+		authHeader := r.Header.Get("Authorization")
+
+		validToken := false
+		if tokenParam == token {
+			validToken = true
+		} else if authHeader == "Bearer "+token {
+			validToken = true
+		}
+
+		if !validToken {
+			http.Error(w, "Unauthorized", http.StatusUnauthorized)
+			log.Printf("Unauthorized WebSocket connection attempt from %s", r.RemoteAddr)
+			return
+		}
+
+		// Upgrade to WebSocket
+		upgrader := websocket.Upgrader{
+			CheckOrigin: func(r *http.Request) bool {
+				origin := r.Header.Get("Origin")
+				if origin == "" {
+					return true // Allow same-origin requests
+				}
+				// Check against configured allowed origins
+				allowedOrigins := strings.Split(config.AllowedOrigins, ",")
+				for _, allowed := range allowedOrigins {
+					if strings.TrimSpace(allowed) == origin {
+						return true
+					}
+				}
+				return false
+			},
+		}
+
+		conn, err := upgrader.Upgrade(w, r, nil)
+		if err != nil {
+			log.Printf("WebSocket upgrade failed: %v", err)
+			return
+		}
+
+		// Register connection
+		if err := eventBroadcaster.AddConnection(conn); err != nil {
+			log.Printf("Failed to register connection: %v", err)
+			conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.ClosePolicyViolation, "Connection limit reached"))
+			conn.Close()
+			return
+		}
+
+		// Handle connection (read loop to detect disconnect)
+		go func() {
+			defer func() {
+				eventBroadcaster.RemoveConnection(conn)
+				conn.Close()
+			}()
+
+			for {
+				// Read messages (just to detect disconnect, we don't expect any)
+				_, _, err := conn.ReadMessage()
+				if err != nil {
+					break
+				}
+			}
+		}()
+	})
+
+	// Create server with configured port
+	srv := &http.Server{
+		Addr:         ":" + config.Port,
+		Handler:      mux,
+		ReadTimeout:  10 * time.Second,
+		WriteTimeout: 10 * time.Second,
+		IdleTimeout:  60 * time.Second,
+	}
+
+	// Start server in goroutine
+	go func() {
+		log.Printf("Stats service listening on %s", srv.Addr)
+		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			log.Fatalf("Server error: %v", err)
+		}
+	}()
+
+	// Wait for interrupt signal
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)
+	<-sigChan
+
+	log.Println("Shutting down stats service...")
+
+	// Graceful shutdown
+	shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer shutdownCancel()
+
+	// Stop all stats streams
+	streamManager.StopAllStreams()
+
+	// Stop all event monitoring
+	eventManager.StopAll()
+
+	// Close all event WebSocket connections
+	eventBroadcaster.CloseAll()
+
+	// Stop HTTP server
+	if err := srv.Shutdown(shutdownCtx); err != nil {
+		log.Printf("Server shutdown error: %v", err)
+	}
+
+	// Cancel context to stop aggregator
+	cancel()
+
+	// Clean up token file
+	if err := os.Remove(config.TokenFilePath); err != nil {
+		log.Printf("Warning: Failed to remove token file: %v", err)
+	} else {
+		log.Println("Removed token file")
+	}
+
+	log.Println("Stats service stopped")
+}
diff --git a/dockmon/stats-service/streamer.go b/dockmon/stats-service/streamer.go
new file mode 100644
index 0000000..be8825d
--- /dev/null
+++ b/dockmon/stats-service/streamer.go
@@ -0,0 +1,440 @@
+package main
+
+import (
+	"context"
+	"crypto/tls"
+	"crypto/x509"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/client"
+)
+
+// ContainerInfo holds basic container information
+type ContainerInfo struct {
+	ID     string
+	Name   string
+	HostID string
+}
+
+// createTLSOption creates a Docker client TLS option from PEM-encoded certificates
+func createTLSOption(caCertPEM, certPEM, keyPEM string) (client.Opt, error) {
+	// Parse CA certificate
+	caCertPool := x509.NewCertPool()
+	if !caCertPool.AppendCertsFromPEM([]byte(caCertPEM)) {
+		return nil, fmt.Errorf("failed to parse CA certificate")
+	}
+
+	// Parse client certificate and key
+	clientCert, err := tls.X509KeyPair([]byte(certPEM), []byte(keyPEM))
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse client certificate/key: %v", err)
+	}
+
+	// Create TLS config
+	tlsConfig := &tls.Config{
+		Certificates: []tls.Certificate{clientCert},
+		RootCAs:      caCertPool,
+		MinVersion:   tls.VersionTLS12,
+	}
+
+	// Create HTTP client with TLS transport and timeouts
+	// Note: No overall Timeout set because Docker API streaming operations (stats, events)
+	// are long-running connections that should not be killed by a timeout
+	httpClient := &http.Client{
+		Transport: &http.Transport{
+			DialContext: (&net.Dialer{
+				Timeout:   30 * time.Second, // Connection establishment timeout
+				KeepAlive: 30 * time.Second, // TCP keepalive interval
+			}).DialContext,
+			TLSClientConfig:       tlsConfig,
+			TLSHandshakeTimeout:   10 * time.Second,
+			IdleConnTimeout:       90 * time.Second,
+			ResponseHeaderTimeout: 10 * time.Second,
+		},
+	}
+
+	return client.WithHTTPClient(httpClient), nil
+}
+
+// StreamManager manages persistent stats streams for all containers
+type StreamManager struct {
+	cache      *StatsCache
+	clients    map[string]*client.Client // hostID -> Docker client
+	clientsMu  sync.RWMutex
+	streams    map[string]context.CancelFunc // composite key (hostID:containerID) -> cancel function
+	streamsMu  sync.RWMutex
+	containers map[string]*ContainerInfo // composite key (hostID:containerID) -> info
+	containersMu sync.RWMutex
+}
+
+// NewStreamManager creates a new stream manager
+func NewStreamManager(cache *StatsCache) *StreamManager {
+	return &StreamManager{
+		cache:      cache,
+		clients:    make(map[string]*client.Client),
+		streams:    make(map[string]context.CancelFunc),
+		containers: make(map[string]*ContainerInfo),
+	}
+}
+
+// AddDockerHost adds a Docker host client
+func (sm *StreamManager) AddDockerHost(hostID, hostAddress, tlsCACert, tlsCert, tlsKey string) error {
+	// Create Docker client for this host FIRST (before acquiring lock)
+	var cli *client.Client
+	var err error
+
+	if hostAddress == "" || hostAddress == "unix:///var/run/docker.sock" {
+		// Local Docker socket
+		cli, err = client.NewClientWithOpts(
+			client.FromEnv,
+			client.WithAPIVersionNegotiation(),
+		)
+	} else {
+		// Remote Docker host - check if TLS is needed
+		clientOpts := []client.Opt{
+			client.WithHost(hostAddress),
+			client.WithAPIVersionNegotiation(),
+		}
+
+		// If TLS certificates provided, configure TLS
+		if tlsCACert != "" && tlsCert != "" && tlsKey != "" {
+			tlsOpt, err := createTLSOption(tlsCACert, tlsCert, tlsKey)
+			if err != nil {
+				return fmt.Errorf("failed to create TLS config: %v", err)
+			}
+			clientOpts = append(clientOpts, tlsOpt)
+		}
+
+		cli, err = client.NewClientWithOpts(clientOpts...)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	// Track whether client was successfully stored to prevent leak
+	clientStored := false
+	defer func() {
+		if !clientStored && cli != nil {
+			cli.Close()
+			log.Printf("Cleaned up unstored Docker client for host %s", truncateID(hostID, 8))
+		}
+	}()
+
+	// Now that new client is successfully created, acquire lock and swap
+	sm.clientsMu.Lock()
+	defer sm.clientsMu.Unlock()
+
+	// Close existing client if it exists (only after new one succeeds)
+	if existingClient, exists := sm.clients[hostID]; exists {
+		existingClient.Close()
+		log.Printf("Closed existing Docker client for host %s", truncateID(hostID, 8))
+	}
+
+	sm.clients[hostID] = cli
+	clientStored = true // Mark as successfully stored
+	log.Printf("Added Docker host: %s (%s)", truncateID(hostID, 8), hostAddress)
+
+	// Initialize host stats with zero values so the host appears immediately in the UI
+	sm.cache.UpdateHostStats(&HostStats{
+		HostID:         hostID,
+		ContainerCount: 0,
+	})
+
+	return nil
+}
+
+// RemoveDockerHost removes a Docker host client and stops all its streams
+func (sm *StreamManager) RemoveDockerHost(hostID string) {
+	// First, find all containers for this host
+	sm.containersMu.RLock()
+	containersToStop := make([]string, 0)
+	for compositeKey, info := range sm.containers {
+		if info.HostID == hostID {
+			containersToStop = append(containersToStop, compositeKey)
+		}
+	}
+	sm.containersMu.RUnlock()
+
+	// Stop all streams for containers on this host
+	// Do this BEFORE closing the client to avoid streams trying to use a closed client
+	for _, compositeKey := range containersToStop {
+		// Extract container ID from composite key (format: hostID:containerID)
+		parts := strings.SplitN(compositeKey, ":", 2)
+		if len(parts) == 2 {
+			sm.StopStream(parts[1], parts[0]) // containerID, hostID
+		}
+	}
+
+	// Now close and remove the Docker client
+	sm.clientsMu.Lock()
+	defer sm.clientsMu.Unlock()
+	if cli, exists := sm.clients[hostID]; exists {
+		cli.Close()
+		delete(sm.clients, hostID)
+		log.Printf("Removed Docker host: %s", truncateID(hostID, 8))
+	}
+
+	// Remove all stats for this host from cache
+	sm.cache.RemoveHostStats(hostID)
+}
+
+// StartStream starts a persistent stats stream for a container
+func (sm *StreamManager) StartStream(ctx context.Context, containerID, containerName, hostID string) error {
+	// Create composite key to support containers with duplicate IDs on different hosts
+	compositeKey := fmt.Sprintf("%s:%s", hostID, containerID)
+
+	// Acquire locks in consistent order: clientsMu → streamsMu → containersMu (when needed)
+	sm.clientsMu.RLock()
+	sm.streamsMu.Lock()
+
+	// Check if stream already exists
+	if _, exists := sm.streams[compositeKey]; exists {
+		sm.streamsMu.Unlock()
+		sm.clientsMu.RUnlock()
+		return nil // Already streaming
+	}
+
+	// Check if client exists
+	_, clientExists := sm.clients[hostID]
+	if !clientExists {
+		sm.streamsMu.Unlock()
+		sm.clientsMu.RUnlock()
+		log.Printf("Warning: No Docker client for host %s", truncateID(hostID, 8))
+		return nil
+	}
+
+	// Create cancellable context for this stream
+	streamCtx, cancel := context.WithCancel(ctx)
+	sm.streams[compositeKey] = cancel
+
+	// Release locks before acquiring containersMu to prevent nested locking
+	sm.streamsMu.Unlock()
+	sm.clientsMu.RUnlock()
+
+	// Store container info with separate lock
+	sm.containersMu.Lock()
+	sm.containers[compositeKey] = &ContainerInfo{
+		ID:     containerID,
+		Name:   containerName,
+		HostID: hostID,
+	}
+	sm.containersMu.Unlock()
+
+	// Start streaming goroutine (no locks held)
+	go sm.streamStats(streamCtx, containerID, containerName, hostID)
+
+	log.Printf("Started stats stream for container %s (%s) on host %s", containerName, truncateID(containerID, 12), truncateID(hostID, 12))
+	return nil
+}
+
+// StopStream stops the stats stream for a container
+func (sm *StreamManager) StopStream(containerID, hostID string) {
+	// Create composite key to support containers with duplicate IDs on different hosts
+	compositeKey := fmt.Sprintf("%s:%s", hostID, containerID)
+
+	sm.streamsMu.Lock()
+	defer sm.streamsMu.Unlock()
+	cancel, exists := sm.streams[compositeKey]
+	if exists {
+		cancel()
+		delete(sm.streams, compositeKey)
+	}
+
+	sm.containersMu.Lock()
+	defer sm.containersMu.Unlock()
+	delete(sm.containers, compositeKey)
+
+	// Remove from cache
+	sm.cache.RemoveContainerStats(containerID, hostID)
+
+	log.Printf("Stopped stats stream for container %s", truncateID(containerID, 12))
+}
+
+// streamStats maintains a persistent stats stream for a single container
+func (sm *StreamManager) streamStats(ctx context.Context, containerID, containerName, hostID string) {
+	defer func() {
+		if r := recover(); r != nil {
+			log.Printf("Recovered from panic in stats stream for %s: %v", truncateID(containerID, 12), r)
+		}
+	}()
+
+	// Retry loop - restart stream if it fails
+	backoff := time.Second
+	maxBackoff := 30 * time.Second
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		default:
+		}
+
+		// Get current Docker client (may have changed if host was updated)
+		sm.clientsMu.RLock()
+		cli, ok := sm.clients[hostID]
+		sm.clientsMu.RUnlock() // Manual unlock needed - we're in a loop
+
+		if !ok {
+			log.Printf("No Docker client for host %s (container %s), retrying in %v", truncateID(hostID, 8), truncateID(containerID, 12), backoff)
+			time.Sleep(backoff)
+			backoff = min(backoff*2, maxBackoff)
+			continue
+		}
+
+		// Open stats stream
+		stats, err := cli.ContainerStats(ctx, containerID, true) // stream=true
+		if err != nil {
+			log.Printf("Error opening stats stream for %s: %v (retrying in %v)", truncateID(containerID, 12), err, backoff)
+			time.Sleep(backoff)
+			backoff = min(backoff*2, maxBackoff)
+			continue
+		}
+
+		// Reset backoff on successful connection
+		backoff = time.Second
+
+		// Read stats from stream
+		decoder := json.NewDecoder(stats.Body)
+
+		for {
+			select {
+			case <-ctx.Done():
+				stats.Body.Close()
+				return
+			default:
+			}
+
+			var stat types.StatsJSON
+			if err := decoder.Decode(&stat); err != nil {
+				stats.Body.Close()
+				if err == io.EOF || err == context.Canceled {
+					log.Printf("Stats stream ended for %s", truncateID(containerID, 12))
+				} else {
+					log.Printf("Error decoding stats for %s: %v", truncateID(containerID, 12), err)
+				}
+				break // Break inner loop, will retry in outer loop
+			}
+
+			// Calculate and cache stats
+			sm.processStats(&stat, containerID, containerName, hostID)
+		}
+
+		// Brief pause before reconnecting
+		time.Sleep(time.Second)
+	}
+}
+
+// processStats calculates metrics from raw Docker stats
+func (sm *StreamManager) processStats(stat *types.StatsJSON, containerID, containerName, hostID string) {
+	// Calculate CPU percentage
+	cpuPercent := calculateCPUPercent(stat)
+
+	// Memory stats
+	memUsage := stat.MemoryStats.Usage
+	memLimit := stat.MemoryStats.Limit
+	memPercent := 0.0
+	if memLimit > 0 {
+		memPercent = (float64(memUsage) / float64(memLimit)) * 100.0
+	}
+
+	// Network stats
+	var netRx, netTx uint64
+	for _, net := range stat.Networks {
+		netRx += net.RxBytes
+		netTx += net.TxBytes
+	}
+
+	// Disk I/O stats
+	var diskRead, diskWrite uint64
+	for _, bio := range stat.BlkioStats.IoServiceBytesRecursive {
+		if bio.Op == "Read" {
+			diskRead += bio.Value
+		} else if bio.Op == "Write" {
+			diskWrite += bio.Value
+		}
+	}
+
+	// Update cache
+	sm.cache.UpdateContainerStats(&ContainerStats{
+		ContainerID:   containerID,
+		ContainerName: containerName,
+		HostID:        hostID,
+		CPUPercent:    roundToDecimal(cpuPercent, 1),
+		MemoryUsage:   memUsage,
+		MemoryLimit:   memLimit,
+		MemoryPercent: roundToDecimal(memPercent, 1),
+		NetworkRx:     netRx,
+		NetworkTx:     netTx,
+		DiskRead:      diskRead,
+		DiskWrite:     diskWrite,
+	})
+}
+
+// calculateCPUPercent calculates CPU percentage from Docker stats
+func calculateCPUPercent(stat *types.StatsJSON) float64 {
+	// CPU calculation similar to `docker stats` command
+	cpuDelta := float64(stat.CPUStats.CPUUsage.TotalUsage) - float64(stat.PreCPUStats.CPUUsage.TotalUsage)
+	systemDelta := float64(stat.CPUStats.SystemUsage) - float64(stat.PreCPUStats.SystemUsage)
+
+	if systemDelta > 0.0 && cpuDelta > 0.0 {
+		numCPUs := float64(len(stat.CPUStats.CPUUsage.PercpuUsage))
+		if numCPUs == 0 {
+			numCPUs = 1.0
+		}
+		return (cpuDelta / systemDelta) * numCPUs * 100.0
+	}
+	return 0.0
+}
+
+// GetStreamCount returns the number of active streams
+func (sm *StreamManager) GetStreamCount() int {
+	sm.streamsMu.RLock()
+	defer sm.streamsMu.RUnlock()
+	return len(sm.streams)
+}
+
+// HasHost checks if a Docker host is registered
+func (sm *StreamManager) HasHost(hostID string) bool {
+	sm.clientsMu.RLock()
+	defer sm.clientsMu.RUnlock()
+	_, exists := sm.clients[hostID]
+	return exists
+}
+
+// StopAllStreams stops all active streams and closes all Docker clients
+func (sm *StreamManager) StopAllStreams() {
+	// Stop all streams
+	sm.streamsMu.Lock()
+	for containerID, cancel := range sm.streams {
+		cancel()
+		log.Printf("Stopped stream for %s", truncateID(containerID, 12))
+	}
+	sm.streams = make(map[string]context.CancelFunc)
+	sm.streamsMu.Unlock()
+
+	// Close all Docker clients
+	sm.clientsMu.Lock()
+	for hostID, cli := range sm.clients {
+		cli.Close()
+		log.Printf("Closed Docker client for host %s", truncateID(hostID, 8))
+	}
+	sm.clients = make(map[string]*client.Client)
+	sm.clientsMu.Unlock()
+}
+
+func min(a, b time.Duration) time.Duration {
+	if a < b {
+		return a
+	}
+	return b
+}
diff --git a/dockmon/stats-service/utils.go b/dockmon/stats-service/utils.go
new file mode 100644
index 0000000..2f534ba
--- /dev/null
+++ b/dockmon/stats-service/utils.go
@@ -0,0 +1,9 @@
+package main
+
+// truncateID truncates an ID string to specified length
+func truncateID(id string, length int) string {
+	if len(id) <= length {
+		return id
+	}
+	return id[:length]
+}
diff --git a/prestashop/docker-compose.yaml b/prestashop/docker-compose.yaml
deleted file mode 100644
index 6decda4..0000000
--- a/prestashop/docker-compose.yaml
+++ /dev/null
@@ -1,70 +0,0 @@
-# carlo
----
-name: prestashop
-
-services:
-  mysql:
-    container_name: mysql
-    image: mysql
-    restart: unless-stopped
-    environment:
-      MYSQL_ROOT_PASSWORD: admin
-      MYSQL_DATABASE: prestashop
-    networks:
-      - prestashop_network
-    volumes:
-      - dbdata:/var/lib/mysql
-
-  nginx:
-    container_name: nginx
-    image: nginx
-    restart: unless-stopped
-    volumes:
-      - ./nginx.conf:/etc/nginx/conf.d/default.conf
-    volumes_from:
-      - prestashop
-    ports:
-      - 127.0.0.1:12080:80
-    networks:
-      - prestashop_network
-    depends_on:
-      - prestashop
-
-  prestashop:
-    container_name: prestashop
-    image: prestashop/prestashop
-    restart: unless-stopped
-    depends_on:
-      - mysql
-    environment:
-      DB_SERVER: mysql
-      DB_NAME: prestashop
-      DB_USER: root
-      DB_PASSWD: root
-      PS_DOMAIN: localhost:12080
-      PS_FOLDER_ADMIN: admin1717
-      PS_FOLDER_INSTALL: instal1717
-    networks:
-      - prestashop_network
-    volumes:
-    - ./modules/my_module:/var/www/html/modules/my_module
-    - ./classes:/var/www/html/classes
-    - psdata:/var/www/html
-
-  adminer:
-    image: adminer
-    restart: unless-stopped
-    container_name: adminer
-    ports:
-      - "12081:8080" # Changed port mapping to reflect internal port
-    environment:
-      - ADMINER_DEFAULT_SERVER=mysql # Ensuring Adminer connects to the MySQL service
-    networks:
-      - prestashop_network
-
-networks:
-  prestashop_network:
-
-volumes:
-  psdata:
-  dbdata:
diff --git a/prestashop/nginx.conf b/prestashop/nginx.conf
deleted file mode 100644
index 94f82b0..0000000
--- a/prestashop/nginx.conf
+++ /dev/null
@@ -1,52 +0,0 @@
-server {
-   listen 80;
-   server_name shop.delmar.bzh;
-
-   root /var/www/html;
-
-   index index.php index.html index.htm;
-
-   set $admin_dir /admin1717;
-
-   location ~ /admin.*/(sell|api|common|_wdt|modules|improve|international|configure|addons|_profiler|product|combination|specific-price)/(.*)$ {
-        try_files $uri $uri/ /index.php?q=$uri&$args $admin_dir/index.php$is_args$args;
-   }
-
-   location / {
-        # Redirect pretty urls to index.php
-        try_files $uri $uri/ /index.php?$args;
-
-        # Images
-        rewrite ^/([0-9])(-[_a-zA-Z0-9-]*)?(-[0-9]+)?/.+.jpg$ /img/p/$1/$1$2$3.jpg last;
-        rewrite ^/([0-9])([0-9])(-[_a-zA-Z0-9-]*)?(-[0-9]+)?/.+.jpg$ /img/p/$1/$2/$1$2$3$4.jpg last;
-        rewrite ^/([0-9])([0-9])([0-9])(-[_a-zA-Z0-9-]*)?(-[0-9]+)?/.+.jpg$ /img/p/$1/$2/$3/$1$2$3$4$5.jpg last;
-        rewrite ^/([0-9])([0-9])([0-9])([0-9])(-[_a-zA-Z0-9-]*)?(-[0-9]+)?/.+.jpg$ /img/p/$1/$2/$3/$4/$1$2$3$4$5$6.jpg last;
-        rewrite ^/([0-9])([0-9])([0-9])([0-9])([0-9])(-[_a-zA-Z0-9-]*)?(-[0-9]+)?/.+.jpg$ /img/p/$1/$2/$3/$4/$5/$1$2$3$4$5$6$7.jpg last;
-        rewrite ^/([0-9])([0-9])([0-9])([0-9])([0-9])([0-9])(-[_a-zA-Z0-9-]*)?(-[0-9]+)?/.+.jpg$ /img/p/$1/$2/$3/$4/$5/$6/$1$2$3$4$5$6$7$8.jpg last;
-        rewrite ^/([0-9])([0-9])([0-9])([0-9])([0-9])([0-9])([0-9])(-[_a-zA-Z0-9-]*)?(-[0-9]+)?/.+.jpg$ /img/p/$1/$2/$3/$4/$5/$6/$7/$1$2$3$4$5$6$7$8$9.jpg last;
-        rewrite ^/([0-9])([0-9])([0-9])([0-9])([0-9])([0-9])([0-9])([0-9])(-[_a-zA-Z0-9-]*)?(-[0-9]+)?/.+.jpg$ /img/p/$1/$2/$3/$4/$5/$6/$7/$8/$1$2$3$4$5$6$7$8$9$10.jpg last;
-        rewrite ^/c/([0-9]+)(-[.*_a-zA-Z0-9-]*)(-[0-9]+)?/.+.jpg$ /img/c/$1$2$3.jpg last;
-        rewrite ^/c/([a-zA-Z_-]+)(-[0-9]+)?/.+.jpg$ /img/c/$1$2.jpg last;
-
-        # AlphaImageLoader for IE and fancybox
-        rewrite ^images_ie/?([^/]+)\.(jpe?g|png|gif)$ js/jquery/plugins/fancybox/images/$1.$2 last;
-
-        # Web service API
-        rewrite ^/api/?(.*)$ /webservice/dispatcher.php?url=$1 last;
-   }
-
-   location ~ \.php$ {
-       try_files $uri =404;
-       fastcgi_split_path_info ^(.+\.php)(/.+)$;
-       fastcgi_pass prestashop:9000;
-       fastcgi_index index.php;
-       include fastcgi_params;
-       fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
-       fastcgi_param PATH_INFO $fastcgi_path_info;
-       fastcgi_read_timeout 600;
-       proxy_connect_timeout 600;
-       proxy_send_timeout 600;
-       proxy_read_timeout 600;
-       send_timeout 600;
-   }
-}