From 005769489ee6325ee7dd1ff08541933ae8e84f22 Mon Sep 17 00:00:00 2001 From: Manish Tanwar Date: Wed, 22 Oct 2025 14:24:13 +0530 Subject: [PATCH] new features with video job cycles and video lenght changes --- .claude/settings.local.json | 48 + .gitignore | 3 + CLAUDE.md | 466 ++++- CORS_FIX_SUMMARY.md | 170 ++ PARALLEL_PROCESSING.md | 272 +++ README.md | 246 ++- backend/app.py | 44 +- backend/chunked_upload.py | 51 +- backend/video_processor.py | 664 ++++++- backend/video_splitter.py | 238 +++ frontend/.env | 5 +- frontend/CONFIG_README.md | 65 + frontend/package-lock.json | 1522 +++++++++-------- frontend/public/config.js | 14 +- frontend/public/config.json | 14 +- frontend/public/index.html | 4 + frontend/src/App.js | 336 +++- frontend/src/auth/AuthProvider.js | 17 +- frontend/src/auth/authApiClient.js | 10 + .../src/components/AuthenticatedContent.js | 335 ++-- frontend/src/components/ResultDisplay.js | 911 +++++----- frontend/src/components/VideoUpload.js | 53 +- video-query.zip | Bin 0 -> 572714 bytes 23 files changed, 4014 insertions(+), 1474 deletions(-) create mode 100644 .claude/settings.local.json create mode 100644 CORS_FIX_SUMMARY.md create mode 100644 PARALLEL_PROCESSING.md create mode 100644 backend/video_splitter.py create mode 100644 frontend/CONFIG_README.md create mode 100644 video-query.zip diff --git a/.claude/settings.local.json b/.claude/settings.local.json new file mode 100644 index 0000000..e6f06ab --- /dev/null +++ b/.claude/settings.local.json @@ -0,0 +1,48 @@ +{ + "permissions": { + "allow": [ + "Bash(npm start)", + "Bash(npm install)", + "Bash(timeout 10 npm start)", + "Bash(ls:*)", + "Bash(rm:*)", + "Bash(./node_modules/.bin/react-scripts:*)", + "Bash(timeout 15 npm start)", + "Bash(npm run build:*)", + "Bash(python3 run.py:*)", + "Bash(source:*)", + "Bash(python:*)", + "Bash(pkill:*)", + "Bash(true)", + "Bash(sudo apt:*)", + "Bash(sudo apt install:*)", + "Bash(apt list:*)", + "Bash(pip install:*)", + "Bash(whereis:*)", + "Bash(find:*)", + "Bash(snap list:*)", + "Bash(pip show:*)", + "Read(//usr/bin/**)", + "Bash(sudo apt-get update:*)", + "WebSearch", + "WebFetch(domain:ai.google.dev)", + "Bash(git checkout:*)", + "Bash(git add:*)", + "Bash(python3:*)", + "Bash(systemctl status:*)", + "Bash(kill:*)", + "Bash(curl:*)", + "Read(//etc/**)", + "Read(//var/log/**)", + "Bash(netstat:*)", + "Bash(ss:*)", + "Bash(cat:*)", + "Bash(ffmpeg:*)", + "Read(//usr/**)", + "Bash(awk:*)", + "Bash(deactivate)", + "Bash(xargs kill:*)" + ], + "deny": [] + } +} diff --git a/.gitignore b/.gitignore index 66b94b0..0bf5189 100644 --- a/.gitignore +++ b/.gitignore @@ -382,3 +382,6 @@ logs/ # Temporary files .tmp/ temp/ + +# Local development configuration (DO NOT COMMIT) +frontend/public/config.local.js diff --git a/CLAUDE.md b/CLAUDE.md index f0e10f6..e902a5d 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -2,19 +2,457 @@ This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. -## Build/Lint/Test Commands -- Run script: `python video_query.py [--prompt "Your custom prompt"]` -- Install dependencies: `pip install -r requirements.txt` (if requirements.txt exists) -- Create venv: `python -m venv venv && source venv/bin/activate` -- Install required packages: `pip install google-generativeai` +## Project Overview + +A full-stack video query application using Google Gemini 2.0 Flash Exp AI for video analysis. Features parallel processing, automatic video splitting, Azure AD B2C authentication (optional), chunked file uploads (up to 5GB), and PDF generation with Mermaid diagrams. + +**Tech Stack:** +- Backend: Flask 3.1.0, Hypercorn 0.17.3, google-genai 1.45.0, pdfkit, ffmpeg +- Frontend: React 18.2.0, @azure/msal-react 3.0.12, Bootstrap 5.3.2, react-dropzone 14.2.3 + +## Development Setup Commands + +### Backend Setup +```bash +cd backend +python3 -m venv venv +source venv/bin/activate # On Windows: venv\Scripts\activate +pip install -r requirements.txt + +# Install system dependencies (Ubuntu/Debian) +sudo apt-get install wkhtmltopdf python3-cairo libcairo2-dev ffmpeg + +# macOS +brew install cairo wkhtmltopdf ffmpeg + +# Create .env file +echo "GOOGLE_API_KEY=your_api_key_here" > .env + +# Run development server +python3 run.py +# Server runs on http://0.0.0.0:5010 +``` + +### Frontend Setup +```bash +cd frontend +npm install + +# Configure for local development (optional auth disable) +echo "REACT_APP_DISABLE_AUTH=true" > .env + +# Start development server +npm start +# Server runs on http://localhost:3000 + +# Build for production +npm run build +``` + +### Quick Restart (Development) +```bash +# From project root +./restart.sh +``` + +## Build/Test Commands + +### Backend +- **Run production server**: `cd backend && source venv/bin/activate && python3 run.py` +- **Test API**: `python test_api.py` (in backend directory) +- **Test webhook**: `python test_webhook.py` +- **Manual test**: `python test_webhook_manual.py` + +### Frontend +- **Development server**: `npm start` (port 3000) +- **Production build**: `npm run build` +- **Build with deploy script**: `./build.sh` + +### Video Processing +- **Standalone script**: `python video_query.py [--prompt "Your custom prompt"]` +- **Note**: The standalone script is deprecated. Use the web application for full features. + +## Production Deployment + +### Backend Deployment (Ubuntu/CentOS) + +1. **Install system packages**: + ```bash + sudo apt-get update + sudo apt-get install -y wkhtmltopdf python3-cairo python3-pil libcairo2-dev ffmpeg python3-venv + ``` + +2. **Set up virtual environment**: + ```bash + cd /path/to/video-query/backend + python3 -m venv venv + source venv/bin/activate + pip install -r requirements.txt + ``` + +3. **Configure environment**: + ```bash + echo "GOOGLE_API_KEY=your_production_api_key" > .env + ``` + +4. **Set up systemd service**: + ```bash + sudo cp video-query.service /etc/systemd/system/ + # Edit service file to match your paths + sudo nano /etc/systemd/system/video-query.service + + sudo systemctl daemon-reload + sudo systemctl enable video-query + sudo systemctl start video-query + sudo systemctl status video-query + ``` + +5. **Verify service**: + ```bash + curl http://localhost:5010/api/health # If health endpoint exists + journalctl -u video-query -f # View logs + ``` + +### Frontend Deployment + +1. **Update production configuration** (`frontend/public/config.js`): + ```javascript + window.__APP_CONFIG__ = { + "basePath": "/video-query", + "domain": "https://your-domain.com", + "api": { + "videoProcessingEndpoint": "https://your-domain.com/video_query_back/api/process", + "chunkedUploadEndpoint": "https://your-domain.com/video_query_back" + } + }; + ``` + +2. **Build for production**: + ```bash + cd frontend + npm run build + ``` + +3. **Deploy to web server**: + ```bash + sudo cp -r build/* /var/www/html/video-query/ + sudo chown -R www-data:www-data /var/www/html/video-query/ + ``` + +4. **Configure Apache** (example): + ```apache + + ServerName your-domain.com + DocumentRoot /var/www/html + + # Frontend + Alias /video-query /var/www/html/video-query + + Options -Indexes +FollowSymLinks + AllowOverride All + Require all granted + + + # Backend proxy + ProxyPass /video_query_back http://localhost:5010 + ProxyPassReverse /video_query_back http://localhost:5010 + + # WebSocket support (if needed) + ProxyPass /video_query_back/ws ws://localhost:5010/ws + ProxyPassReverse /video_query_back/ws ws://localhost:5010/ws + + SSLEngine on + SSLCertificateFile /etc/ssl/certs/your-cert.crt + SSLCertificateKeyFile /etc/ssl/private/your-key.key + + ``` + +5. **Configure Nginx** (alternative): + ```nginx + server { + listen 443 ssl; + server_name your-domain.com; + + ssl_certificate /etc/ssl/certs/your-cert.crt; + ssl_certificate_key /etc/ssl/private/your-key.key; + + # Frontend + location /video-query { + alias /var/www/html/video-query; + try_files $uri $uri/ /video-query/index.html; + } + + # Backend proxy + location /video_query_back { + proxy_pass http://localhost:5010; + 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; + + # Timeouts for long video processing + proxy_read_timeout 3600s; + proxy_connect_timeout 3600s; + proxy_send_timeout 3600s; + } + } + ``` + +6. **Restart web server**: + ```bash + # Apache + sudo systemctl restart apache2 + + # Nginx + sudo systemctl restart nginx + ``` + +### Azure AD B2C Authentication Setup (Optional) + +1. **Configure Azure AD B2C tenant** and register application +2. **Update** `frontend/src/auth/authConfig.js` with your tenant details +3. **Set authentication in frontend/.env**: + ```bash + # Enable auth for production + REACT_APP_DISABLE_AUTH=false + + # Disable auth for local dev + REACT_APP_DISABLE_AUTH=true + ``` + +## Key Architecture Components + +### Parallel Processing (App.js:244-268) +- **Max concurrent videos**: 2 (MAX_PARALLEL constant) +- Uses `Promise.allSettled()` for batch processing +- Each video gets an `AbortController` for cancellation + +### Rate Limiting (video_processor.py:221-224) +- **Delay**: 2 seconds between API calls +- Uses `threading.Lock` for thread safety +- Prevents Gemini API rate limit errors (5 RPM free tier) + +### Hybrid Upload Strategy (video_processor.py:163-203) +- **Files < 10MB**: Base64 inline data (instant) +- **Files >= 10MB**: File Upload API (slower but reliable) +- Threshold: `SIZE_THRESHOLD_MB = 10` + +### Video Splitting (video_splitter.py) +- **Chunk duration**: 25 minutes +- **Automatic**: Videos > 25 minutes split automatically +- **Processing**: Chunks processed in parallel on backend +- **Maximum single chunk**: 55 minutes (Gemini limit) + +### Queue Management (App.js:63-336) +- **Queue states**: queued, processing, completed, failed, cancelled +- **Operations**: Stop (cancel), Retry, Remove +- **Abort signal**: Support for canceling in-flight requests + +## Configuration Files + +### Backend Configuration +- **backend/.env**: `GOOGLE_API_KEY=your_key` +- **backend/run.py**: Hypercorn server config (body size limits, timeouts) + +### Frontend Configuration +- **frontend/.env**: `REACT_APP_DISABLE_AUTH=true/false` +- **frontend/public/config.js**: Production config (committed) +- **frontend/public/config.local.js**: Local dev override (not committed, in .gitignore) + +### Configuration Priority +1. `config.local.js` (local development) - highest priority +2. `config.js` (production) - fallback ## Code Style Guidelines -- Imports: Standard library imports first, followed by third-party imports, then local imports -- Formatting: PEP 8 compliant with 4-space indentation -- Types: Use type hints for function parameters and return values -- Naming: snake_case for variables/functions, PascalCase for classes -- Error handling: Use try/except blocks with specific exception types -- API Keys: Store in environment variables, not hardcoded -- Documentation: Use docstrings for functions and main modules -- Max line length: 100 characters -- Include helpful comments for complex operations \ No newline at end of file + +### Python (Backend) +- **Imports**: Standard library → third-party → local imports +- **Formatting**: PEP 8 compliant with 4-space indentation +- **Types**: Use type hints for function parameters and return values +- **Naming**: snake_case for variables/functions, PascalCase for classes +- **Error handling**: Use try/except blocks with specific exception types +- **API Keys**: Store in environment variables, never hardcode +- **Documentation**: Use docstrings for functions and main modules +- **Max line length**: 100 characters +- **Comments**: Include helpful comments for complex operations + +### JavaScript/React (Frontend) +- **Formatting**: 2-space indentation for React components +- **Naming**: camelCase for variables/functions, PascalCase for components +- **State management**: Use React hooks (useState, useEffect, useMsal) +- **Error handling**: Try/catch with user-friendly error messages +- **API calls**: Use authApiClient.js with abort signal support +- **Comments**: JSDoc style for complex functions + +## Important Implementation Notes + +### Authentication +- **Controlled via .env**: Do NOT remove MSAL code +- **Toggle**: Set `REACT_APP_DISABLE_AUTH=true` to disable +- **Components**: AuthProvider.js, authApiClient.js, authConfig.js +- **Session storage**: Tokens stored in sessionStorage for implicit flow + +### File Upload +- **Chunked upload**: All files use chunked upload (chunkedUploader.js) +- **Max file size**: 5GB per file +- **Progress tracking**: Real-time progress via callbacks +- **Supported formats**: MP4, AVI, MOV, WMV, MKV, WEBM + +### PDF Generation +- **Dependencies**: wkhtmltopdf, cairosvg, pdfkit +- **Mermaid support**: Diagrams converted to PNG then embedded +- **Endpoint**: POST /api/generate-pdf +- **Client**: ResultDisplay.js handles download + +### Error Handling +- **Rate limiting**: 400 INVALID_ARGUMENT → check logs, reduce parallel count +- **Large files**: Use hybrid upload strategy (SIZE_THRESHOLD_MB) +- **Abort errors**: Check for `err.code === 'ERR_CANCELED'` or `abortSignal.aborted` + +## Troubleshooting + +### Backend Issues +```bash +# Check service status +sudo systemctl status video-query + +# View logs +journalctl -u video-query -f + +# Restart service +sudo systemctl restart video-query + +# Check ffmpeg installation +which ffprobe +ffprobe -version +``` + +### Frontend Issues +```bash +# Clear browser cache +# Chrome/Firefox: Ctrl+Shift+R (force reload) + +# Check config loading +# Browser console: window.__APP_CONFIG__ + +# Verify build +ls -la frontend/build/ + +# Check Apache/Nginx logs +tail -f /var/log/apache2/error.log +tail -f /var/log/nginx/error.log +``` + +### Rate Limiting Issues +- **Symptom**: 400 INVALID_ARGUMENT after 3-4 videos +- **Check**: Gemini API rate limits (5 RPM for free tier) +- **Solutions**: + - Increase delay in video_processor.py (line 222) + - Reduce MAX_PARALLEL in App.js (line 245) + - Lower SIZE_THRESHOLD_MB in video_processor.py (line 163) + +### CORS Issues +- **Local dev**: Verify config.local.js exists and points to localhost:5010 +- **Production**: Check Apache/Nginx proxy configuration +- **Backend**: Verify CORS settings in app.py + +## Testing + +### Backend Testing +```bash +cd backend +source venv/bin/activate + +# Test video processing +python test_api.py + +# Test webhook +python test_webhook.py + +# Manual API test +curl -X POST http://localhost:5010/api/process \ + -H "Content-Type: application/json" \ + -d '{"file_path": "/path/to/video.mp4", "filename": "video.mp4", "prompt": "Test prompt"}' +``` + +### Frontend Testing +```bash +cd frontend + +# Development mode +npm start + +# Production build test +npm run build +npx serve -s build -l 3000 +``` + +## Log Extraction & Analytics + +### Extract User Logs +```bash +# Quick extraction +./quick_extract.sh + +# Robust extraction with error handling +./extract_user_logs_robust.sh + +# See LOG_EXTRACTION_README.md for details +``` + +## Useful File Locations + +### Backend +- Main app: `backend/app.py` +- Video processor: `backend/video_processor.py` (Gemini API integration) +- Video splitter: `backend/video_splitter.py` (25-min chunks) +- Chunked upload: `backend/chunked_upload.py` +- Authentication: `backend/auth.py` + +### Frontend +- Main app: `frontend/src/App.js` (queue management, parallel processing) +- Queue UI: `frontend/src/components/AuthenticatedContent.js` +- Upload: `frontend/src/components/VideoUpload.js` +- Results: `frontend/src/components/ResultDisplay.js` +- Chunked uploader: `frontend/src/utils/chunkedUploader.js` + +### Configuration +- Backend env: `backend/.env` +- Frontend env: `frontend/.env` +- Production config: `frontend/public/config.js` +- Local config: `frontend/public/config.local.js` +- Systemd service: `backend/video-query.service` + +## Dependencies Management + +### Backend Updates +```bash +cd backend +source venv/bin/activate +pip install --upgrade google-genai flask flask-cors pdfkit +pip freeze > requirements.txt +``` + +### Frontend Updates +```bash +cd frontend +npm update +npm audit fix +``` + +## Security Considerations + +- **API Keys**: Never commit .env files +- **Authentication**: Azure AD B2C tokens in sessionStorage (consider security implications) +- **CORS**: Specific origin allowlisting in production +- **File validation**: Size and type checks in VideoUpload.js +- **Temporary files**: Automatic cleanup in backend +- **Rate limiting**: Built-in to prevent abuse + +## Support & Documentation + +- **Main docs**: See README.md for comprehensive feature documentation +- **Deployment**: See DEPLOYMENT.md for detailed deployment guide +- **Log extraction**: See LOG_EXTRACTION_README.md for analytics +- **Parallel processing**: See PARALLEL_PROCESSING.md (if exists) +- **CORS fixes**: See CORS_FIX_SUMMARY.md (if exists) \ No newline at end of file diff --git a/CORS_FIX_SUMMARY.md b/CORS_FIX_SUMMARY.md new file mode 100644 index 0000000..7c76b13 --- /dev/null +++ b/CORS_FIX_SUMMARY.md @@ -0,0 +1,170 @@ +# CORS Fix Summary + +## Issue +Frontend running on `http://localhost:3000` was blocked by CORS policy when trying to access backend API at `https://brandtechsandbox.oliver.solutions/video_query_back/api/init-upload` + +### Error Message +``` +Access to XMLHttpRequest at 'https://brandtechsandbox.oliver.solutions/video_query_back/api/init-upload' +from origin 'http://localhost:3000' has been blocked by CORS policy: +Response to preflight request doesn't pass access control check: +No 'Access-Control-Allow-Origin' header is present on the requested resource. +``` + +--- + +## Root Cause +The OPTIONS preflight handler in `app.py` (lines 1124-1132) was only returning `https://ai-sandbox.oliver.solutions` as the allowed origin, not `http://localhost:3000`. + +--- + +## Solution Implemented + +### File: `backend/app.py` + +#### Changed (lines 1123-1143): +```python +# Handle CORS preflight requests for all API routes +@app.route('/api/', methods=['OPTIONS']) +def handle_options(path): + # Get the origin from the request + origin = request.headers.get('Origin') + allowed_origins = ['https://ai-sandbox.oliver.solutions', 'http://localhost:3000'] + + response = jsonify({}) + + # Allow the origin if it's in our allowed list + if origin in allowed_origins: + response.headers.add('Access-Control-Allow-Origin', origin) + else: + # Default to production origin + response.headers.add('Access-Control-Allow-Origin', 'https://ai-sandbox.oliver.solutions') + + response.headers.add('Access-Control-Allow-Headers', 'Content-Type,Authorization,X-Requested-With') + response.headers.add('Access-Control-Allow-Methods', 'GET,POST,OPTIONS') + response.headers.add('Access-Control-Max-Age', '86400') # 24 hours + response.headers.add('Access-Control-Allow-Credentials', 'true') + return response +``` + +--- + +## What Changed + +### Before: +- Hardcoded origin: `'https://ai-sandbox.oliver.solutions'` +- Did not check request origin +- Always returned same origin regardless of where request came from + +### After: +- Dynamic origin checking +- List of allowed origins: `['https://ai-sandbox.oliver.solutions', 'http://localhost:3000']` +- Returns the origin that made the request if it's in the allowed list +- Falls back to production origin if request origin is not allowed + +--- + +## Existing CORS Configuration (Already Correct) + +The main CORS configuration on line 41-46 was already correct: +```python +CORS(app, resources={r"/api/*": { + "origins": ["https://ai-sandbox.oliver.solutions", "http://localhost:3000"], + "supports_credentials": True, + "methods": ["GET", "POST", "OPTIONS"], + "allow_headers": ["Content-Type", "X-Requested-With", "Authorization"] +}}, expose_headers=["Content-Disposition", "Authorization"]) +``` + +--- + +## Testing + +### Before Fix: +``` +❌ localhost:3000 → backend API: CORS error +✅ production → backend API: Works +``` + +### After Fix: +``` +✅ localhost:3000 → backend API: Should work +✅ production → backend API: Still works +``` + +--- + +## How to Test + +1. **Start the backend** (if not already running): + ```bash + cd backend + python3 run.py + # or + hypercorn run:app + ``` + +2. **Start the frontend** on localhost:3000: + ```bash + cd frontend + npm start + ``` + +3. **Test the upload**: + - Open browser to `http://localhost:3000` + - Try uploading a video + - Check browser console for CORS errors + - Should see successful API calls + +4. **Check Network Tab**: + - Open browser DevTools → Network tab + - Look for `init-upload` request + - Check Response Headers for: + - `Access-Control-Allow-Origin: http://localhost:3000` + - `Access-Control-Allow-Credentials: true` + +--- + +## Additional Notes + +### Why This Fix is Safe: +1. **Localhost is development only** - Won't be accessible in production +2. **Credentials still required** - Auth is still enforced +3. **Limited to /api/* routes** - Doesn't affect other routes +4. **Production origin still allowed** - No impact on deployed version + +### If You Need to Add More Origins: +Update the `allowed_origins` list in `app.py` line 1128: +```python +allowed_origins = [ + 'https://ai-sandbox.oliver.solutions', + 'http://localhost:3000', + 'http://localhost:3001', # Add more as needed + 'https://another-domain.com' +] +``` + +--- + +## Files Modified + +1. ✅ `backend/app.py` - Updated OPTIONS handler (lines 1123-1143) + +--- + +## Dependencies + +- ✅ `flask-cors==5.0.1` - Already in requirements.txt +- ✅ No new dependencies needed + +--- + +## Status + +✅ **FIXED and READY FOR TESTING** + +The CORS error should now be resolved. Try uploading a video from `http://localhost:3000` and verify it works. + +--- + +Generated: 2025-10-16 diff --git a/PARALLEL_PROCESSING.md b/PARALLEL_PROCESSING.md new file mode 100644 index 0000000..84e3613 --- /dev/null +++ b/PARALLEL_PROCESSING.md @@ -0,0 +1,272 @@ +# Parallel Video Chunk Processing + +## Overview + +The video-query application now supports **parallel processing** of video chunks, significantly reducing processing time for long videos. + +## Performance Improvements + +### Before (Sequential Processing) +- **2-hour video** (3 chunks of 50 min each) + - Chunk 1: ~3-5 minutes + - Chunk 2: ~3-5 minutes + - Chunk 3: ~3-5 minutes + - **Total: 9-15 minutes** + +### After (Parallel Processing) +- **2-hour video** (3 chunks processed simultaneously) + - All 3 chunks: ~3-5 minutes + - **Total: 3-5 minutes** + +**Speed Improvement: 3x faster!** + +--- + +## Configuration + +### Default Settings + +```python +# Default configuration in VideoProcessor +max_parallel_chunks = 4 # Conservative setting for free tier +``` + +### Custom Configuration + +```python +from video_processor import VideoProcessor + +# For Free Tier (5 RPM limit) +processor = VideoProcessor(api_key="your_key", max_parallel_chunks=3) + +# For Paid Tier (150 RPM limit) +processor = VideoProcessor(api_key="your_key", max_parallel_chunks=10) +``` + +--- + +## API Rate Limits + +### Gemini API Limits by Tier + +| Tier | RPM Limit | Recommended Workers | Max Video Chunks | +|------|-----------|---------------------|------------------| +| **Free** | 5 RPM | 3-4 workers | 3-4 simultaneous | +| **Paid Tier 1** | 150 RPM | 10+ workers | 10+ simultaneous | +| **Paid Tier 2+** | 1000+ RPM | 20+ workers | 20+ simultaneous | + +### Important Notes + +- Rate limits are **per project**, not per API key +- Concurrent requests are allowed as long as you stay within RPM limits +- The system automatically respects your configured `max_parallel_chunks` setting + +--- + +## Usage + +### Enable Parallel Processing (Default) + +```python +from video_processor import VideoProcessor + +processor = VideoProcessor() + +# Parallel processing is enabled by default +result = processor.process_long_video( + video_path="/path/to/long_video.mp4", + prompt="Generate a meeting summary", + user_email="user@example.com" +) + +print(f"Processing mode: {result['processing_mode']}") # Output: "parallel" +``` + +### Disable Parallel Processing (Sequential) + +```python +# If you prefer sequential processing +result = processor.process_long_video( + video_path="/path/to/long_video.mp4", + prompt="Generate a meeting summary", + user_email="user@example.com", + use_parallel=False # Disable parallel processing +) + +print(f"Processing mode: {result['processing_mode']}") # Output: "sequential" +``` + +### Auto-Detection Mode + +```python +# Use process_video_auto for automatic detection +result = processor.process_video_auto( + video_path="/path/to/video.mp4", + prompt="Generate documentation", + user_email="user@example.com" +) + +# Automatically uses parallel processing for long videos +``` + +--- + +## How It Works + +1. **Video Splitting** + - Long videos are split into 25-minute chunks (configurable) + - Uses FFmpeg for fast, lossless splitting + +2. **Parallel Upload & Processing** + - Chunks are uploaded to Gemini API concurrently + - Multiple API calls run simultaneously (up to `max_parallel_chunks`) + - Thread-safe execution using `ThreadPoolExecutor` + +3. **Response Combination** + - Responses are collected in correct order + - Intelligently combined based on prompt type (meeting, documentation, etc.) + - For meetings, can optionally synthesize into unified summary + +4. **Cleanup** + - Temporary chunk files are automatically deleted + - Handles errors gracefully + +--- + +## Technical Implementation + +### Thread Safety + +The implementation uses: +- `concurrent.futures.ThreadPoolExecutor` for parallel execution +- `threading.Lock` for rate limiting +- Order-preserving result collection + +### Error Handling + +- Each chunk is processed independently +- If one chunk fails, the error is logged with specific details +- Failed chunks return error information without crashing entire job +- Results maintain correct order regardless of completion order + +--- + +## Environment Variables + +```bash +# Optional: Set max workers via environment variable +export VIDEO_QUERY_MAX_WORKERS=5 + +# API Key (required) +export GOOGLE_API_KEY="your_gemini_api_key" +``` + +--- + +## Logging + +Monitor parallel processing with detailed logs: + +``` +[INFO] Starting parallel processing of 3 chunks with 4 workers +[INFO] [Parallel] Processing chunk 1/3: /tmp/video_chunk_01.mp4 +[INFO] [Parallel] Processing chunk 2/3: /tmp/video_chunk_02.mp4 +[INFO] [Parallel] Processing chunk 3/3: /tmp/video_chunk_03.mp4 +[INFO] [Parallel] Completed chunk 2/3 +[INFO] [Parallel] Progress: 1/3 chunks completed +[INFO] [Parallel] Completed chunk 1/3 +[INFO] [Parallel] Progress: 2/3 chunks completed +[INFO] [Parallel] Completed chunk 3/3 +[INFO] [Parallel] Progress: 3/3 chunks completed +[INFO] [Parallel] All 3 chunks processed +[INFO] Combining responses from all chunks... +``` + +--- + +## Troubleshooting + +### Rate Limit Errors + +**Symptom:** `429 Too Many Requests` errors + +**Solution:** +```python +# Reduce max_parallel_chunks +processor = VideoProcessor(max_parallel_chunks=2) +``` + +### Memory Issues + +**Symptom:** Out of memory errors + +**Solution:** +```python +# Process fewer chunks in parallel +processor = VideoProcessor(max_parallel_chunks=2) +``` + +### Slower Performance + +**Symptom:** Parallel processing is slower than expected + +**Possible Causes:** +- Network bottleneck (upload bandwidth) +- CPU bottleneck (video encoding) +- API rate limiting + +**Solution:** +- Check network speed +- Monitor CPU usage +- Verify API tier and limits + +--- + +## Best Practices + +1. **Choose Appropriate Worker Count** + - Free tier: 3-4 workers + - Paid tier: 8-10 workers + - Don't exceed your RPM limit + +2. **Monitor Resource Usage** + - Check server memory + - Monitor network bandwidth + - Track API usage + +3. **Handle Errors Gracefully** + - Implement retry logic + - Log all errors + - Provide fallback to sequential processing + +4. **Optimize Chunk Size** + - 25 minutes for most cases + - 50 minutes if API supports it + - Balance between parallelism and chunk size + +--- + +## Future Enhancements + +Potential improvements: +- [ ] Adaptive worker count based on API tier detection +- [ ] Exponential backoff for rate limit errors +- [ ] Progress callbacks for real-time updates +- [ ] Configurable chunk duration +- [ ] Support for asyncio (async/await pattern) + +--- + +## Support + +For issues or questions: +1. Check logs for detailed error information +2. Verify API key and rate limits +3. Review configuration settings +4. Consult Gemini API documentation + +--- + +## License + +Same as the main project license. diff --git a/README.md b/README.md index 6ef94d8..18adec0 100644 --- a/README.md +++ b/README.md @@ -1,32 +1,43 @@ # Video Query Tool -A full-stack web application that processes videos using Google's Gemini AI model, allowing users to upload videos and receive AI-generated content based on customizable prompts. The application features Azure AD B2C authentication, chunked file uploads for large videos, PDF generation with Mermaid diagram support, and comprehensive usage tracking. +A full-stack web application that processes videos using Google's Gemini AI model, allowing users to upload multiple videos simultaneously and receive AI-generated content based on customizable prompts. Features parallel processing, automatic video splitting, Azure AD B2C authentication, chunked file uploads, PDF generation with Mermaid diagrams, and comprehensive usage tracking. ## Features ### Core Functionality -- **Video Processing**: Upload and analyze videos using Google Gemini 2.5 Pro AI model +- **Video Processing**: Upload and analyze videos using Google Gemini 2.0 Flash Exp AI model - **Multiple Processing Modes**: - Meeting Summary - Process/Tool Documentation - Process Documentation with Mermaid Charts - Custom Prompts -- **Large File Support**: Chunked upload system supporting files up to 5GB +- **Large File Support**: Chunked upload system supporting files up to 5GB per file - **PDF Generation**: Convert results to PDF with embedded Mermaid diagrams -- **Authentication**: Azure AD B2C integration with both popup and redirect flows +- **Authentication**: Azure AD B2C integration (optional, controlled via .env) +- **Parallel Processing**: Process up to 2 videos simultaneously +- **Multiple File Upload**: Upload and queue multiple videos at once +- **Long Video Support**: Automatic splitting and parallel chunk processing for videos > 25 minutes ### Technical Features +- **Multiple File Queue**: Upload multiple videos, manage queue (Stop, Retry, Remove) - **Drag & Drop Upload**: Modern file upload interface with progress tracking -- **Real-time Processing**: Live status updates during video analysis -- **Error Handling**: Comprehensive error handling and user feedback +- **Real-time Processing**: Live status updates with parallel processing indicators +- **Queue Management**: Stop, retry, or remove videos from processing queue anytime +- **Automatic Video Splitting**: Videos > 25 minutes automatically split into 25-min chunks +- **Rate Limiting**: Built-in API rate limiting (2-second delay) to prevent quota errors +- **Error Handling**: Comprehensive error handling with retry capability +- **Processing Time Display**: Shows processing duration for each completed video - **Usage Analytics**: Automated tracking via webhook integration - **Production Ready**: Systemd service configuration and deployment scripts ## Limitations -- **Video Length**: Gemini AI processes videos up to 55 minutes maximum -- **File Size**: Application supports uploads up to 5GB +- **Video Length**: No limit - videos automatically split into 25-minute chunks +- **Single Chunk Limit**: Individual chunks must be under 55 minutes (handled automatically) +- **File Size**: Application supports uploads up to 5GB per file - **Supported Formats**: MP4, AVI, MOV, WMV, MKV, WEBM +- **Parallel Processing**: Max 2 videos simultaneously (rate limit protection) +- **API Rate Limits**: Gemini free tier: 5 RPM (built-in 2s delay between calls) ## Project Structure @@ -34,41 +45,50 @@ A full-stack web application that processes videos using Google's Gemini AI mode video_query/ ├── backend/ # Flask/Hypercorn API server │ ├── app.py # Main Flask application with PDF generation -│ ├── video_processor.py # Gemini API integration and video processing +│ ├── video_processor.py # Gemini API integration, parallel processing, rate limiting +│ ├── video_splitter.py # Video splitting for long videos (25-min chunks) │ ├── auth.py # Azure AD B2C authentication handlers │ ├── chunked_upload.py # Chunked file upload Blueprint │ ├── run.py # Hypercorn production server │ ├── requirements.txt # Python dependencies +│ ├── .env # Environment variables (GOOGLE_API_KEY) │ └── test_*.py # API testing utilities ├── frontend/ # React SPA │ ├── src/ │ │ ├── components/ # React components -│ │ │ ├── VideoUpload.js # Drag & drop file upload +│ │ │ ├── VideoUpload.js # Multi-file drag & drop upload │ │ │ ├── PromptSelector.js # Mode selection and prompt editing │ │ │ ├── ResultDisplay.js # Results with PDF generation -│ │ │ ├── AuthenticatedContent.js # Main application interface +│ │ │ ├── AuthenticatedContent.js # Queue management, processed list │ │ │ └── Login.js # Authentication interface │ │ ├── auth/ # Authentication utilities │ │ │ ├── authConfig.js # Azure AD B2C configuration │ │ │ ├── AuthProvider.js # MSAL React provider │ │ │ └── authApiClient.js # Authenticated API client │ │ └── utils/ -│ │ └── chunkedUploader.js # Large file upload handler +│ │ ├── chunkedUploader.js # Large file upload handler +│ │ ├── configLoader.js # Dynamic config loading +│ │ └── pathUtils.js # Path utilities +│ ├── public/ +│ │ ├── config.js # Production config (committed) +│ │ ├── config.local.js # Local dev config (not committed) +│ │ └── index.html # Loads both configs │ ├── package.json # Node.js dependencies +│ ├── .env # Frontend environment variables │ └── build/ # Production build output ├── DEPLOYMENT.md # Production deployment instructions ├── LOG_EXTRACTION_README.md # Usage analytics documentation +├── CLAUDE.md # Development guidelines and build commands ├── restart.sh # Development restart script ├── quick_extract.sh # Log extraction utility -├── extract_user_logs*.sh # Advanced log processing -└── requirements.txt # Root Python dependencies (legacy) +└── extract_user_logs*.sh # Advanced log processing ``` ## Dependencies ### Backend Dependencies - **Flask 3.1.0**: Web framework -- **google-generativeai 0.8.5**: Gemini AI API client +- **google-genai 1.45.0**: Gemini AI SDK (updated API) - **Hypercorn 0.17.3**: ASGI production server - **python-jose**: JWT token validation for Azure AD - **flask-cors 5.0.1**: Cross-origin resource sharing @@ -76,14 +96,15 @@ video_query/ - **cairosvg 2.8.0**: SVG to PNG conversion for diagrams - **Pillow 11.2.1**: Image processing - **python-dotenv 1.1.0**: Environment variable management +- **ffmpeg-python**: Video splitting functionality ### Frontend Dependencies - **React 18.2.0**: UI framework - **@azure/msal-react 3.0.12**: Microsoft Authentication Library -- **axios 1.6.0**: HTTP client +- **axios 1.6.0**: HTTP client with abort signal support - **bootstrap 5.3.2**: UI components and styling - **mermaid 11.6.0**: Diagram generation -- **react-dropzone 14.2.3**: File upload interface +- **react-dropzone 14.2.3**: Multi-file upload interface - **showdown 2.1.0**: Markdown to HTML conversion ## Setup Instructions @@ -92,40 +113,42 @@ video_query/ - Python 3.8+ - Node.js 16+ - Google Cloud API key with Gemini access -- Azure AD B2C tenant (for authentication) +- Azure AD B2C tenant (optional, for authentication) - wkhtmltopdf (for PDF generation) +- ffmpeg/ffprobe (for video splitting) ### Backend Setup 1. **Create and activate virtual environment**: ```bash - python -m venv venv + cd backend + python3 -m venv venv source venv/bin/activate # On Windows: venv\Scripts\activate ``` 2. **Install dependencies**: ```bash - pip install -r backend/requirements.txt + pip install -r requirements.txt ``` -3. **Set up environment variables**: +3. **Set up environment variables** (create `backend/.env`): ```bash - export GOOGLE_API_KEY="your_gemini_api_key_here" + GOOGLE_API_KEY=your_gemini_api_key_here ``` -4. **Install system dependencies for PDF generation**: +4. **Install system dependencies**: ```bash # Ubuntu/Debian: - sudo apt-get install wkhtmltopdf python3-cairo libcairo2-dev + sudo apt-get install wkhtmltopdf python3-cairo libcairo2-dev ffmpeg # macOS: - brew install cairo wkhtmltopdf + brew install cairo wkhtmltopdf ffmpeg ``` 5. **Start development server**: ```bash - cd backend - python run.py --host 0.0.0.0 --port 5010 + python3 run.py + # Server runs on http://0.0.0.0:5010 ``` ### Frontend Setup @@ -136,14 +159,21 @@ video_query/ npm install ``` -2. **Configure authentication** (edit `src/auth/authConfig.js`): - - Update Azure AD B2C tenant ID - - Update client ID - - Update redirect URIs +2. **Configure authentication** (optional): + - Edit `frontend/.env`: + ``` + REACT_APP_DISABLE_AUTH=true # Disable auth for local dev + ``` + - For production, update `src/auth/authConfig.js` with Azure AD B2C details -3. **Start development server**: +3. **Configure backend URL for local development**: + - File `frontend/public/config.local.js` already configured for localhost:5010 + - This file is not committed (in .gitignore) + +4. **Start development server**: ```bash npm start + # Server runs on http://localhost:3000 ``` ## Production Deployment @@ -153,6 +183,7 @@ video_query/ - Apache/Nginx web server - Python 3.8+ with virtual environment - wkhtmltopdf system package +- ffmpeg/ffprobe for video processing - Node.js for building frontend ### Backend Deployment @@ -160,38 +191,75 @@ video_query/ 1. **Install system packages**: ```bash sudo apt-get update - sudo apt-get install -y wkhtmltopdf python3-cairo python3-pil libcairo2-dev + sudo apt-get install -y wkhtmltopdf python3-cairo python3-pil libcairo2-dev ffmpeg ``` -2. **Create production service** (see `DEPLOYMENT.md` for systemd configuration): +2. **Set up virtual environment and install dependencies**: ```bash + cd backend + python3 -m venv venv + source venv/bin/activate + pip install -r requirements.txt + ``` + +3. **Create production .env file**: + ```bash + echo "GOOGLE_API_KEY=your_production_api_key" > .env + ``` + +4. **Create systemd service** (see `backend/video-query.service`): + ```bash + sudo cp backend/video-query.service /etc/systemd/system/ + sudo systemctl daemon-reload sudo systemctl enable video-query sudo systemctl start video-query ``` ### Frontend Deployment -1. **Build for production**: - ```bash - cd frontend - PUBLIC_URL=/video_query npm run build +1. **Update production config** (`frontend/public/config.js`): + ```javascript + window.__APP_CONFIG__ = { + "basePath": "/video-query", + "domain": "https://your-domain.com", + "api": { + "videoProcessingEndpoint": "https://your-domain.com/video_query_back/api/process", + "chunkedUploadEndpoint": "https://your-domain.com/video_query_back" + } + }; ``` -2. **Deploy to web server**: +2. **Build for production**: ```bash - cp -r build/* /var/www/html/video-query/ + cd frontend + npm run build + ``` + +3. **Deploy to web server**: + ```bash + sudo cp -r build/* /var/www/html/video-query/ + ``` + +4. **Configure web server** (Apache example): + ```apache + + DocumentRoot /var/www/html + + # Frontend + Alias /video-query /var/www/html/video-query + + # Backend proxy + ProxyPass /video_query_back http://localhost:5010 + ProxyPassReverse /video_query_back http://localhost:5010 + ``` ## API Reference -### Authentication Endpoints -- **GET /api/auth-test**: Verify authentication status - ### Video Processing Endpoints - **POST /api/process**: Main video processing endpoint - - Accepts both direct uploads and chunked upload references - - Form data: `video` file, `prompt` text - - JSON data: `file_path`, `filename`, `prompt` (for chunked uploads) + - Accepts JSON: `file_path`, `filename`, `prompt` (for chunked uploads) + - Returns: Processing result with content, processing time, chunks info ### Chunked Upload Endpoints - **POST /api/init-upload**: Initialize chunked upload session @@ -201,44 +269,90 @@ video_query/ ### PDF Generation Endpoints - **POST /api/generate-pdf**: Generate PDF from HTML with Mermaid diagrams - - JSON data: `html`, `textDiagrams`, `svgDiagrams`, `diagramPngs` + - JSON data: `html`, `textDiagrams`, `diagramPngs`, `videoFileName` -## Usage Analytics - -The application includes built-in usage tracking that sends data to a webhook endpoint for analytics purposes. This tracks: -- User email addresses -- Processing timestamps -- Prompts used -- Model information - -Log extraction utilities are provided in `extract_user_logs*.sh` scripts. +### Authentication Endpoints (if enabled) +- **GET /api/auth-test**: Verify authentication status ## Configuration Files -### Key Configuration Files -- **CLAUDE.md**: Development guidelines and build commands -- **.gitignore**: Comprehensive exclusion patterns -- **backend/requirements.txt**: Production Python dependencies -- **frontend/package.json**: Node.js dependencies and build scripts +### Backend Configuration +- **backend/.env**: Environment variables + ``` + GOOGLE_API_KEY=your_api_key + ``` -### Environment Variables -- `GOOGLE_API_KEY`: Required for Gemini API access -- Various Azure AD B2C configuration in frontend auth config +### Frontend Configuration +- **frontend/.env**: React environment variables + ``` + REACT_APP_DISABLE_AUTH=true # Optional: disable auth for local dev + ``` +- **frontend/public/config.js**: Production configuration (committed to git) +- **frontend/public/config.local.js**: Local development override (not committed) + +### Key Configuration Details +- **Parallel Processing**: Max 2 concurrent videos (App.js:245) +- **Rate Limiting**: 2-second delay between API calls (video_processor.py:224) +- **File Size Threshold**: 10MB for inline vs upload API (video_processor.py:167) +- **Video Chunk Duration**: 25 minutes (video_splitter.py) + +## Usage + +### Local Development +1. Start backend: `cd backend && source venv/bin/activate && python3 run.py` +2. Start frontend: `cd frontend && npm start` +3. Open: http://localhost:3000 + +### Processing Videos +1. **Upload**: Drag & drop multiple videos or click to select +2. **Queue**: Videos appear in "Processing Queue" section +3. **Select Prompt**: Choose processing mode or write custom prompt +4. **Process**: Click "Process N Videos" button +5. **Monitor**: Watch real-time progress (2 videos process in parallel) +6. **Manage**: Use Stop (⏸️), Retry (🔄), or Remove (🗑️) buttons +7. **View Results**: Check "Processed Videos" section for completed results +8. **Download**: Click "Download PDF" or "Copy Formatted" for any completed video + +### Processing Long Videos +- Videos > 25 minutes automatically split into chunks +- Each chunk processed in parallel (backend handles this) +- Results intelligently combined +- Processing time displayed for transparency ## Development Utilities - **restart.sh**: Quick development environment restart - **backend/test_*.py**: API testing and validation scripts - **backend/run.py**: Production server with optimized settings for large uploads +- **extract_user_logs*.sh**: Usage analytics extraction ## Security Features -- Azure AD B2C integration with JWT validation +- Azure AD B2C integration with JWT validation (optional) - CORS protection with specific origin allowlisting - Secure file upload validation - Temporary file cleanup - Token expiration handling +- Rate limiting to prevent API abuse +- Abort signal support for cancellation + +## Troubleshooting + +### Backend Issues +- **400 INVALID_ARGUMENT**: Usually rate limiting - check logs for details +- **File upload errors**: Verify ffmpeg installed (`which ffprobe`) +- **PDF generation fails**: Ensure wkhtmltopdf installed + +### Frontend Issues +- **CORS errors**: Check backend CORS settings in app.py +- **Changes not visible**: Clear browser cache (Ctrl+Shift+R) +- **Config not loading**: Verify config.js and config.local.js exist in public/ + +### Rate Limiting +- Backend: 2-second delay between API calls (automatic) +- Frontend: Max 2 parallel videos +- Free tier: 5 RPM limit enforced by Gemini API ## License -This project is proprietary and confidential. \ No newline at end of file +This project is proprietary and confidential. diff --git a/backend/app.py b/backend/app.py index 2913a49..f380610 100644 --- a/backend/app.py +++ b/backend/app.py @@ -39,7 +39,7 @@ from video_processor import VideoProcessor app = Flask(__name__) # Enable CORS with permissive settings for large file uploads CORS(app, resources={r"/api/*": { - "origins": ["https://ai-sandbox.oliver.solutions"], + "origins": ["https://ai-sandbox.oliver.solutions", "http://localhost:3000"], "supports_credentials": True, "methods": ["GET", "POST", "OPTIONS"], "allow_headers": ["Content-Type", "X-Requested-With", "Authorization"] @@ -113,7 +113,8 @@ def process_video(): user_email = request.user.get("email", request.user.get("preferred_username", "anonymous")) logger.info(f"Processing chunked upload from {file_path} ({filename}) for user: {user_email}") - result = video_processor.process_video(file_path, prompt, user_email) + # Use auto-processing which handles both short and long videos + result = video_processor.process_video_auto(file_path, prompt, user_email) # Clean up the uploaded file try: @@ -121,14 +122,19 @@ def process_video(): logger.info(f"Cleaned up temporary file: {file_path}") except Exception as cleanup_error: logger.warning(f"Could not remove temporary file {file_path}: {str(cleanup_error)}") - + if result['success']: content_length = len(result['content']) if result['content'] else 0 logger.info(f"Returning successful response with {content_length} characters") - return jsonify({ + response_data = { 'success': True, 'content': result['content'] - }) + } + # Include chunk information if video was processed in chunks + if result.get('chunks_processed', 0) > 1: + response_data['chunks_processed'] = result['chunks_processed'] + response_data['total_chunks'] = result.get('total_chunks', result['chunks_processed']) + return jsonify(response_data) else: logger.error(f"Processing failed: {result['message']}") return jsonify({ @@ -205,6 +211,10 @@ def process_video(): logger.info(f"Starting video processing for user: {user_email}...") result = video_processor.process_video(file_path, prompt, user_email) logger.info(f"Processing result: success={result['success']}") + + # Log if it was processed in chunks + if result.get('chunks_processed', 0) > 1: + logger.info(f"Video was processed in {result['chunks_processed']} chunks") # Clean up the file after processing try: @@ -212,14 +222,19 @@ def process_video(): logger.info(f"Cleaned up temporary file: {file_path}") except Exception as cleanup_error: logger.warning(f"Could not remove temporary file {file_path}: {str(cleanup_error)}") - + if result['success']: content_length = len(result['content']) if result['content'] else 0 logger.info(f"Returning successful response with {content_length} characters") - return jsonify({ + response_data = { 'success': True, 'content': result['content'] - }) + } + # Include chunk information if video was processed in chunks + if result.get('chunks_processed', 0) > 1: + response_data['chunks_processed'] = result['chunks_processed'] + response_data['total_chunks'] = result.get('total_chunks', result['chunks_processed']) + return jsonify(response_data) else: logger.error(f"Processing failed: {result['message']}") return jsonify({ @@ -1108,8 +1123,19 @@ def generate_pdf(): # Handle CORS preflight requests for all API routes @app.route('/api/', methods=['OPTIONS']) def handle_options(path): + # Get the origin from the request + origin = request.headers.get('Origin') + allowed_origins = ['https://ai-sandbox.oliver.solutions', 'http://localhost:3000'] + response = jsonify({}) - response.headers.add('Access-Control-Allow-Origin', 'https://ai-sandbox.oliver.solutions') + + # Allow the origin if it's in our allowed list + if origin in allowed_origins: + response.headers.add('Access-Control-Allow-Origin', origin) + else: + # Default to production origin + response.headers.add('Access-Control-Allow-Origin', 'https://ai-sandbox.oliver.solutions') + response.headers.add('Access-Control-Allow-Headers', 'Content-Type,Authorization,X-Requested-With') response.headers.add('Access-Control-Allow-Methods', 'GET,POST,OPTIONS') response.headers.add('Access-Control-Max-Age', '86400') # 24 hours diff --git a/backend/chunked_upload.py b/backend/chunked_upload.py index a94e877..cbe28a6 100644 --- a/backend/chunked_upload.py +++ b/backend/chunked_upload.py @@ -4,18 +4,44 @@ import json from flask import Blueprint, request, jsonify, current_app from werkzeug.utils import secure_filename import logging -from auth import require_auth +from auth import lenient_auth logger = logging.getLogger('video_query') # Create blueprint for handling chunked uploads chunked_upload_bp = Blueprint('chunked_upload', __name__) +# CORS preflight handler for all blueprint routes +def handle_cors_preflight(): + """Handle CORS preflight requests""" + origin = request.headers.get('Origin') + allowed_origins = ['https://ai-sandbox.oliver.solutions', 'http://localhost:3000'] + + response = jsonify({}) + + # Allow the origin if it's in our allowed list + if origin in allowed_origins: + response.headers.add('Access-Control-Allow-Origin', origin) + else: + # Default to production origin + response.headers.add('Access-Control-Allow-Origin', 'https://ai-sandbox.oliver.solutions') + + response.headers.add('Access-Control-Allow-Headers', 'Content-Type,Authorization,X-Requested-With') + response.headers.add('Access-Control-Allow-Methods', 'GET,POST,OPTIONS') + response.headers.add('Access-Control-Max-Age', '86400') # 24 hours + response.headers.add('Access-Control-Allow-Credentials', 'true') + return response + # Track upload sessions active_uploads = {} +@chunked_upload_bp.route('/api/init-upload', methods=['OPTIONS']) +def init_upload_options(): + """Handle CORS preflight for init-upload""" + return handle_cors_preflight() + @chunked_upload_bp.route('/api/init-upload', methods=['POST']) -@require_auth +@lenient_auth def init_upload(): """Initialize a new chunked upload session""" if not request.is_json: @@ -59,8 +85,13 @@ def init_upload(): "upload_id": upload_id }) +@chunked_upload_bp.route('/api/upload-chunk/', methods=['OPTIONS']) +def upload_chunk_options(upload_id): + """Handle CORS preflight for upload-chunk""" + return handle_cors_preflight() + @chunked_upload_bp.route('/api/upload-chunk/', methods=['POST']) -@require_auth +@lenient_auth def upload_chunk(upload_id): """Handle a chunk of file data""" if upload_id not in active_uploads: @@ -102,8 +133,13 @@ def upload_chunk(upload_id): "complete": upload['complete'] }) +@chunked_upload_bp.route('/api/complete-upload/', methods=['OPTIONS']) +def complete_upload_options(upload_id): + """Handle CORS preflight for complete-upload""" + return handle_cors_preflight() + @chunked_upload_bp.route('/api/complete-upload/', methods=['POST']) -@require_auth +@lenient_auth def complete_upload(upload_id): """Mark an upload as complete and return the file path for processing""" if upload_id not in active_uploads: @@ -140,8 +176,13 @@ def complete_upload(upload_id): "size": upload['uploaded_size'] }) +@chunked_upload_bp.route('/api/cancel-upload/', methods=['OPTIONS']) +def cancel_upload_options(upload_id): + """Handle CORS preflight for cancel-upload""" + return handle_cors_preflight() + @chunked_upload_bp.route('/api/cancel-upload/', methods=['POST']) -@require_auth +@lenient_auth def cancel_upload(upload_id): """Cancel an upload and delete the partial file""" if upload_id not in active_uploads: diff --git a/backend/video_processor.py b/backend/video_processor.py index fdf0aa8..4e89bb7 100644 --- a/backend/video_processor.py +++ b/backend/video_processor.py @@ -6,8 +6,12 @@ import logging import requests import json import datetime -from typing import Dict, Any, Optional +import base64 +from typing import Dict, Any, Optional, List, Tuple from dotenv import load_dotenv +from video_splitter import VideoSplitter +from concurrent.futures import ThreadPoolExecutor, as_completed +import threading # Load environment variables from .env file load_dotenv() @@ -28,15 +32,28 @@ class VideoProcessor: # Maximum video duration in minutes (Gemini limitation) MAX_VIDEO_DURATION = 55 - + # Threshold for chunked upload (10MB) CHUNKED_UPLOAD_THRESHOLD = 10 * 1024 * 1024 - + # Webhook URL for tracking usage WEBHOOK_URL = "https://hook.us1.make.celonis.com/8ri1h8b2he4wudp2jku69mgcxumzxf3v" - def __init__(self, api_key: Optional[str] = None): - """Initialize with API key from environment variable or direct setting""" + # Parallel processing configuration + # Default max workers for parallel chunk processing + # Free tier: 5 RPM (use 3-4 workers to be safe) + # Paid tier: 150 RPM (can use more workers) + DEFAULT_MAX_WORKERS = 4 # Conservative default for free tier + + def __init__(self, api_key: Optional[str] = None, max_parallel_chunks: int = None): + """ + Initialize with API key from environment variable or direct setting + + Args: + api_key: Google API key for Gemini + max_parallel_chunks: Maximum number of chunks to process in parallel + (default: 4, recommended 3-4 for free tier, up to 10+ for paid tier) + """ self.api_key = api_key or os.getenv("GOOGLE_API_KEY") if not self.api_key: logger.error("API key not provided") @@ -46,6 +63,16 @@ class VideoProcessor: logger.info("Initializing Gemini API client") self.client = genai.Client(api_key=self.api_key) logger.info("Gemini API client initialized successfully") + + # Set parallel processing configuration + self.max_parallel_chunks = max_parallel_chunks or self.DEFAULT_MAX_WORKERS + logger.info(f"Parallel processing enabled with max {self.max_parallel_chunks} concurrent chunks") + + # Initialize video splitter + self.video_splitter = VideoSplitter() + + # Thread lock for rate limiting + self._rate_limit_lock = threading.Lock() def send_usage_webhook(self, user_email: str, prompt: str) -> None: """ @@ -92,66 +119,39 @@ class VideoProcessor: def process_video(self, video_path: str, prompt: str, user_email: str = "anonymous") -> Dict[str, Any]: """ Process a video with the given prompt using Gemini API - + Args: video_path: Path to the video file prompt: Text prompt to use for video analysis user_email: Email of the user processing the video (for usage tracking) - + Returns: Dictionary with processing result or error """ + start_time = time.time() + result = { "success": False, "message": "", - "content": "" + "content": "", + "processing_time_seconds": 0 } - + logger.info(f"Processing video: {video_path}") logger.info(f"Prompt: {prompt[:100]}..." if len(prompt) > 100 else f"Prompt: {prompt}") - + if not os.path.exists(video_path): error_msg = f"Video file not found at '{video_path}'" logger.error(error_msg) result["message"] = error_msg return result - + try: # Get file size file_size = os.path.getsize(video_path) - logger.info(f"File size: {file_size / (1024 * 1024):.2f} MB") - - # Upload the video file - logger.info("Uploading video to Gemini API...") - - # Log the file size in relation to our threshold (for informational purposes only) - if file_size > self.CHUNKED_UPLOAD_THRESHOLD: - logger.info(f"File size exceeds {self.CHUNKED_UPLOAD_THRESHOLD/(1024*1024):.2f} MB threshold") - else: - logger.info(f"File size below {self.CHUNKED_UPLOAD_THRESHOLD/(1024*1024):.2f} MB threshold") - - # All uploads use the same method (our chunking happens in the frontend) - # Google API may handle large files internally in their own way - # Note: display_name is not supported in the new google-genai SDK - video_file = self.client.files.upload(file=video_path) - logger.info(f"Upload successful. File URI: {video_file.uri}") - logger.info(f"Initial file state: {video_file.state.name}") - - # Wait for processing if needed - processing_wait_count = 0 - while video_file.state.name == "PROCESSING": - processing_wait_count += 1 - logger.info(f"File is still processing. Wait count: {processing_wait_count}") - time.sleep(2) # Wait for 2 seconds before checking again - video_file = self.client.files.get(name=video_file.name) # Re-fetch file state - logger.info(f"Updated file state: {video_file.state.name}") - - if video_file.state.name != "ACTIVE": - error_msg = f"Error: File did not become active. Current state: {video_file.state.name}" - logger.error(error_msg) - result["message"] = error_msg - return result - + file_size_mb = file_size / (1024 * 1024) + logger.info(f"File size: {file_size_mb:.2f} MB") + # Determine MIME type for the video mime_type, _ = mimetypes.guess_type(video_path) if not mime_type: @@ -159,23 +159,82 @@ class VideoProcessor: mime_type = "video/mp4" # Fallback else: logger.info(f"MIME type: {mime_type}") - - # Create the content parts for the prompt - prompt_parts = [ - {"text": prompt}, - {"file_data": { - "file_uri": video_file.uri, - "mime_type": mime_type - }} - ] - - # Generate content using the client + + # Use different approach based on file size + # Small files (< 10MB): use inline base64 data (faster, no upload wait) + # Large files (>= 10MB): use file upload API (handles larger files) + # Note: Base64 adds ~37% overhead, so 10MB file = ~13.7MB base64 + SIZE_THRESHOLD_MB = 10 + uploaded_file = None + + if file_size_mb < SIZE_THRESHOLD_MB: + # Small file: Use base64 encoding for inline data + logger.info(f"File < {SIZE_THRESHOLD_MB}MB, using inline base64 data") + with open(video_path, "rb") as video_file_obj: + video_data = video_file_obj.read() + video_base64 = base64.b64encode(video_data).decode('utf-8') + + logger.info(f"Base64 encoding complete. Size: {len(video_base64)} characters") + + # Create the content parts using inline data + prompt_parts = [ + {"text": prompt}, + {"inline_data": { + "mime_type": mime_type, + "data": video_base64 + }} + ] + else: + # Large file: Use file upload API + logger.info(f"File >= {SIZE_THRESHOLD_MB}MB, using file upload API") + upload_start = time.time() + + uploaded_file = self.client.files.upload( + file=video_path + ) + logger.info(f"Upload complete in {time.time() - upload_start:.1f}s. File URI: {uploaded_file.uri}") + logger.info(f"Initial file state: {uploaded_file.state}") + + # Wait for file to be processed + while uploaded_file.state == "PROCESSING": + logger.info("File is still processing, waiting...") + time.sleep(2) + uploaded_file = self.client.files.get(name=uploaded_file.name) + logger.info(f"Updated file state: {uploaded_file.state}") + + if uploaded_file.state != "ACTIVE": + error_msg = f"File upload failed. State: {uploaded_file.state}" + logger.error(error_msg) + result["message"] = error_msg + return result + + logger.info("File is ACTIVE and ready for processing") + + # Create content parts using file reference + prompt_parts = [ + {"text": prompt}, + {"file_data": { + "file_uri": uploaded_file.uri, + "mime_type": mime_type + }} + ] + + # Rate limiting: Wait to avoid hitting API limits + # Free tier: 5 RPM, so minimum 12 seconds between requests + with self._rate_limit_lock: + time.sleep(2) # 2 second delay between API calls + + # Use the client to generate content with the new SDK API logger.info("Sending prompt to Gemini for processing...") + api_start = time.time() + response = self.client.models.generate_content( - model='gemini-2.5-pro', + model="gemini-2.5-pro", contents=prompt_parts ) - logger.info("Received response from Gemini") + + api_time = time.time() - api_start + logger.info(f"Received response from Gemini (API call took {api_time:.1f}s)") # Extract the response content content = "" @@ -197,19 +256,22 @@ class VideoProcessor: # Set success result result["success"] = True result["content"] = content + result["processing_time_seconds"] = round(time.time() - start_time, 2) logger.info(f"Processed result with {len(content)} characters") - + logger.info(f"Total processing time: {result['processing_time_seconds']}s") + # Send usage data to webhook for tracking self.send_usage_webhook(user_email, prompt) - - # Attempt to delete the file from Gemini storage - try: - logger.info(f"Deleting file from Gemini storage: {video_file.name}") - self.client.files.delete(name=video_file.name) - logger.info("File deleted successfully from Gemini storage") - except Exception as del_err: - logger.warning(f"Could not delete file from Gemini storage: {str(del_err)}") - + + # Clean up uploaded file if it was used + if uploaded_file: + try: + logger.info(f"Deleting uploaded file: {uploaded_file.name}") + self.client.files.delete(name=uploaded_file.name) + logger.info("File deleted successfully from Gemini storage") + except Exception as del_err: + logger.warning(f"Could not delete file from Gemini storage: {str(del_err)}") + return result except Exception as e: @@ -219,4 +281,470 @@ class VideoProcessor: logger.error(error_details) result["message"] = f"Error processing video: {str(e)}" result["error_details"] = error_details - return result \ No newline at end of file + return result + + def combine_chunk_responses(self, responses: List[str], prompt: str, + num_chunks: int) -> str: + """ + Intelligently combine responses from multiple video chunks. + + Args: + responses: List of response texts from each chunk + prompt: Original prompt used for processing + num_chunks: Total number of chunks processed + + Returns: + Combined response text + """ + logger.info(f"Combining {len(responses)} chunk responses") + + # Detect the prompt type to determine combination strategy + prompt_lower = prompt.lower() + is_meeting_summary = "meeting" in prompt_lower or "summary" in prompt_lower + is_documentation = "documentation" in prompt_lower or "process" in prompt_lower + is_with_charts = "mermaid" in prompt_lower or "diagram" in prompt_lower or "chart" in prompt_lower + + if is_with_charts: + return self._combine_with_charts(responses, num_chunks) + elif is_meeting_summary: + return self._combine_meeting_summary(responses, num_chunks) + elif is_documentation: + return self._combine_documentation(responses, num_chunks) + else: + return self._combine_generic(responses, num_chunks) + + def _combine_generic(self, responses: List[str], num_chunks: int) -> str: + """Generic combination: simple sequential joining with section headers.""" + logger.info("Using generic combination strategy") + combined = [] + + combined.append(f"# Complete Video Analysis\n") + combined.append(f"*This video was processed in {num_chunks} parts due to its length.*\n") + + for i, response in enumerate(responses, 1): + combined.append(f"\n## Part {i} of {num_chunks}\n") + combined.append(response.strip()) + + return "\n".join(combined) + + def _combine_meeting_summary(self, responses: List[str], num_chunks: int) -> str: + """Combination strategy optimized for meeting summaries.""" + logger.info("Using meeting summary combination strategy") + + # First, try to synthesize the segments into a unified summary + try: + logger.info("Attempting to synthesize segments into unified meeting summary") + synthesized = self._synthesize_meeting_segments(responses, num_chunks) + if synthesized: + return synthesized + else: + logger.warning("Synthesis failed, falling back to segment concatenation") + except Exception as e: + logger.warning(f"Error during synthesis: {e}, falling back to segment concatenation") + + # Fallback: simple concatenation with formatting + combined = [] + + combined.append(f"# Complete Meeting Recording Summary\n") + combined.append(f"*This recording was analyzed in {num_chunks} segments.*\n") + combined.append(f"\n---\n") + + # Combine all discussion points with clear time markers + for i, response in enumerate(responses, 1): + time_range = self._format_time_range(i, num_chunks) + combined.append(f"\n## Segment {i}: {time_range}\n") + combined.append(response.strip()) + combined.append(f"\n---\n") + + # Add consolidated note + combined.append(f"\n### Notes") + combined.append(f"- Review all segments above for discussion points and action items") + combined.append(f"- Total recording duration: ~{num_chunks * 50} minutes") + combined.append(f"- Recording was split into {num_chunks} segments for analysis") + + return "\n".join(combined) + + def _synthesize_meeting_segments(self, responses: List[str], num_chunks: int) -> Optional[str]: + """ + Use AI to synthesize multiple segment summaries into one unified meeting summary. + + Args: + responses: List of segment summaries + num_chunks: Number of segments + + Returns: + Unified meeting summary or None if synthesis fails + """ + try: + # Prepare the segments for synthesis + segments_text = "" + for i, response in enumerate(responses, 1): + time_range = self._format_time_range(i, num_chunks) + segments_text += f"\n\n### Segment {i} ({time_range}):\n{response.strip()}\n" + + # Create synthesis prompt + synthesis_prompt = f"""You are analyzing a meeting recording that was split into {num_chunks} segments due to its length. Below are the summaries from each segment. Your task is to create ONE unified, comprehensive meeting summary that integrates all the information. + +SEGMENT SUMMARIES: +{segments_text} + +Please provide a SINGLE, UNIFIED meeting summary that: +1. Combines all discussion points into one cohesive narrative (not separated by segments) +2. Consolidates all action items into one master list (removing duplicates if any) +3. Identifies main themes and outcomes across the entire meeting +4. Maintains chronological flow where relevant +5. Uses clear sections: Meeting Summary, Discussion Points, Action Items (with owners) + +Format the output as a professional meeting summary document. Do not reference the segments in your output - write as if this was analyzed as one continuous meeting.""" + + logger.info("Sending synthesis request to Gemini") + synthesis_response = self.client.models.generate_content( + model="gemini-2.5-pro", + contents=synthesis_prompt + ) + + if synthesis_response.parts: + synthesized_content = "" + for part in synthesis_response.parts: + if hasattr(part, 'text'): + synthesized_content += part.text + + if synthesized_content: + logger.info("Successfully synthesized unified meeting summary") + # Add header noting this was synthesized + final_output = "# Meeting Summary\n\n" + final_output += f"*Synthesized from {num_chunks}-segment analysis*\n\n" + final_output += "---\n\n" + final_output += synthesized_content + return final_output + + logger.warning("No content in synthesis response") + return None + + except Exception as e: + logger.error(f"Error during synthesis: {str(e)}") + return None + + def _combine_documentation(self, responses: List[str], num_chunks: int) -> str: + """Combination strategy optimized for process documentation.""" + logger.info("Using documentation combination strategy") + combined = [] + + combined.append(f"# Complete Process Documentation\n") + combined.append(f"*This process was documented from a {num_chunks}-part video recording.*\n") + + combined.append(f"\n## Overview\n") + combined.append(f"This documentation covers the complete process shown in the video. " + f"The content has been organized sequentially across all segments.\n") + + for i, response in enumerate(responses, 1): + combined.append(f"\n## Section {i}: {self._format_time_range(i, num_chunks)}\n") + combined.append(response.strip()) + + combined.append(f"\n\n---\n*End of documentation*") + + return "\n".join(combined) + + def _combine_with_charts(self, responses: List[str], num_chunks: int) -> str: + """Combination strategy for documentation with Mermaid diagrams.""" + logger.info("Using documentation with charts combination strategy") + combined = [] + + combined.append(f"# Complete Process Documentation with Workflow Diagrams\n") + combined.append(f"*This analysis spans {num_chunks} video segments.*\n") + + # First, add all text content + combined.append(f"\n## Overview and Detailed Steps\n") + + for i, response in enumerate(responses, 1): + combined.append(f"\n### Part {i}: {self._format_time_range(i, num_chunks)}\n") + + # Separate mermaid diagrams from text content + parts = response.split("```mermaid") + text_part = parts[0].strip() + combined.append(text_part) + + # Add mermaid diagrams in a dedicated section + if len(parts) > 1: + for j, diagram_part in enumerate(parts[1:], 1): + if "```" in diagram_part: + diagram_code = diagram_part.split("```")[0] + combined.append(f"\n**Workflow Diagram {i}.{j}:**\n") + combined.append(f"```mermaid{diagram_code}```\n") + + # Add any remaining text after the diagram + remaining_text = "```".join(diagram_part.split("```")[1:]).strip() + if remaining_text: + combined.append(remaining_text) + + combined.append(f"\n\n---\n*Complete documentation generated from {num_chunks}-part video analysis*") + + return "\n".join(combined) + + def _format_time_range(self, part_num: int, total_parts: int, + chunk_duration: int = 50) -> str: + """Format time range for a video part.""" + start_min = (part_num - 1) * chunk_duration + end_min = part_num * chunk_duration if part_num < total_parts else "End" + + if isinstance(end_min, int): + return f"{start_min}-{end_min} minutes" + else: + return f"{start_min}+ minutes" + + def _process_single_chunk(self, chunk_info: Tuple[int, str, str, int, str]) -> Tuple[int, Dict[str, Any]]: + """ + Process a single video chunk. Used for parallel processing. + + Args: + chunk_info: Tuple of (chunk_index, chunk_path, chunk_prompt, total_chunks, user_email) + + Returns: + Tuple of (chunk_index, result_dict) + """ + chunk_index, chunk_path, chunk_prompt, total_chunks, user_email = chunk_info + + logger.info(f"[Parallel] Processing chunk {chunk_index + 1}/{total_chunks}: {chunk_path}") + + try: + chunk_result = self.process_video(chunk_path, chunk_prompt, user_email) + logger.info(f"[Parallel] Completed chunk {chunk_index + 1}/{total_chunks}") + return (chunk_index, chunk_result) + except Exception as e: + logger.error(f"[Parallel] Error processing chunk {chunk_index + 1}/{total_chunks}: {str(e)}") + return (chunk_index, { + "success": False, + "message": f"Error processing chunk {chunk_index + 1}: {str(e)}", + "content": "" + }) + + def _process_chunks_parallel(self, chunk_paths: List[str], prompt: str, + user_email: str) -> List[Dict[str, Any]]: + """ + Process multiple video chunks in parallel using ThreadPoolExecutor. + + Args: + chunk_paths: List of paths to video chunk files + prompt: Original prompt for video analysis + user_email: User email for tracking + + Returns: + List of result dictionaries in order of chunks + """ + num_chunks = len(chunk_paths) + logger.info(f"Starting parallel processing of {num_chunks} chunks with {self.max_parallel_chunks} workers") + + # Prepare chunk information for parallel processing + chunk_infos = [] + for i, chunk_path in enumerate(chunk_paths): + chunk_prompt = self._create_chunk_prompt(prompt, i + 1, num_chunks) + chunk_infos.append((i, chunk_path, chunk_prompt, num_chunks, user_email)) + + # Process chunks in parallel + results = [None] * num_chunks # Pre-allocate results list to maintain order + + with ThreadPoolExecutor(max_workers=self.max_parallel_chunks) as executor: + # Submit all chunks for processing + future_to_chunk = { + executor.submit(self._process_single_chunk, chunk_info): chunk_info[0] + for chunk_info in chunk_infos + } + + # Collect results as they complete + completed = 0 + for future in as_completed(future_to_chunk): + chunk_index = future_to_chunk[future] + try: + chunk_index, result = future.result() + results[chunk_index] = result + completed += 1 + logger.info(f"[Parallel] Progress: {completed}/{num_chunks} chunks completed") + except Exception as e: + logger.error(f"[Parallel] Unexpected error for chunk {chunk_index + 1}: {str(e)}") + results[chunk_index] = { + "success": False, + "message": f"Unexpected error: {str(e)}", + "content": "" + } + + logger.info(f"[Parallel] All {num_chunks} chunks processed") + return results + + def process_long_video(self, video_path: str, prompt: str, + user_email: str = "anonymous", use_parallel: bool = True) -> Dict[str, Any]: + """ + Process a long video by splitting it into chunks and combining the results. + Supports both parallel and sequential processing. + + Args: + video_path: Path to the video file + prompt: Text prompt to use for video analysis + user_email: Email of the user processing the video (for usage tracking) + use_parallel: If True, process chunks in parallel; if False, process sequentially + + Returns: + Dictionary with processing result or error + """ + start_time = time.time() + + result = { + "success": False, + "message": "", + "content": "", + "chunks_processed": 0, + "processing_mode": "parallel" if use_parallel else "sequential", + "processing_time_seconds": 0 + } + + chunk_paths = [] + + try: + # Check if video needs splitting + num_chunks, duration_minutes = self.video_splitter.get_chunk_info(video_path) + + if num_chunks <= 1: + logger.info("Video does not need splitting, processing normally") + return self.process_video(video_path, prompt, user_email) + + logger.info(f"Long video detected: {duration_minutes:.2f} minutes, will be split into {num_chunks} chunks") + logger.info(f"Processing mode: {'PARALLEL' if use_parallel else 'SEQUENTIAL'}") + + # Split the video + logger.info("Starting video splitting...") + chunk_paths = self.video_splitter.split_video(video_path) + logger.info(f"Video split into {len(chunk_paths)} chunks successfully") + + # Process chunks (parallel or sequential) + if use_parallel: + # Parallel processing using ThreadPoolExecutor + chunk_results = self._process_chunks_parallel(chunk_paths, prompt, user_email) + else: + # Sequential processing (original logic) + chunk_results = [] + for i, chunk_path in enumerate(chunk_paths, 1): + logger.info(f"[Sequential] Processing chunk {i}/{len(chunk_paths)}: {chunk_path}") + + # Modify prompt to indicate this is part of a multi-part video + chunk_prompt = self._create_chunk_prompt(prompt, i, len(chunk_paths)) + + # Process this chunk + chunk_result = self.process_video(chunk_path, chunk_prompt, user_email) + chunk_results.append(chunk_result) + + logger.info(f"[Sequential] Completed chunk {i}/{len(chunk_paths)}") + + # Check for failures in any chunk + chunk_responses = [] + for i, chunk_result in enumerate(chunk_results, 1): + if not chunk_result["success"]: + error_msg = f"Failed to process chunk {i}/{len(chunk_paths)}: {chunk_result.get('message', 'Unknown error')}" + logger.error(error_msg) + result["message"] = error_msg + result["chunks_processed"] = i - 1 + return result + + chunk_responses.append(chunk_result["content"]) + + # Combine all responses + logger.info("Combining responses from all chunks...") + combined_content = self.combine_chunk_responses( + chunk_responses, + prompt, + len(chunk_paths) + ) + + result["success"] = True + result["content"] = combined_content + result["chunks_processed"] = len(chunk_paths) + result["processing_time_seconds"] = round(time.time() - start_time, 2) + result["message"] = f"Successfully processed video in {len(chunk_paths)} chunks" + + logger.info(f"Long video processing completed successfully: {len(chunk_paths)} chunks") + logger.info(f"Total processing time: {result['processing_time_seconds']}s") + + return result + + except Exception as e: + import traceback + error_details = traceback.format_exc() + logger.error(f"Error processing long video: {str(e)}") + logger.error(error_details) + result["message"] = f"Error processing long video: {str(e)}" + result["error_details"] = error_details + return result + + finally: + # Always clean up chunk files + if chunk_paths: + logger.info("Cleaning up temporary chunk files...") + self.video_splitter.cleanup_chunks(chunk_paths) + + def _create_chunk_prompt(self, original_prompt: str, chunk_num: int, + total_chunks: int) -> str: + """ + Create a prompt for a video chunk that provides context about its position. + + Args: + original_prompt: The original user prompt + chunk_num: Current chunk number (1-indexed) + total_chunks: Total number of chunks + + Returns: + Modified prompt for the chunk + """ + # For meeting summaries, modify the prompt to focus on just summarizing what's in this segment + prompt_lower = original_prompt.lower() + is_meeting = "meeting" in prompt_lower + + if is_meeting: + # For meetings, ask for a partial summary of this segment only + if chunk_num == 1: + context = f"[SEGMENT {chunk_num} of {total_chunks} - First 50 minutes] " + context += "Provide a summary of the discussion points and any action items covered in THIS segment only. " + context += "Do not try to provide a complete meeting summary - just summarize what happens in this part. " + elif chunk_num == total_chunks: + context = f"[SEGMENT {chunk_num} of {total_chunks} - Final segment] " + context += "Provide a summary of the discussion points and any action items covered in THIS final segment only. " + context += "This continues from previous segments, but only summarize what happens in this part. " + else: + context = f"[SEGMENT {chunk_num} of {total_chunks} - Middle segment] " + context += "Provide a summary of the discussion points and any action items covered in THIS segment only. " + context += "This is a middle portion of a longer recording - only summarize what happens in this part. " + + return context + original_prompt + else: + # For other types, use the original approach + context = f"[PART {chunk_num} of {total_chunks}] " + + if chunk_num == 1: + context += "This is the first segment of a longer video. " + elif chunk_num == total_chunks: + context += "This is the final segment continuing from previous parts. " + else: + context += "This is a middle segment continuing from previous parts. " + + return context + original_prompt + + def process_video_auto(self, video_path: str, prompt: str, + user_email: str = "anonymous") -> Dict[str, Any]: + """ + Automatically process a video, handling both short and long videos. + This method detects if the video needs splitting and processes accordingly. + + Args: + video_path: Path to the video file + prompt: Text prompt to use for video analysis + user_email: Email of the user processing the video (for usage tracking) + + Returns: + Dictionary with processing result or error + """ + logger.info(f"Auto-processing video: {video_path}") + + # Check if video needs splitting + if self.video_splitter.needs_splitting(video_path): + logger.info("Video requires splitting, using long video processing") + return self.process_long_video(video_path, prompt, user_email) + else: + logger.info("Video is within single-chunk limit, using standard processing") + return self.process_video(video_path, prompt, user_email) \ No newline at end of file diff --git a/backend/video_splitter.py b/backend/video_splitter.py new file mode 100644 index 0000000..b5af3ab --- /dev/null +++ b/backend/video_splitter.py @@ -0,0 +1,238 @@ +""" +Video Splitter Module + +This module provides functionality to detect video duration and split long videos +into smaller chunks for processing with APIs that have duration limitations. +""" + +import ffmpeg +import os +import tempfile +import logging +from typing import List, Tuple, Optional + +logger = logging.getLogger('video_query') + + +class VideoSplitter: + """ + Handles video duration detection and splitting operations. + """ + + # Default chunk duration in minutes (25 min to avoid API timeouts) + DEFAULT_CHUNK_DURATION = 25 + + def __init__(self, chunk_duration_minutes: int = DEFAULT_CHUNK_DURATION): + """ + Initialize VideoSplitter with specified chunk duration. + + Args: + chunk_duration_minutes: Duration of each chunk in minutes (default: 50) + """ + self.chunk_duration_minutes = chunk_duration_minutes + self.chunk_duration_seconds = chunk_duration_minutes * 60 + logger.info(f"VideoSplitter initialized with chunk duration: {chunk_duration_minutes} minutes") + + def get_video_duration(self, video_path: str) -> Optional[float]: + """ + Get the duration of a video file in seconds. + + Args: + video_path: Path to the video file + + Returns: + Duration in seconds, or None if unable to determine + """ + try: + logger.info(f"Detecting duration for video: {video_path}") + # Explicitly set ffprobe command path to avoid PATH issues + probe = ffmpeg.probe(video_path, cmd='/usr/bin/ffprobe') + + # Get duration from video stream + video_info = next( + (stream for stream in probe['streams'] if stream['codec_type'] == 'video'), + None + ) + + if video_info and 'duration' in video_info: + duration = float(video_info['duration']) + elif 'format' in probe and 'duration' in probe['format']: + duration = float(probe['format']['duration']) + else: + logger.error("Could not find duration in video metadata") + return None + + logger.info(f"Video duration: {duration:.2f} seconds ({duration/60:.2f} minutes)") + return duration + + except ffmpeg.Error as e: + logger.error(f"FFmpeg error while detecting duration: {e.stderr.decode() if e.stderr else str(e)}") + return None + except Exception as e: + logger.error(f"Error detecting video duration: {str(e)}") + return None + + def needs_splitting(self, video_path: str) -> bool: + """ + Check if a video needs to be split based on its duration. + + Args: + video_path: Path to the video file + + Returns: + True if video duration exceeds chunk duration, False otherwise + """ + duration = self.get_video_duration(video_path) + if duration is None: + logger.warning("Could not determine if video needs splitting") + return False + + needs_split = duration > self.chunk_duration_seconds + if needs_split: + logger.info(f"Video needs splitting: {duration/60:.2f} min > {self.chunk_duration_minutes} min") + else: + logger.info(f"Video does not need splitting: {duration/60:.2f} min <= {self.chunk_duration_minutes} min") + + return needs_split + + def split_video(self, video_path: str, output_dir: Optional[str] = None) -> List[str]: + """ + Split a video into multiple chunks based on the configured chunk duration. + + Args: + video_path: Path to the video file to split + output_dir: Directory to save chunks (default: system temp directory) + + Returns: + List of paths to the generated chunk files + """ + duration = self.get_video_duration(video_path) + if duration is None: + raise ValueError("Could not determine video duration") + + # Use temp directory if none specified + if output_dir is None: + output_dir = tempfile.mkdtemp(prefix="video_chunks_") + logger.info(f"Using temporary directory for chunks: {output_dir}") + else: + os.makedirs(output_dir, exist_ok=True) + + # Calculate number of chunks needed + num_chunks = int(duration / self.chunk_duration_seconds) + ( + 1 if duration % self.chunk_duration_seconds > 0 else 0 + ) + logger.info(f"Splitting video into {num_chunks} chunks") + + chunk_paths = [] + video_basename = os.path.splitext(os.path.basename(video_path))[0] + video_extension = os.path.splitext(video_path)[1] + + for i in range(num_chunks): + start_time = i * self.chunk_duration_seconds + chunk_output = os.path.join( + output_dir, + f"{video_basename}_chunk_{i+1:02d}{video_extension}" + ) + + logger.info(f"Creating chunk {i+1}/{num_chunks}: start={start_time}s, output={chunk_output}") + + try: + # Split the video using ffmpeg + # Using -t to specify duration of this chunk + # Using -c copy for fast processing (no re-encoding) + stream = ffmpeg.input(video_path, ss=start_time, t=self.chunk_duration_seconds) + stream = ffmpeg.output( + stream, + chunk_output, + c='copy', # Copy streams without re-encoding for speed + map='0', # Include all streams from input + avoid_negative_ts='make_zero' # Handle timestamp issues + ) + ffmpeg.run(stream, capture_stdout=True, capture_stderr=True, overwrite_output=True) + + chunk_paths.append(chunk_output) + logger.info(f"Successfully created chunk {i+1}/{num_chunks}") + + except ffmpeg.Error as e: + error_msg = e.stderr.decode() if e.stderr else str(e) + logger.error(f"FFmpeg error creating chunk {i+1}: {error_msg}") + # Clean up any created chunks on error + self.cleanup_chunks(chunk_paths) + raise RuntimeError(f"Failed to create video chunk {i+1}: {error_msg}") + except Exception as e: + logger.error(f"Error creating chunk {i+1}: {str(e)}") + self.cleanup_chunks(chunk_paths) + raise + + logger.info(f"Successfully split video into {len(chunk_paths)} chunks") + return chunk_paths + + def cleanup_chunks(self, chunk_paths: List[str]) -> None: + """ + Delete temporary chunk files. + + Args: + chunk_paths: List of paths to chunk files to delete + """ + if not chunk_paths: + return + + logger.info(f"Cleaning up {len(chunk_paths)} chunk files") + for chunk_path in chunk_paths: + try: + if os.path.exists(chunk_path): + os.remove(chunk_path) + logger.debug(f"Deleted chunk: {chunk_path}") + except Exception as e: + logger.warning(f"Could not delete chunk {chunk_path}: {str(e)}") + + # Try to remove the temp directory if it's empty + if chunk_paths: + chunk_dir = os.path.dirname(chunk_paths[0]) + try: + if os.path.exists(chunk_dir) and not os.listdir(chunk_dir): + os.rmdir(chunk_dir) + logger.debug(f"Deleted temporary directory: {chunk_dir}") + except Exception as e: + logger.warning(f"Could not delete temporary directory {chunk_dir}: {str(e)}") + + def get_chunk_info(self, video_path: str) -> Tuple[int, float]: + """ + Get information about how a video would be chunked without actually splitting it. + + Args: + video_path: Path to the video file + + Returns: + Tuple of (number_of_chunks, total_duration_in_minutes) + """ + duration = self.get_video_duration(video_path) + if duration is None: + return (0, 0.0) + + duration_minutes = duration / 60 + num_chunks = int(duration / self.chunk_duration_seconds) + ( + 1 if duration % self.chunk_duration_seconds > 0 else 0 + ) + + return (num_chunks, duration_minutes) + + +# Convenience functions for direct use +def get_video_duration(video_path: str) -> Optional[float]: + """Get video duration in seconds.""" + splitter = VideoSplitter() + return splitter.get_video_duration(video_path) + + +def split_video(video_path: str, chunk_duration_minutes: int = 50, + output_dir: Optional[str] = None) -> List[str]: + """Split a video into chunks.""" + splitter = VideoSplitter(chunk_duration_minutes=chunk_duration_minutes) + return splitter.split_video(video_path, output_dir=output_dir) + + +def cleanup_chunks(chunk_paths: List[str]) -> None: + """Clean up chunk files.""" + splitter = VideoSplitter() + splitter.cleanup_chunks(chunk_paths) diff --git a/frontend/.env b/frontend/.env index ef95ff8..569fb6a 100644 --- a/frontend/.env +++ b/frontend/.env @@ -2,4 +2,7 @@ # The app now uses runtime configuration from config.json for base path detection # Optional: Set this if you want to override the runtime base path detection -# REACT_APP_BASE_PATH_OVERRIDE=/your-custom-path \ No newline at end of file +# REACT_APP_BASE_PATH_OVERRIDE=/your-custom-path + +# Temporarily disable Azure AD authentication for testing +REACT_APP_DISABLE_AUTH=true \ No newline at end of file diff --git a/frontend/CONFIG_README.md b/frontend/CONFIG_README.md new file mode 100644 index 0000000..e800011 --- /dev/null +++ b/frontend/CONFIG_README.md @@ -0,0 +1,65 @@ +# Frontend Configuration Guide + +## Overview + +The frontend uses two configuration files to support both local development and production deployment: + +1. **`config.js`** - Production configuration (ALWAYS committed to git) +2. **`config.local.js`** - Local development configuration (NEVER committed to git) + +## How It Works + +The `index.html` loads both files in order: +1. First loads `config.js` (production config) +2. Then loads `config.local.js` (if it exists, overrides production config) + +In production, only `config.js` exists, so production settings are used. +In development, `config.local.js` overrides the production settings to point to localhost. + +## Local Development Setup + +**`config.local.js`** is already created and configured to point to: +- Frontend: `http://localhost:3000` +- Backend: `http://localhost:5010` + +This file is listed in `.gitignore` and will NOT be committed to git. + +## Production Deployment + +**`config.js`** contains production settings: +- Frontend: `https://brandtechsandbox.oliver.solutions/video-query/` +- Backend: `https://brandtechsandbox.oliver.solutions/video_query_back` + +When deploying to production: +1. Only `config.js` is deployed (config.local.js is excluded) +2. The application automatically uses production URLs +3. No manual configuration changes needed + +## Important Notes + +- ✅ **DO commit** `config.js` (production config) +- ❌ **DO NOT commit** `config.local.js` (local dev config) +- The `.gitignore` file ensures `config.local.js` is never accidentally committed +- If you need to modify production URLs, edit `config.js` +- If you need to modify local development URLs, edit `config.local.js` + +## Troubleshooting + +### "Backend is not reachable" in local development + +1. Check that backend is running: `ps aux | grep "python.*run.py"` +2. Verify backend is listening on port 5010: `ss -tulpn | grep 5010` +3. Check `config.local.js` has correct URLs +4. Clear browser cache and hard reload (Ctrl+Shift+R or Cmd+Shift+R) + +### Changes to config not taking effect + +1. Hard reload the browser (Ctrl+Shift+R or Cmd+Shift+R) +2. Check browser console for config loading messages +3. Verify the correct config file is being loaded + +### CORS errors in browser console + +This means the frontend and backend URLs don't match. Check: +1. `config.local.js` (or `config.js`) has correct backend URL +2. Backend CORS settings in `backend/app.py` include your frontend URL diff --git a/frontend/package-lock.json b/frontend/package-lock.json index 0843fdc..3b14fe2 100644 --- a/frontend/package-lock.json +++ b/frontend/package-lock.json @@ -32,19 +32,6 @@ "url": "https://github.com/sponsors/sindresorhus" } }, - "node_modules/@ampproject/remapping": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz", - "integrity": "sha512-30iZtAPgz+LTIYoeivqYo853f02jBYSd5uGnGpkFV0M3xOt9aN73erkgYAmZU43x4VfqcnLxW9Kpg3R5LC4YYw==", - "license": "Apache-2.0", - "dependencies": { - "@jridgewell/gen-mapping": "^0.3.5", - "@jridgewell/trace-mapping": "^0.3.24" - }, - "engines": { - "node": ">=6.0.0" - } - }, "node_modules/@antfu/install-pkg": { "version": "1.1.0", "resolved": "https://registry.npmjs.org/@antfu/install-pkg/-/install-pkg-1.1.0.tgz", @@ -59,45 +46,45 @@ } }, "node_modules/@antfu/utils": { - "version": "8.1.1", - "resolved": "https://registry.npmjs.org/@antfu/utils/-/utils-8.1.1.tgz", - "integrity": "sha512-Mex9nXf9vR6AhcXmMrlz/HVgYYZpVGJ6YlPgwl7UnaFpnshXs6EK/oa5Gpf3CzENMjkvEx2tQtntGnb7UtSTOQ==", + "version": "9.3.0", + "resolved": "https://registry.npmjs.org/@antfu/utils/-/utils-9.3.0.tgz", + "integrity": "sha512-9hFT4RauhcUzqOE4f1+frMKLZrgNog5b06I7VmZQV1BkvwvqrbC8EBZf3L1eEL2AKb6rNKjER0sEvJiSP1FXEA==", "license": "MIT", "funding": { "url": "https://github.com/sponsors/antfu" } }, "node_modules/@azure/msal-browser": { - "version": "4.12.0", - "resolved": "https://registry.npmjs.org/@azure/msal-browser/-/msal-browser-4.12.0.tgz", - "integrity": "sha512-WD1lmVWchg7wn1mI7Tr4v7QPyTwK+8Nuyje3jRpOFENLRLEBsdK8VVdTw3C+TypZmYn4cOAdj3zREnuFXgvfIA==", + "version": "4.25.0", + "resolved": "https://registry.npmjs.org/@azure/msal-browser/-/msal-browser-4.25.0.tgz", + "integrity": "sha512-kbL+Ae7/UC62wSzxirZddYeVnHvvkvAnSZkBqL55X+jaSXTAXfngnNsDM5acEWU0Q/SAv3gEQfxO1igWOn87Pg==", "license": "MIT", "dependencies": { - "@azure/msal-common": "15.6.0" + "@azure/msal-common": "15.13.0" }, "engines": { "node": ">=0.8.0" } }, "node_modules/@azure/msal-common": { - "version": "15.6.0", - "resolved": "https://registry.npmjs.org/@azure/msal-common/-/msal-common-15.6.0.tgz", - "integrity": "sha512-EotmBz42apYGjqiIV9rDUdptaMptpTn4TdGf3JfjLvFvinSe9BJ6ywU92K9ky+t/b0ghbeTSe9RfqlgLh8f2jA==", + "version": "15.13.0", + "resolved": "https://registry.npmjs.org/@azure/msal-common/-/msal-common-15.13.0.tgz", + "integrity": "sha512-8oF6nj02qX7eE/6+wFT5NluXRHc05AgdCC3fJnkjiJooq8u7BcLmxaYYSwc2AfEkWRMRi6Eyvvbeqk4U4412Ag==", "license": "MIT", "engines": { "node": ">=0.8.0" } }, "node_modules/@azure/msal-react": { - "version": "3.0.12", - "resolved": "https://registry.npmjs.org/@azure/msal-react/-/msal-react-3.0.12.tgz", - "integrity": "sha512-Rnw1hcx/ILYmbhcPZbhQNdBpf0jE3P0nMiwLKRMqgjnACqOiHQ5+ZZzEIXwEPiva9TPSrW34yvNBTLx8k/5pVg==", + "version": "3.0.20", + "resolved": "https://registry.npmjs.org/@azure/msal-react/-/msal-react-3.0.20.tgz", + "integrity": "sha512-+mlGe5rzJDe1Feb0BcPwCkcRTIXAUX0mxBnP8hDuzIXrwBAT/iHHl6wcsZ5iKBnMuqOicJhGX5l2/Iwqguom0Q==", "license": "MIT", "engines": { "node": ">=10" }, "peerDependencies": { - "@azure/msal-browser": "^4.12.0", + "@azure/msal-browser": "^4.24.0", "react": "^16.8.0 || ^17 || ^18 || ^19" } }, @@ -116,30 +103,30 @@ } }, "node_modules/@babel/compat-data": { - "version": "7.27.2", - "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.27.2.tgz", - "integrity": "sha512-TUtMJYRPyUb/9aU8f3K0mjmjf6M9N5Woshn2CS6nqJSeJtTtQcpLUXjGt9vbF8ZGff0El99sWkLgzwW3VXnxZQ==", + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.28.4.tgz", + "integrity": "sha512-YsmSKC29MJwf0gF8Rjjrg5LQCmyh+j/nD8/eP7f+BeoQTKYqs9RoWbjGOdy0+1Ekr68RJZMUOPVQaQisnIo4Rw==", "license": "MIT", "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/core": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.27.1.tgz", - "integrity": "sha512-IaaGWsQqfsQWVLqMn9OB92MNN7zukfVA4s7KKAI0KfrrDsZ0yhi5uV4baBuLuN7n3vsZpwP8asPPcVwApxvjBQ==", + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.4.tgz", + "integrity": "sha512-2BCOP7TN8M+gVDj7/ht3hsaO/B/n5oDbiAyyvnRlNOs+u1o+JWNYTQrmpuNp1/Wq2gcFrI01JAW+paEKDMx/CA==", "license": "MIT", "dependencies": { - "@ampproject/remapping": "^2.2.0", "@babel/code-frame": "^7.27.1", - "@babel/generator": "^7.27.1", - "@babel/helper-compilation-targets": "^7.27.1", - "@babel/helper-module-transforms": "^7.27.1", - "@babel/helpers": "^7.27.1", - "@babel/parser": "^7.27.1", - "@babel/template": "^7.27.1", - "@babel/traverse": "^7.27.1", - "@babel/types": "^7.27.1", + "@babel/generator": "^7.28.3", + "@babel/helper-compilation-targets": "^7.27.2", + "@babel/helper-module-transforms": "^7.28.3", + "@babel/helpers": "^7.28.4", + "@babel/parser": "^7.28.4", + "@babel/template": "^7.27.2", + "@babel/traverse": "^7.28.4", + "@babel/types": "^7.28.4", + "@jridgewell/remapping": "^2.3.5", "convert-source-map": "^2.0.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", @@ -164,9 +151,9 @@ } }, "node_modules/@babel/eslint-parser": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/eslint-parser/-/eslint-parser-7.27.1.tgz", - "integrity": "sha512-q8rjOuadH0V6Zo4XLMkJ3RMQ9MSBqwaDByyYB0izsYdaIWGNLmEblbCOf1vyFHICcg16CD7Fsi51vcQnYxmt6Q==", + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/eslint-parser/-/eslint-parser-7.28.4.tgz", + "integrity": "sha512-Aa+yDiH87980jR6zvRfFuCR1+dLb00vBydhTL+zI992Rz/wQhSvuxjmOOuJOgO3XmakO6RykRGD2S1mq1AtgHA==", "license": "MIT", "dependencies": { "@nicolo-ribaudo/eslint-scope-5-internals": "5.1.1-v1", @@ -200,15 +187,15 @@ } }, "node_modules/@babel/generator": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.27.1.tgz", - "integrity": "sha512-UnJfnIpc/+JO0/+KRVQNGU+y5taA5vCbwN8+azkX6beii/ZF+enZJSOKo11ZSzGJjlNfJHfQtmQT8H+9TXPG2w==", + "version": "7.28.3", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.3.tgz", + "integrity": "sha512-3lSpxGgvnmZznmBkCRnVREPUFJv2wrv9iAoFDvADJc0ypmdOxdUtcLeBgBJ6zE0PMeTKnxeQzyk0xTBq4Ep7zw==", "license": "MIT", "dependencies": { - "@babel/parser": "^7.27.1", - "@babel/types": "^7.27.1", - "@jridgewell/gen-mapping": "^0.3.5", - "@jridgewell/trace-mapping": "^0.3.25", + "@babel/parser": "^7.28.3", + "@babel/types": "^7.28.2", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", "jsesc": "^3.0.2" }, "engines": { @@ -216,12 +203,12 @@ } }, "node_modules/@babel/helper-annotate-as-pure": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.27.1.tgz", - "integrity": "sha512-WnuuDILl9oOBbKnb4L+DyODx7iC47XfzmNCpTttFsSp6hTG7XZxu60+4IO+2/hPfcGOoKbFiwoI/+zwARbNQow==", + "version": "7.27.3", + "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.27.3.tgz", + "integrity": "sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg==", "license": "MIT", "dependencies": { - "@babel/types": "^7.27.1" + "@babel/types": "^7.27.3" }, "engines": { "node": ">=6.9.0" @@ -253,17 +240,17 @@ } }, "node_modules/@babel/helper-create-class-features-plugin": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.27.1.tgz", - "integrity": "sha512-QwGAmuvM17btKU5VqXfb+Giw4JcN0hjuufz3DYnpeVDvZLAObloM77bhMXiqry3Iio+Ai4phVRDwl6WU10+r5A==", + "version": "7.28.3", + "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.28.3.tgz", + "integrity": "sha512-V9f6ZFIYSLNEbuGA/92uOvYsGCJNsuA8ESZ4ldc09bWk/j8H8TKiPw8Mk1eG6olpnO0ALHJmYfZvF4MEE4gajg==", "license": "MIT", "dependencies": { - "@babel/helper-annotate-as-pure": "^7.27.1", + "@babel/helper-annotate-as-pure": "^7.27.3", "@babel/helper-member-expression-to-functions": "^7.27.1", "@babel/helper-optimise-call-expression": "^7.27.1", "@babel/helper-replace-supers": "^7.27.1", "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1", - "@babel/traverse": "^7.27.1", + "@babel/traverse": "^7.28.3", "semver": "^6.3.1" }, "engines": { @@ -309,21 +296,30 @@ } }, "node_modules/@babel/helper-define-polyfill-provider": { - "version": "0.6.4", - "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.4.tgz", - "integrity": "sha512-jljfR1rGnXXNWnmQg2K3+bvhkxB51Rl32QRaOTuwwjviGrHzIbSc8+x9CpraDtbT7mfyjXObULP4w/adunNwAw==", + "version": "0.6.5", + "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.6.5.tgz", + "integrity": "sha512-uJnGFcPsWQK8fvjgGP5LZUZZsYGIoPeRjSF5PGwrelYgq7Q15/Ft9NGFp1zglwgIv//W0uG4BevRuSJRyylZPg==", "license": "MIT", "dependencies": { - "@babel/helper-compilation-targets": "^7.22.6", - "@babel/helper-plugin-utils": "^7.22.5", - "debug": "^4.1.1", + "@babel/helper-compilation-targets": "^7.27.2", + "@babel/helper-plugin-utils": "^7.27.1", + "debug": "^4.4.1", "lodash.debounce": "^4.0.8", - "resolve": "^1.14.2" + "resolve": "^1.22.10" }, "peerDependencies": { "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" } }, + "node_modules/@babel/helper-globals": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz", + "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, "node_modules/@babel/helper-member-expression-to-functions": { "version": "7.27.1", "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.27.1.tgz", @@ -351,14 +347,14 @@ } }, "node_modules/@babel/helper-module-transforms": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.27.1.tgz", - "integrity": "sha512-9yHn519/8KvTU5BjTVEEeIM3w9/2yXNKoD82JifINImhpKkARMJKPP59kLo+BafpdN5zgNeIcS4jsGDmd3l58g==", + "version": "7.28.3", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.3.tgz", + "integrity": "sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw==", "license": "MIT", "dependencies": { "@babel/helper-module-imports": "^7.27.1", "@babel/helper-validator-identifier": "^7.27.1", - "@babel/traverse": "^7.27.1" + "@babel/traverse": "^7.28.3" }, "engines": { "node": ">=6.9.0" @@ -463,39 +459,39 @@ } }, "node_modules/@babel/helper-wrap-function": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.27.1.tgz", - "integrity": "sha512-NFJK2sHUvrjo8wAU/nQTWU890/zB2jj0qBcCbZbbf+005cAsv6tMjXz31fBign6M5ov1o0Bllu+9nbqkfsjjJQ==", + "version": "7.28.3", + "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.28.3.tgz", + "integrity": "sha512-zdf983tNfLZFletc0RRXYrHrucBEg95NIFMkn6K9dbeMYnsgHaSBGcQqdsCSStG2PYwRre0Qc2NNSCXbG+xc6g==", "license": "MIT", "dependencies": { - "@babel/template": "^7.27.1", - "@babel/traverse": "^7.27.1", - "@babel/types": "^7.27.1" + "@babel/template": "^7.27.2", + "@babel/traverse": "^7.28.3", + "@babel/types": "^7.28.2" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/helpers": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.27.1.tgz", - "integrity": "sha512-FCvFTm0sWV8Fxhpp2McP5/W53GPllQ9QeQ7SiqGWjMf/LVG07lFa5+pgK05IRhVwtvafT22KF+ZSnM9I545CvQ==", + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.4.tgz", + "integrity": "sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w==", "license": "MIT", "dependencies": { - "@babel/template": "^7.27.1", - "@babel/types": "^7.27.1" + "@babel/template": "^7.27.2", + "@babel/types": "^7.28.4" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/parser": { - "version": "7.27.2", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.27.2.tgz", - "integrity": "sha512-QYLs8299NA7WM/bZAdp+CviYYkVoYXlDW2rzliy3chxd1PQjej7JORuMJDJXJUb9g0TT+B99EwaVLKmX+sPXWw==", + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.4.tgz", + "integrity": "sha512-yZbBqeM6TkpP9du/I2pUZnJsRMGGvOuIrhjzC1AwHwW+6he4mni6Bp/m8ijn0iOuZuPI2BfkCoSRunpyjnrQKg==", "license": "MIT", "dependencies": { - "@babel/types": "^7.27.1" + "@babel/types": "^7.28.4" }, "bin": { "parser": "bin/babel-parser.js" @@ -568,13 +564,13 @@ } }, "node_modules/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.27.1.tgz", - "integrity": "sha512-6BpaYGDavZqkI6yT+KSPdpZFfpnd68UKXbcjI9pJ13pvHhPrCKWOOLp+ysvMeA+DxnhuPpgIaRpxRxo5A9t5jw==", + "version": "7.28.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly/-/plugin-bugfix-v8-static-class-fields-redefine-readonly-7.28.3.tgz", + "integrity": "sha512-b6YTX108evsvE4YgWyQ921ZAFFQm3Bn+CA3+ZXlNVnPhx+UfsVURoPjfGAPCjBgrqo30yX/C2nZGX96DxvR9Iw==", "license": "MIT", "dependencies": { "@babel/helper-plugin-utils": "^7.27.1", - "@babel/traverse": "^7.27.1" + "@babel/traverse": "^7.28.3" }, "engines": { "node": ">=6.9.0" @@ -601,9 +597,9 @@ } }, "node_modules/@babel/plugin-proposal-decorators": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-decorators/-/plugin-proposal-decorators-7.27.1.tgz", - "integrity": "sha512-DTxe4LBPrtFdsWzgpmbBKevg3e9PBy+dXRt19kSbucbZvL2uqtdqwwpluL1jfxYE0wIDTFp1nTy/q6gNLsxXrg==", + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-decorators/-/plugin-proposal-decorators-7.28.0.tgz", + "integrity": "sha512-zOiZqvANjWDUaUS9xMxbMcK/Zccztbe/6ikvUXaG9nsPH3w6qh5UaPGAnirI/WhIbZ8m3OHU0ReyPrknG+ZKeg==", "license": "MIT", "dependencies": { "@babel/helper-create-class-features-plugin": "^7.27.1", @@ -997,14 +993,14 @@ } }, "node_modules/@babel/plugin-transform-async-generator-functions": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.27.1.tgz", - "integrity": "sha512-eST9RrwlpaoJBDHShc+DS2SG4ATTi2MYNb4OxYkf3n+7eb49LWpnS+HSpVfW4x927qQwgk8A2hGNVaajAEw0EA==", + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-generator-functions/-/plugin-transform-async-generator-functions-7.28.0.tgz", + "integrity": "sha512-BEOdvX4+M765icNPZeidyADIvQ1m1gmunXufXxvRESy/jNNyfovIqUyE7MVgGBjWktCoJlzvFA1To2O4ymIO3Q==", "license": "MIT", "dependencies": { "@babel/helper-plugin-utils": "^7.27.1", "@babel/helper-remap-async-to-generator": "^7.27.1", - "@babel/traverse": "^7.27.1" + "@babel/traverse": "^7.28.0" }, "engines": { "node": ">=6.9.0" @@ -1046,9 +1042,9 @@ } }, "node_modules/@babel/plugin-transform-block-scoping": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.27.1.tgz", - "integrity": "sha512-QEcFlMl9nGTgh1rn2nIeU5bkfb9BAjaQcWbiP4LvKxUot52ABcTkpcyJ7f2Q2U2RuQ84BNLgts3jRme2dTx6Fw==", + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.28.4.tgz", + "integrity": "sha512-1yxmvN0MJHOhPVmAsmoW5liWwoILobu/d/ShymZmj867bAdxGbehIrew1DuLpw2Ukv+qDSSPQdYW1dLNE7t11A==", "license": "MIT", "dependencies": { "@babel/helper-plugin-utils": "^7.27.1" @@ -1077,12 +1073,12 @@ } }, "node_modules/@babel/plugin-transform-class-static-block": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.27.1.tgz", - "integrity": "sha512-s734HmYU78MVzZ++joYM+NkJusItbdRcbm+AGRgJCt3iA+yux0QpD9cBVdz3tKyrjVYWRl7j0mHSmv4lhV0aoA==", + "version": "7.28.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-static-block/-/plugin-transform-class-static-block-7.28.3.tgz", + "integrity": "sha512-LtPXlBbRoc4Njl/oh1CeD/3jC+atytbnf/UqLoqTDcEYGUPj022+rvfkbDYieUrSj3CaV4yHDByPE+T2HwfsJg==", "license": "MIT", "dependencies": { - "@babel/helper-create-class-features-plugin": "^7.27.1", + "@babel/helper-create-class-features-plugin": "^7.28.3", "@babel/helper-plugin-utils": "^7.27.1" }, "engines": { @@ -1093,17 +1089,17 @@ } }, "node_modules/@babel/plugin-transform-classes": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.27.1.tgz", - "integrity": "sha512-7iLhfFAubmpeJe/Wo2TVuDrykh/zlWXLzPNdL0Jqn/Xu8R3QQ8h9ff8FQoISZOsw74/HFqFI7NX63HN7QFIHKA==", + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.28.4.tgz", + "integrity": "sha512-cFOlhIYPBv/iBoc+KS3M6et2XPtbT2HiCRfBXWtfpc9OAyostldxIf9YAYB6ypURBBbx+Qv6nyrLzASfJe+hBA==", "license": "MIT", "dependencies": { - "@babel/helper-annotate-as-pure": "^7.27.1", - "@babel/helper-compilation-targets": "^7.27.1", + "@babel/helper-annotate-as-pure": "^7.27.3", + "@babel/helper-compilation-targets": "^7.27.2", + "@babel/helper-globals": "^7.28.0", "@babel/helper-plugin-utils": "^7.27.1", "@babel/helper-replace-supers": "^7.27.1", - "@babel/traverse": "^7.27.1", - "globals": "^11.1.0" + "@babel/traverse": "^7.28.4" }, "engines": { "node": ">=6.9.0" @@ -1129,12 +1125,13 @@ } }, "node_modules/@babel/plugin-transform-destructuring": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.27.1.tgz", - "integrity": "sha512-ttDCqhfvpE9emVkXbPD8vyxxh4TWYACVybGkDj+oReOGwnp066ITEivDlLwe0b1R0+evJ13IXQuLNB5w1fhC5Q==", + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.28.0.tgz", + "integrity": "sha512-v1nrSMBiKcodhsyJ4Gf+Z0U/yawmJDBOTpEB3mcQY52r9RIyPneGyAS/yM6seP/8I+mWI3elOMtT5dB8GJVs+A==", "license": "MIT", "dependencies": { - "@babel/helper-plugin-utils": "^7.27.1" + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/traverse": "^7.28.0" }, "engines": { "node": ">=6.9.0" @@ -1205,6 +1202,22 @@ "@babel/core": "^7.0.0-0" } }, + "node_modules/@babel/plugin-transform-explicit-resource-management": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-explicit-resource-management/-/plugin-transform-explicit-resource-management-7.28.0.tgz", + "integrity": "sha512-K8nhUcn3f6iB+P3gwCv/no7OdzOZQcKchW6N389V6PD8NUWKZHzndOd9sPDVbMoBsbmjMqlB4L9fm+fEFNVlwQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/plugin-transform-destructuring": "^7.28.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, "node_modules/@babel/plugin-transform-exponentiation-operator": { "version": "7.27.1", "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.27.1.tgz", @@ -1472,15 +1485,16 @@ } }, "node_modules/@babel/plugin-transform-object-rest-spread": { - "version": "7.27.2", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.27.2.tgz", - "integrity": "sha512-AIUHD7xJ1mCrj3uPozvtngY3s0xpv7Nu7DoUSnzNY6Xam1Cy4rUznR//pvMHOhQ4AvbCexhbqXCtpxGHOGOO6g==", + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.28.4.tgz", + "integrity": "sha512-373KA2HQzKhQCYiRVIRr+3MjpCObqzDlyrM6u4I201wL8Mp2wHf7uB8GhDwis03k2ti8Zr65Zyyqs1xOxUF/Ew==", "license": "MIT", "dependencies": { "@babel/helper-compilation-targets": "^7.27.2", "@babel/helper-plugin-utils": "^7.27.1", - "@babel/plugin-transform-destructuring": "^7.27.1", - "@babel/plugin-transform-parameters": "^7.27.1" + "@babel/plugin-transform-destructuring": "^7.28.0", + "@babel/plugin-transform-parameters": "^7.27.7", + "@babel/traverse": "^7.28.4" }, "engines": { "node": ">=6.9.0" @@ -1537,9 +1551,9 @@ } }, "node_modules/@babel/plugin-transform-parameters": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.27.1.tgz", - "integrity": "sha512-018KRk76HWKeZ5l4oTj2zPpSh+NbGdt0st5S6x0pga6HgrjBOJb24mMDHorFopOOd6YHkLgOZ+zaCjZGPO4aKg==", + "version": "7.27.7", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.27.7.tgz", + "integrity": "sha512-qBkYTYCb76RRxUM6CcZA5KRu8K4SM8ajzVeUgVdMVO9NN9uI/GaVmBg/WKJJGnNokV9SY8FxNOVWGXzqzUidBg==", "license": "MIT", "dependencies": { "@babel/helper-plugin-utils": "^7.27.1" @@ -1615,9 +1629,9 @@ } }, "node_modules/@babel/plugin-transform-react-display-name": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.27.1.tgz", - "integrity": "sha512-p9+Vl3yuHPmkirRrg021XiP+EETmPMQTLr6Ayjj85RLNEbb3Eya/4VI0vAdzQG9SEAl2Lnt7fy5lZyMzjYoZQQ==", + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.28.0.tgz", + "integrity": "sha512-D6Eujc2zMxKjfa4Zxl4GHMsmhKKZ9VpcqIchJLvwTxad9zWIYulwYItBovpDOoNLISpcZSXoDJ5gaGbQUDqViA==", "license": "MIT", "dependencies": { "@babel/helper-plugin-utils": "^7.27.1" @@ -1680,9 +1694,9 @@ } }, "node_modules/@babel/plugin-transform-regenerator": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.27.1.tgz", - "integrity": "sha512-B19lbbL7PMrKr52BNPjCqg1IyNUIjTcxKj8uX9zHO+PmWN93s19NDr/f69mIkEp2x9nmDJ08a7lgHaTTzvW7mw==", + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.28.4.tgz", + "integrity": "sha512-+ZEdQlBoRg9m2NnzvEeLgtvBMO4tkFBw5SQIUgLICgTrumLoU7lr+Oghi6km2PFj+dbUt2u1oby2w3BDO9YQnA==", "license": "MIT", "dependencies": { "@babel/helper-plugin-utils": "^7.27.1" @@ -1726,16 +1740,16 @@ } }, "node_modules/@babel/plugin-transform-runtime": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-runtime/-/plugin-transform-runtime-7.27.1.tgz", - "integrity": "sha512-TqGF3desVsTcp3WrJGj4HfKokfCXCLcHpt4PJF0D8/iT6LPd9RS82Upw3KPeyr6B22Lfd3DO8MVrmp0oRkUDdw==", + "version": "7.28.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-runtime/-/plugin-transform-runtime-7.28.3.tgz", + "integrity": "sha512-Y6ab1kGqZ0u42Zv/4a7l0l72n9DKP/MKoKWaUSBylrhNZO2prYuqFOLbn5aW5SIFXwSH93yfjbgllL8lxuGKLg==", "license": "MIT", "dependencies": { "@babel/helper-module-imports": "^7.27.1", "@babel/helper-plugin-utils": "^7.27.1", - "babel-plugin-polyfill-corejs2": "^0.4.10", - "babel-plugin-polyfill-corejs3": "^0.11.0", - "babel-plugin-polyfill-regenerator": "^0.6.1", + "babel-plugin-polyfill-corejs2": "^0.4.14", + "babel-plugin-polyfill-corejs3": "^0.13.0", + "babel-plugin-polyfill-regenerator": "^0.6.5", "semver": "^6.3.1" }, "engines": { @@ -1831,12 +1845,12 @@ } }, "node_modules/@babel/plugin-transform-typescript": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.27.1.tgz", - "integrity": "sha512-Q5sT5+O4QUebHdbwKedFBEwRLb02zJ7r4A5Gg2hUoLuU3FjdMcyqcywqUrLCaDsFCxzokf7u9kuy7qz51YUuAg==", + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.28.0.tgz", + "integrity": "sha512-4AEiDEBPIZvLQaWlc9liCavE0xRM0dNca41WtBeM3jgFptfUOSG9z0uteLhq6+3rq+WB6jIvUwKDTpXEHPJ2Vg==", "license": "MIT", "dependencies": { - "@babel/helper-annotate-as-pure": "^7.27.1", + "@babel/helper-annotate-as-pure": "^7.27.3", "@babel/helper-create-class-features-plugin": "^7.27.1", "@babel/helper-plugin-utils": "^7.27.1", "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1", @@ -1913,12 +1927,12 @@ } }, "node_modules/@babel/preset-env": { - "version": "7.27.2", - "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.27.2.tgz", - "integrity": "sha512-Ma4zSuYSlGNRlCLO+EAzLnCmJK2vdstgv+n7aUP+/IKZrOfWHOJVdSJtuub8RzHTj3ahD37k5OKJWvzf16TQyQ==", + "version": "7.28.3", + "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.28.3.tgz", + "integrity": "sha512-ROiDcM+GbYVPYBOeCR6uBXKkQpBExLl8k9HO1ygXEyds39j+vCCsjmj7S8GOniZQlEs81QlkdJZe76IpLSiqpg==", "license": "MIT", "dependencies": { - "@babel/compat-data": "^7.27.2", + "@babel/compat-data": "^7.28.0", "@babel/helper-compilation-targets": "^7.27.2", "@babel/helper-plugin-utils": "^7.27.1", "@babel/helper-validator-option": "^7.27.1", @@ -1926,25 +1940,26 @@ "@babel/plugin-bugfix-safari-class-field-initializer-scope": "^7.27.1", "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.27.1", "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.27.1", - "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.27.1", + "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.28.3", "@babel/plugin-proposal-private-property-in-object": "7.21.0-placeholder-for-preset-env.2", "@babel/plugin-syntax-import-assertions": "^7.27.1", "@babel/plugin-syntax-import-attributes": "^7.27.1", "@babel/plugin-syntax-unicode-sets-regex": "^7.18.6", "@babel/plugin-transform-arrow-functions": "^7.27.1", - "@babel/plugin-transform-async-generator-functions": "^7.27.1", + "@babel/plugin-transform-async-generator-functions": "^7.28.0", "@babel/plugin-transform-async-to-generator": "^7.27.1", "@babel/plugin-transform-block-scoped-functions": "^7.27.1", - "@babel/plugin-transform-block-scoping": "^7.27.1", + "@babel/plugin-transform-block-scoping": "^7.28.0", "@babel/plugin-transform-class-properties": "^7.27.1", - "@babel/plugin-transform-class-static-block": "^7.27.1", - "@babel/plugin-transform-classes": "^7.27.1", + "@babel/plugin-transform-class-static-block": "^7.28.3", + "@babel/plugin-transform-classes": "^7.28.3", "@babel/plugin-transform-computed-properties": "^7.27.1", - "@babel/plugin-transform-destructuring": "^7.27.1", + "@babel/plugin-transform-destructuring": "^7.28.0", "@babel/plugin-transform-dotall-regex": "^7.27.1", "@babel/plugin-transform-duplicate-keys": "^7.27.1", "@babel/plugin-transform-duplicate-named-capturing-groups-regex": "^7.27.1", "@babel/plugin-transform-dynamic-import": "^7.27.1", + "@babel/plugin-transform-explicit-resource-management": "^7.28.0", "@babel/plugin-transform-exponentiation-operator": "^7.27.1", "@babel/plugin-transform-export-namespace-from": "^7.27.1", "@babel/plugin-transform-for-of": "^7.27.1", @@ -1961,15 +1976,15 @@ "@babel/plugin-transform-new-target": "^7.27.1", "@babel/plugin-transform-nullish-coalescing-operator": "^7.27.1", "@babel/plugin-transform-numeric-separator": "^7.27.1", - "@babel/plugin-transform-object-rest-spread": "^7.27.2", + "@babel/plugin-transform-object-rest-spread": "^7.28.0", "@babel/plugin-transform-object-super": "^7.27.1", "@babel/plugin-transform-optional-catch-binding": "^7.27.1", "@babel/plugin-transform-optional-chaining": "^7.27.1", - "@babel/plugin-transform-parameters": "^7.27.1", + "@babel/plugin-transform-parameters": "^7.27.7", "@babel/plugin-transform-private-methods": "^7.27.1", "@babel/plugin-transform-private-property-in-object": "^7.27.1", "@babel/plugin-transform-property-literals": "^7.27.1", - "@babel/plugin-transform-regenerator": "^7.27.1", + "@babel/plugin-transform-regenerator": "^7.28.3", "@babel/plugin-transform-regexp-modifiers": "^7.27.1", "@babel/plugin-transform-reserved-words": "^7.27.1", "@babel/plugin-transform-shorthand-properties": "^7.27.1", @@ -1982,10 +1997,10 @@ "@babel/plugin-transform-unicode-regex": "^7.27.1", "@babel/plugin-transform-unicode-sets-regex": "^7.27.1", "@babel/preset-modules": "0.1.6-no-external-plugins", - "babel-plugin-polyfill-corejs2": "^0.4.10", - "babel-plugin-polyfill-corejs3": "^0.11.0", - "babel-plugin-polyfill-regenerator": "^0.6.1", - "core-js-compat": "^3.40.0", + "babel-plugin-polyfill-corejs2": "^0.4.14", + "babel-plugin-polyfill-corejs3": "^0.13.0", + "babel-plugin-polyfill-regenerator": "^0.6.5", + "core-js-compat": "^3.43.0", "semver": "^6.3.1" }, "engines": { @@ -2058,9 +2073,9 @@ } }, "node_modules/@babel/runtime": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.27.1.tgz", - "integrity": "sha512-1x3D2xEk2fRo3PAhwQwu5UubzgiVWSXTBfWpVd2Mx2AzRqJuDJCsgaDVZ7HB5iGzDW1Hl1sWN2mFyKjmR9uAog==", + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.28.4.tgz", + "integrity": "sha512-Q/N6JNWvIvPnLDvjlE1OUBLPQHH6l3CltCEsHIujp45zQUSSh8K+gHnaEX45yAT1nyngnINhvWtzN+Nb9D8RAQ==", "license": "MIT", "engines": { "node": ">=6.9.0" @@ -2081,27 +2096,27 @@ } }, "node_modules/@babel/traverse": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.27.1.tgz", - "integrity": "sha512-ZCYtZciz1IWJB4U61UPu4KEaqyfj+r5T1Q5mqPo+IBpcG9kHv30Z0aD8LXPgC1trYa6rK0orRyAhqUgk4MjmEg==", + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.4.tgz", + "integrity": "sha512-YEzuboP2qvQavAcjgQNVgsvHIDv6ZpwXvcvjmyySP2DIMuByS/6ioU5G9pYrWHM6T2YDfc7xga9iNzYOs12CFQ==", "license": "MIT", "dependencies": { "@babel/code-frame": "^7.27.1", - "@babel/generator": "^7.27.1", - "@babel/parser": "^7.27.1", - "@babel/template": "^7.27.1", - "@babel/types": "^7.27.1", - "debug": "^4.3.1", - "globals": "^11.1.0" + "@babel/generator": "^7.28.3", + "@babel/helper-globals": "^7.28.0", + "@babel/parser": "^7.28.4", + "@babel/template": "^7.27.2", + "@babel/types": "^7.28.4", + "debug": "^4.3.1" }, "engines": { "node": ">=6.9.0" } }, "node_modules/@babel/types": { - "version": "7.27.1", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.27.1.tgz", - "integrity": "sha512-+EzkxvLNfiUeKMgy/3luqfsCWFRXLb7U6wNQTk60tovuckwB15B191tJWvpp4HjiQWdJkCxO3Wbvc6jlk3Xb2Q==", + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.4.tgz", + "integrity": "sha512-bkFqkLhh3pMBUQQkpVgWDWq/lqzc2678eUyDlTBhRqhCHFguYYGM0Efga7tYk4TogG/3x0EEl66/OQ+WGbWB/Q==", "license": "MIT", "dependencies": { "@babel/helper-string-parser": "^7.27.1", @@ -2449,9 +2464,9 @@ } }, "node_modules/@eslint-community/eslint-utils": { - "version": "4.7.0", - "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.7.0.tgz", - "integrity": "sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw==", + "version": "4.9.0", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.0.tgz", + "integrity": "sha512-ayVFHdtZ+hsq1t2Dy24wCmGXGe4q9Gu3smhLYALJrr473ZH27MsnSL+LKUlimp4BWJqMDMLmPpx/Q9R3OAlL4g==", "license": "MIT", "dependencies": { "eslint-visitor-keys": "^3.4.3" @@ -2594,33 +2609,21 @@ "license": "MIT" }, "node_modules/@iconify/utils": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/@iconify/utils/-/utils-2.3.0.tgz", - "integrity": "sha512-GmQ78prtwYW6EtzXRU1rY+KwOKfz32PD7iJh6Iyqw68GiKuoZ2A6pRtzWONz5VQJbp50mEjXh/7NkumtrAgRKA==", + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@iconify/utils/-/utils-3.0.2.tgz", + "integrity": "sha512-EfJS0rLfVuRuJRn4psJHtK2A9TqVnkxPpHY6lYHiB9+8eSuudsxbwMiavocG45ujOo6FJ+CIRlRnlOGinzkaGQ==", "license": "MIT", "dependencies": { - "@antfu/install-pkg": "^1.0.0", - "@antfu/utils": "^8.1.0", + "@antfu/install-pkg": "^1.1.0", + "@antfu/utils": "^9.2.0", "@iconify/types": "^2.0.0", - "debug": "^4.4.0", - "globals": "^15.14.0", + "debug": "^4.4.1", + "globals": "^15.15.0", "kolorist": "^1.8.0", - "local-pkg": "^1.0.0", + "local-pkg": "^1.1.1", "mlly": "^1.7.4" } }, - "node_modules/@iconify/utils/node_modules/globals": { - "version": "15.15.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-15.15.0.tgz", - "integrity": "sha512-7ACyT3wmyp3I61S4fG682L0VA2RGD9otkqGJIwNUMF1SWUombIIk+af1unuDYgMm082aHYwD+mzJvv9Iu8dsgg==", - "license": "MIT", - "engines": { - "node": ">=18" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/@isaacs/cliui": { "version": "8.0.2", "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz", @@ -2639,9 +2642,9 @@ } }, "node_modules/@isaacs/cliui/node_modules/ansi-regex": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz", - "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==", + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz", + "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==", "license": "MIT", "engines": { "node": ">=12" @@ -2651,9 +2654,9 @@ } }, "node_modules/@isaacs/cliui/node_modules/ansi-styles": { - "version": "6.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", - "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", + "version": "6.2.3", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz", + "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==", "license": "MIT", "engines": { "node": ">=12" @@ -2680,9 +2683,9 @@ } }, "node_modules/@isaacs/cliui/node_modules/strip-ansi": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", - "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.2.tgz", + "integrity": "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==", "license": "MIT", "dependencies": { "ansi-regex": "^6.0.1" @@ -3031,17 +3034,23 @@ } }, "node_modules/@jridgewell/gen-mapping": { - "version": "0.3.8", - "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.8.tgz", - "integrity": "sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==", + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", "license": "MIT", "dependencies": { - "@jridgewell/set-array": "^1.2.1", - "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/remapping": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.24" - }, - "engines": { - "node": ">=6.0.0" } }, "node_modules/@jridgewell/resolve-uri": { @@ -3053,19 +3062,10 @@ "node": ">=6.0.0" } }, - "node_modules/@jridgewell/set-array": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/@jridgewell/set-array/-/set-array-1.2.1.tgz", - "integrity": "sha512-R8gLRTZeyp03ymzP/6Lil/28tGeGEzhx1q2k703KGWRAI1VdvPIXdG70VJc2pAMw3NA6JKL5hhFu1sJX0Mnn/A==", - "license": "MIT", - "engines": { - "node": ">=6.0.0" - } - }, "node_modules/@jridgewell/source-map": { - "version": "0.3.6", - "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.6.tgz", - "integrity": "sha512-1ZJTZebgqllO79ue2bm3rIGud/bOe0pP5BjSRCRxxYkEZS8STV7zN84UBbiYu7jy+eCKSnVIUgoWWE/tt+shMQ==", + "version": "0.3.11", + "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.11.tgz", + "integrity": "sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==", "license": "MIT", "dependencies": { "@jridgewell/gen-mapping": "^0.3.5", @@ -3073,15 +3073,15 @@ } }, "node_modules/@jridgewell/sourcemap-codec": { - "version": "1.5.0", - "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz", - "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==", + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", "license": "MIT" }, "node_modules/@jridgewell/trace-mapping": { - "version": "0.3.25", - "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.25.tgz", - "integrity": "sha512-vNk6aEwybGtawWmy/PzwnGDOjCkLWSD2wqvjGGAgOAwCGWySYXfYoxt00IJkTF+8Lb57DwOb3Aa0o9CApepiYQ==", + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", "license": "MIT", "dependencies": { "@jridgewell/resolve-uri": "^3.1.0", @@ -3095,9 +3095,9 @@ "license": "MIT" }, "node_modules/@mermaid-js/parser": { - "version": "0.4.0", - "resolved": "https://registry.npmjs.org/@mermaid-js/parser/-/parser-0.4.0.tgz", - "integrity": "sha512-wla8XOWvQAwuqy+gxiZqY+c7FokraOTHRWMsbB4AgRx9Sy7zKslNyejy7E+a77qHfey5GXw/ik3IXv/NHMJgaA==", + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/@mermaid-js/parser/-/parser-0.6.3.tgz", + "integrity": "sha512-lnjOhe7zyHjc+If7yT4zoedx2vo4sHaTmtkl1+or8BRTnCtDmcTpAjpzDSfCZrshM5bCoz0GyidzadJAH1xobA==", "license": "MIT", "dependencies": { "langium": "3.3.1" @@ -3180,9 +3180,9 @@ } }, "node_modules/@pmmmwh/react-refresh-webpack-plugin": { - "version": "0.5.16", - "resolved": "https://registry.npmjs.org/@pmmmwh/react-refresh-webpack-plugin/-/react-refresh-webpack-plugin-0.5.16.tgz", - "integrity": "sha512-kLQc9xz6QIqd2oIYyXRUiAp79kGpFBm3fEM9ahfG1HI0WI5gdZ2OVHWdmZYnwODt7ISck+QuQ6sBPrtvUBML7Q==", + "version": "0.5.17", + "resolved": "https://registry.npmjs.org/@pmmmwh/react-refresh-webpack-plugin/-/react-refresh-webpack-plugin-0.5.17.tgz", + "integrity": "sha512-tXDyE1/jzFsHXjhRZQ3hMl0IVhYe5qula43LDWIhVfjp9G/nT5OQY5AORVOrkEGAUltBJOfOWeETbmhm6kHhuQ==", "license": "MIT", "dependencies": { "ansi-html": "^0.0.9", @@ -3324,9 +3324,9 @@ "license": "MIT" }, "node_modules/@rushstack/eslint-patch": { - "version": "1.11.0", - "resolved": "https://registry.npmjs.org/@rushstack/eslint-patch/-/eslint-patch-1.11.0.tgz", - "integrity": "sha512-zxnHvoMQVqewTJr/W4pKjF0bMGiKJv1WX7bSrkl46Hg0QjESbzBROWK0Wg4RphzSOS5Jiy7eFimmM3UgMrMZbQ==", + "version": "1.14.0", + "resolved": "https://registry.npmjs.org/@rushstack/eslint-patch/-/eslint-patch-1.14.0.tgz", + "integrity": "sha512-WJFej426qe4RWOm9MMtP4V3CV4AucXolQty+GRgAWLgQXmpCuwzs7hEpxxhSc/znXUSxum9d/P/32MW0FlAAlA==", "license": "MIT" }, "node_modules/@sinclair/typebox": { @@ -3637,18 +3637,18 @@ } }, "node_modules/@types/babel__traverse": { - "version": "7.20.7", - "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.20.7.tgz", - "integrity": "sha512-dkO5fhS7+/oos4ciWxyEyjWe48zmG6wbCheo/G2ZnHx4fs3EU6YC6UM8rk56gAjNJ9P3MTH2jo5jb92/K6wbng==", + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz", + "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==", "license": "MIT", "dependencies": { - "@babel/types": "^7.20.7" + "@babel/types": "^7.28.2" } }, "node_modules/@types/body-parser": { - "version": "1.19.5", - "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.5.tgz", - "integrity": "sha512-fB3Zu92ucau0iQ0JMCFQE7b/dv8Ot07NI3KaZIkIUNXq82k4eBAqUaneXfleGY9JWskeS9y+u0nXMyspcuQrCg==", + "version": "1.19.6", + "resolved": "https://registry.npmjs.org/@types/body-parser/-/body-parser-1.19.6.tgz", + "integrity": "sha512-HLFeCYgz89uk22N5Qg3dvGvsv46B8GLvKKo1zKG4NybA8U2DiEO3w9lqGg29t/tfLRJpJ6iQxnVw4OnB7MoM9g==", "license": "MIT", "dependencies": { "@types/connect": "*", @@ -3722,9 +3722,9 @@ } }, "node_modules/@types/d3-array": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-3.2.1.tgz", - "integrity": "sha512-Y2Jn2idRrLzUfAKV2LyRImR+y4oa2AntrgID95SHJxuMUrkNXmanDSed71sRNZysveJVt1hLLemQZIady0FpEg==", + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-3.2.2.tgz", + "integrity": "sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw==", "license": "MIT" }, "node_modules/@types/d3-axis": { @@ -3774,9 +3774,9 @@ "license": "MIT" }, "node_modules/@types/d3-dispatch": { - "version": "3.0.6", - "resolved": "https://registry.npmjs.org/@types/d3-dispatch/-/d3-dispatch-3.0.6.tgz", - "integrity": "sha512-4fvZhzMeeuBJYZXRXrRIQnvUYfyXwYmLsdiN7XXmVNQKKw1cM8a5WdID0g1hVFZDqT9ZqZEY5pD44p24VS7iZQ==", + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-dispatch/-/d3-dispatch-3.0.7.tgz", + "integrity": "sha512-5o9OIAdKkhN1QItV2oqaE5KMIiXAvDWBDPrD85e58Qlz1c1kI/J0NcqbEG88CoTwJrYe7ntUCVfeUl2UJKbWgA==", "license": "MIT" }, "node_modules/@types/d3-drag": { @@ -3957,15 +3957,15 @@ } }, "node_modules/@types/estree": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.7.tgz", - "integrity": "sha512-w28IoSUCJpidD/TGviZwwMJckNESJZXFu7NBZ5YJ4mEUnNraUn9Pm8HSZm/jDF1pDWYKspWE7oVphigUPRakIQ==", + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", "license": "MIT" }, "node_modules/@types/express": { - "version": "4.17.21", - "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.21.tgz", - "integrity": "sha512-ejlPM315qwLpaQlQDTjPdsUFSc6ZsP4AN6AlWnogPjQ7CVi7PYF3YVz+CY3jE2pwYf7E/7HlDAN0rV2GxTG0HQ==", + "version": "4.17.23", + "resolved": "https://registry.npmjs.org/@types/express/-/express-4.17.23.tgz", + "integrity": "sha512-Crp6WY9aTYP3qPi2wGDo9iUe/rceX01UMhnF1jmwDcKCFM6cx7YhGP/Mpr3y9AASpfHixIG0E6azCcL5OcDHsQ==", "license": "MIT", "dependencies": { "@types/body-parser": "*", @@ -3975,9 +3975,9 @@ } }, "node_modules/@types/express-serve-static-core": { - "version": "5.0.6", - "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-5.0.6.tgz", - "integrity": "sha512-3xhRnjJPkULekpSzgtoNYYcTWgEZkp4myc+Saevii5JPnHNvHMRlBSHDbs7Bh1iPPoVTERHEZXyhyLbMEsExsA==", + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-5.1.0.tgz", + "integrity": "sha512-jnHMsrd0Mwa9Cf4IdOzbz543y4XJepXrbia2T4b6+spXC2We3t1y6K44D3mR8XMFSXMCf3/l7rCgddfx7UNVBA==", "license": "MIT", "dependencies": { "@types/node": "*", @@ -3987,9 +3987,9 @@ } }, "node_modules/@types/express/node_modules/@types/express-serve-static-core": { - "version": "4.19.6", - "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.19.6.tgz", - "integrity": "sha512-N4LZ2xG7DatVqhCZzOGb1Yi5lMbXSZcmdLDe9EzSndPV2HpWYWzRbaerl2n27irrm94EPpprqa8KpskPT085+A==", + "version": "4.19.7", + "resolved": "https://registry.npmjs.org/@types/express-serve-static-core/-/express-serve-static-core-4.19.7.tgz", + "integrity": "sha512-FvPtiIf1LfhzsaIXhv/PHan/2FeQBbtBDtfX2QfvPxdUelMDEckK08SM6nqo1MIZY3RUlfA+HV8+hFUSio78qg==", "license": "MIT", "dependencies": { "@types/node": "*", @@ -4020,9 +4020,9 @@ "license": "MIT" }, "node_modules/@types/http-errors": { - "version": "2.0.4", - "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.4.tgz", - "integrity": "sha512-D0CFMMtydbJAegzOyHjtiKPLlvnm3iTZyZRSZoLq2mRhDdmLfIWOCYPfQJ4cu2erKghU++QvjcUjp/5h7hESpA==", + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@types/http-errors/-/http-errors-2.0.5.tgz", + "integrity": "sha512-r8Tayk8HJnX0FztbZN7oVqGccWgw98T/0neJphO91KkmOzug1KkofZURD4UaD5uH8AqcFLfdPErnBod0u71/qg==", "license": "MIT" }, "node_modules/@types/http-proxy": { @@ -4077,18 +4077,18 @@ "license": "MIT" }, "node_modules/@types/node": { - "version": "22.15.17", - "resolved": "https://registry.npmjs.org/@types/node/-/node-22.15.17.tgz", - "integrity": "sha512-wIX2aSZL5FE+MR0JlvF87BNVrtFWf6AE6rxSE9X7OwnVvoyCQjpzSRJ+M87se/4QCkCiebQAqrJ0y6fwIyi7nw==", + "version": "24.7.2", + "resolved": "https://registry.npmjs.org/@types/node/-/node-24.7.2.tgz", + "integrity": "sha512-/NbVmcGTP+lj5oa4yiYxxeBjRivKQ5Ns1eSZeB99ExsEQ6rX5XYU1Zy/gGxY/ilqtD4Etx9mKyrPxZRetiahhA==", "license": "MIT", "dependencies": { - "undici-types": "~6.21.0" + "undici-types": "~7.14.0" } }, "node_modules/@types/node-forge": { - "version": "1.3.11", - "resolved": "https://registry.npmjs.org/@types/node-forge/-/node-forge-1.3.11.tgz", - "integrity": "sha512-FQx220y22OKNTqaByeBGqHWYz4cl94tpcxeFdvBo3wjG6XPBuZ0BNgNZRV5J5TFmmcsJ4IzsLkmGRiQbnYsBEQ==", + "version": "1.3.14", + "resolved": "https://registry.npmjs.org/@types/node-forge/-/node-forge-1.3.14.tgz", + "integrity": "sha512-mhVF2BnD4BO+jtOp7z1CdzaK4mbuK0LLQYAvdOLqHTavxFNq4zA1EmYkpnFjP8HOUzedfQkRnp0E2ulSAYSzAw==", "license": "MIT", "dependencies": { "@types/node": "*" @@ -4113,9 +4113,9 @@ "license": "MIT" }, "node_modules/@types/qs": { - "version": "6.9.18", - "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.18.tgz", - "integrity": "sha512-kK7dgTYDyGqS+e2Q4aK9X3D7q234CIZ1Bv0q/7Z5IwRDoADNU81xXJK/YVyLbLTZCoIwUoDoffFeF+p/eIklAA==", + "version": "6.14.0", + "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.14.0.tgz", + "integrity": "sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==", "license": "MIT" }, "node_modules/@types/range-parser": { @@ -4140,18 +4140,17 @@ "license": "MIT" }, "node_modules/@types/semver": { - "version": "7.7.0", - "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.7.0.tgz", - "integrity": "sha512-k107IF4+Xr7UHjwDc7Cfd6PRQfbdkiRabXGRjo07b4WyPahFBZCZ1sE+BNxYIJPPg73UkfOsVOLwqVc/6ETrIA==", + "version": "7.7.1", + "resolved": "https://registry.npmjs.org/@types/semver/-/semver-7.7.1.tgz", + "integrity": "sha512-FmgJfu+MOcQ370SD0ev7EI8TlCAfKYU+B4m5T3yXc1CiRN94g/SZPtsCkk506aUDtlMnFZvasDwHHUcZUEaYuA==", "license": "MIT" }, "node_modules/@types/send": { - "version": "0.17.4", - "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.4.tgz", - "integrity": "sha512-x2EM6TJOybec7c52BX0ZspPodMsQUd5L6PRwOunVyVUhXiBSKf3AezDL8Dgvgt5o0UfKNfuA0eMLr2wLT4AiBA==", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@types/send/-/send-1.2.0.tgz", + "integrity": "sha512-zBF6vZJn1IaMpg3xUF25VK3gd3l8zwE0ZLRX7dsQyQi+jp4E8mMDJNGDYnYse+bQhYwWERTxVwHpi3dMOq7RKQ==", "license": "MIT", "dependencies": { - "@types/mime": "^1", "@types/node": "*" } }, @@ -4165,14 +4164,24 @@ } }, "node_modules/@types/serve-static": { - "version": "1.15.7", - "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.7.tgz", - "integrity": "sha512-W8Ym+h8nhuRwaKPaDw34QUkwsGi6Rc4yYqvKFo5rm2FUEhCFbzVWrxXUxuKK8TASjWsysJY0nsmNCGhCOIsrOw==", + "version": "1.15.9", + "resolved": "https://registry.npmjs.org/@types/serve-static/-/serve-static-1.15.9.tgz", + "integrity": "sha512-dOTIuqpWLyl3BBXU3maNQsS4A3zuuoYRNIvYSxxhebPfXg2mzWQEPne/nlJ37yOse6uGgR386uTpdsx4D0QZWA==", "license": "MIT", "dependencies": { "@types/http-errors": "*", "@types/node": "*", - "@types/send": "*" + "@types/send": "<1" + } + }, + "node_modules/@types/serve-static/node_modules/@types/send": { + "version": "0.17.5", + "resolved": "https://registry.npmjs.org/@types/send/-/send-0.17.5.tgz", + "integrity": "sha512-z6F2D3cOStZvuk2SaP6YrwkNO65iTZcwA2ZkSABegdkAh/lf+Aa/YQndZVfmEXT5vgAp6zv06VQ3ejSVjAny4w==", + "license": "MIT", + "dependencies": { + "@types/mime": "^1", + "@types/node": "*" } }, "node_modules/@types/sockjs": { @@ -4643,9 +4652,9 @@ } }, "node_modules/acorn": { - "version": "8.14.1", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.1.tgz", - "integrity": "sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg==", + "version": "8.15.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz", + "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==", "license": "MIT", "bin": { "acorn": "bin/acorn" @@ -4676,6 +4685,18 @@ "node": ">=0.4.0" } }, + "node_modules/acorn-import-phases": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/acorn-import-phases/-/acorn-import-phases-1.0.4.tgz", + "integrity": "sha512-wKmbr/DDiIXzEOiWrTTUcDm24kQ2vGfZQvM2fwg2vXqR5uW6aapr7ObPtj1th32b9u90/Pf4AItvdTh42fBmVQ==", + "license": "MIT", + "engines": { + "node": ">=10.13.0" + }, + "peerDependencies": { + "acorn": "^8.14.0" + } + }, "node_modules/acorn-jsx": { "version": "5.3.2", "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", @@ -4921,17 +4942,19 @@ "license": "MIT" }, "node_modules/array-includes": { - "version": "3.1.8", - "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.8.tgz", - "integrity": "sha512-itaWrbYbqpGXkGhZPGUulwnhVf5Hpy1xiCFsGqyIGglbBxmG5vSjxQen3/WGOjPpNEv1RtBLKxbmVXm8HpJStQ==", + "version": "3.1.9", + "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.9.tgz", + "integrity": "sha512-FmeCCAenzH0KH381SPT5FZmiA/TmpndpcaShhfgEN9eCVjnFBqq3l1xrI42y8+PPLI6hypzou4GXw00WHmPBLQ==", "license": "MIT", "dependencies": { - "call-bind": "^1.0.7", + "call-bind": "^1.0.8", + "call-bound": "^1.0.4", "define-properties": "^1.2.1", - "es-abstract": "^1.23.2", - "es-object-atoms": "^1.0.0", - "get-intrinsic": "^1.2.4", - "is-string": "^1.0.7" + "es-abstract": "^1.24.0", + "es-object-atoms": "^1.1.1", + "get-intrinsic": "^1.3.0", + "is-string": "^1.1.1", + "math-intrinsics": "^1.1.0" }, "engines": { "node": ">= 0.4" @@ -5189,22 +5212,22 @@ } }, "node_modules/axe-core": { - "version": "4.10.3", - "resolved": "https://registry.npmjs.org/axe-core/-/axe-core-4.10.3.tgz", - "integrity": "sha512-Xm7bpRXnDSX2YE2YFfBk2FnF0ep6tmG7xPh8iHee8MIcrgq762Nkce856dYtJYLkuIoYZvGfTs/PbZhideTcEg==", + "version": "4.11.0", + "resolved": "https://registry.npmjs.org/axe-core/-/axe-core-4.11.0.tgz", + "integrity": "sha512-ilYanEU8vxxBexpJd8cWM4ElSQq4QctCLKih0TSfjIfCQTeyH/6zVrmIJfLPrKTKJRbiG+cfnZbQIjAlJmF1jQ==", "license": "MPL-2.0", "engines": { "node": ">=4" } }, "node_modules/axios": { - "version": "1.9.0", - "resolved": "https://registry.npmjs.org/axios/-/axios-1.9.0.tgz", - "integrity": "sha512-re4CqKTJaURpzbLHtIi6XpDv20/CnpXOtjRY5/CU32L8gU8ek9UIivcfvSWvmKEngmVbrUtPpdDwWDWL7DNHvg==", + "version": "1.12.2", + "resolved": "https://registry.npmjs.org/axios/-/axios-1.12.2.tgz", + "integrity": "sha512-vMJzPewAlRyOgxV2dU0Cuz2O8zzzx9VYtbJOaBgXFeLc4IV/Eg50n4LowmehOOR61S8ZMpc2K5Sa7g6A4jfkUw==", "license": "MIT", "dependencies": { "follow-redirects": "^1.15.6", - "form-data": "^4.0.0", + "form-data": "^4.0.4", "proxy-from-env": "^1.1.0" } }, @@ -5332,13 +5355,13 @@ } }, "node_modules/babel-plugin-polyfill-corejs2": { - "version": "0.4.13", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.13.tgz", - "integrity": "sha512-3sX/eOms8kd3q2KZ6DAhKPc0dgm525Gqq5NtWKZ7QYYZEv57OQ54KtblzJzH1lQF/eQxO8KjWGIK9IPUJNus5g==", + "version": "0.4.14", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.4.14.tgz", + "integrity": "sha512-Co2Y9wX854ts6U8gAAPXfn0GmAyctHuK8n0Yhfjd6t30g7yvKjspvvOo9yG+z52PZRgFErt7Ka2pYnXCjLKEpg==", "license": "MIT", "dependencies": { - "@babel/compat-data": "^7.22.6", - "@babel/helper-define-polyfill-provider": "^0.6.4", + "@babel/compat-data": "^7.27.7", + "@babel/helper-define-polyfill-provider": "^0.6.5", "semver": "^6.3.1" }, "peerDependencies": { @@ -5355,25 +5378,25 @@ } }, "node_modules/babel-plugin-polyfill-corejs3": { - "version": "0.11.1", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.11.1.tgz", - "integrity": "sha512-yGCqvBT4rwMczo28xkH/noxJ6MZ4nJfkVYdoDaC/utLtWrXxv27HVrzAeSbqR8SxDsp46n0YF47EbHoixy6rXQ==", + "version": "0.13.0", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.13.0.tgz", + "integrity": "sha512-U+GNwMdSFgzVmfhNm8GJUX88AadB3uo9KpJqS3FaqNIPKgySuvMb+bHPsOmmuWyIcuqZj/pzt1RUIUZns4y2+A==", "license": "MIT", "dependencies": { - "@babel/helper-define-polyfill-provider": "^0.6.3", - "core-js-compat": "^3.40.0" + "@babel/helper-define-polyfill-provider": "^0.6.5", + "core-js-compat": "^3.43.0" }, "peerDependencies": { "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" } }, "node_modules/babel-plugin-polyfill-regenerator": { - "version": "0.6.4", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.4.tgz", - "integrity": "sha512-7gD3pRadPrbjhjLyxebmx/WrFYcuSjZ0XbdUujQMZ/fcE9oeewk2U/7PCvez84UeuK3oSjmPZ0Ch0dlupQvGzw==", + "version": "0.6.5", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.6.5.tgz", + "integrity": "sha512-ISqQ2frbiNU9vIJkzg7dlPpznPZ4jOiUQ1uSmB0fEHeowtN3COYRsXr/xexn64NpU13P06jc/L5TgiJXOgrbEg==", "license": "MIT", "dependencies": { - "@babel/helper-define-polyfill-provider": "^0.6.4" + "@babel/helper-define-polyfill-provider": "^0.6.5" }, "peerDependencies": { "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" @@ -5386,9 +5409,9 @@ "license": "MIT" }, "node_modules/babel-preset-current-node-syntax": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.1.0.tgz", - "integrity": "sha512-ldYss8SbBlWva1bs28q78Ju5Zq1F+8BrqBZZ0VFhLBvhh6lCpC2o3gDJi/5DRLs9FgYZCnmPYIVFU4lRXCkyUw==", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/babel-preset-current-node-syntax/-/babel-preset-current-node-syntax-1.2.0.tgz", + "integrity": "sha512-E/VlAEzRrsLEb2+dv8yp3bo4scof3l9nR4lrld+Iy5NyVqgVYUJnDAmunkhPMisRI32Qc4iRiz425d8vM++2fg==", "license": "MIT", "dependencies": { "@babel/plugin-syntax-async-generators": "^7.8.4", @@ -5408,7 +5431,7 @@ "@babel/plugin-syntax-top-level-await": "^7.14.5" }, "peerDependencies": { - "@babel/core": "^7.0.0" + "@babel/core": "^7.0.0 || ^8.0.0-0" } }, "node_modules/babel-preset-jest": { @@ -5477,6 +5500,15 @@ "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", "license": "MIT" }, + "node_modules/baseline-browser-mapping": { + "version": "2.8.16", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.8.16.tgz", + "integrity": "sha512-OMu3BGQ4E7P1ErFsIPpbJh0qvDudM/UuJeHgkAvfWe+0HFJCXh+t/l8L6fVLR55RI/UbKrVLnAXZSVwd9ysWYw==", + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.js" + } + }, "node_modules/batch": { "version": "0.6.1", "resolved": "https://registry.npmjs.org/batch/-/batch-0.6.1.tgz", @@ -5594,9 +5626,9 @@ "license": "ISC" }, "node_modules/bootstrap": { - "version": "5.3.6", - "resolved": "https://registry.npmjs.org/bootstrap/-/bootstrap-5.3.6.tgz", - "integrity": "sha512-jX0GAcRzvdwISuvArXn3m7KZscWWFAf1MKBcnzaN02qWMb3jpMoUX4/qgeiGzqyIb4ojulRzs89UCUmGcFSzTA==", + "version": "5.3.8", + "resolved": "https://registry.npmjs.org/bootstrap/-/bootstrap-5.3.8.tgz", + "integrity": "sha512-HP1SZDqaLDPwsNiqRqi5NcP0SSXciX2s9E+RyqJIIqGo+vJeN5AJVM98CXmW/Wux0nQ5L7jeWUdplCEf0Ee+tg==", "funding": [ { "type": "github", @@ -5613,9 +5645,9 @@ } }, "node_modules/brace-expansion": { - "version": "1.1.11", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", - "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "version": "1.1.12", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz", + "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==", "license": "MIT", "dependencies": { "balanced-match": "^1.0.0", @@ -5641,9 +5673,9 @@ "license": "BSD-2-Clause" }, "node_modules/browserslist": { - "version": "4.24.5", - "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.5.tgz", - "integrity": "sha512-FDToo4Wo82hIdgc1CQ+NQD0hEhmpPjrZ3hiUgwgOG6IuTdlpr8jdjyG24P6cNP1yJpTLzS5OcGgSw0xmDU1/Tw==", + "version": "4.26.3", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.26.3.tgz", + "integrity": "sha512-lAUU+02RFBuCKQPj/P6NgjlbCnLBMp4UtgTx7vNHd3XSIJF87s9a5rA3aH2yw3GS9DqZAUbOtZdCCiZeVRqt0w==", "funding": [ { "type": "opencollective", @@ -5660,9 +5692,10 @@ ], "license": "MIT", "dependencies": { - "caniuse-lite": "^1.0.30001716", - "electron-to-chromium": "^1.5.149", - "node-releases": "^2.0.19", + "baseline-browser-mapping": "^2.8.9", + "caniuse-lite": "^1.0.30001746", + "electron-to-chromium": "^1.5.227", + "node-releases": "^2.0.21", "update-browserslist-db": "^1.1.3" }, "bin": { @@ -5808,9 +5841,9 @@ } }, "node_modules/caniuse-lite": { - "version": "1.0.30001717", - "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001717.tgz", - "integrity": "sha512-auPpttCq6BDEG8ZAuHJIplGw6GODhjw+/11e7IjpnYCxZcW/ONgPs0KVBJ0d1bY3e2+7PRe5RCLyP+PfwVgkYw==", + "version": "1.0.30001750", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001750.tgz", + "integrity": "sha512-cuom0g5sdX6rw00qOoLNSFCJ9/mYIsuSOA+yzpDw8eopiFqcVwQvZHqov0vmEighRxX++cfC0Vg1G+1Iy/mSpQ==", "funding": [ { "type": "opencollective", @@ -6135,12 +6168,12 @@ } }, "node_modules/commander": { - "version": "8.3.0", - "resolved": "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz", - "integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==", + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz", + "integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==", "license": "MIT", "engines": { - "node": ">= 12" + "node": ">= 10" } }, "node_modules/common-tags": { @@ -6171,16 +6204,16 @@ } }, "node_modules/compression": { - "version": "1.8.0", - "resolved": "https://registry.npmjs.org/compression/-/compression-1.8.0.tgz", - "integrity": "sha512-k6WLKfunuqCYD3t6AsuPGvQWaKwuLLh2/xHNcX4qE+vIfDNXpSqnrhwA7O53R7WVQUnt8dVAIW+YHr7xTgOgGA==", + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/compression/-/compression-1.8.1.tgz", + "integrity": "sha512-9mAqGPHLakhCLeNyxPkK4xVo746zQ/czLH1Ky+vkitMnWfWZps8r0qXuwhwizagCRttsL4lfG4pIOvaWLpAP0w==", "license": "MIT", "dependencies": { "bytes": "3.1.2", "compressible": "~2.0.18", "debug": "2.6.9", "negotiator": "~0.6.4", - "on-headers": "~1.0.2", + "on-headers": "~1.1.0", "safe-buffer": "5.2.1", "vary": "~1.1.2" }, @@ -6273,9 +6306,9 @@ "license": "MIT" }, "node_modules/core-js": { - "version": "3.42.0", - "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.42.0.tgz", - "integrity": "sha512-Sz4PP4ZA+Rq4II21qkNqOEDTDrCvcANId3xpIgB34NDkWc3UduWj2dqEtN9yZIq8Dk3HyPI33x9sqqU5C8sr0g==", + "version": "3.46.0", + "resolved": "https://registry.npmjs.org/core-js/-/core-js-3.46.0.tgz", + "integrity": "sha512-vDMm9B0xnqqZ8uSBpZ8sNtRtOdmfShrvT6h2TuQGLs0Is+cR0DYbj/KWP6ALVNbWPpqA/qPLoOuppJN07humpA==", "hasInstallScript": true, "license": "MIT", "funding": { @@ -6284,12 +6317,12 @@ } }, "node_modules/core-js-compat": { - "version": "3.42.0", - "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.42.0.tgz", - "integrity": "sha512-bQasjMfyDGyaeWKBIu33lHh9qlSR0MFE/Nmc6nMjf/iU9b3rSMdAYz1Baxrv4lPdGUsTqZudHA4jIGSJy0SWZQ==", + "version": "3.46.0", + "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.46.0.tgz", + "integrity": "sha512-p9hObIIEENxSV8xIu+V68JjSeARg6UVMG5mR+JEUguG3sI6MsiS1njz2jHmyJDvA+8jX/sytkBHup6kxhM9law==", "license": "MIT", "dependencies": { - "browserslist": "^4.24.4" + "browserslist": "^4.26.3" }, "funding": { "type": "opencollective", @@ -6297,9 +6330,9 @@ } }, "node_modules/core-js-pure": { - "version": "3.42.0", - "resolved": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.42.0.tgz", - "integrity": "sha512-007bM04u91fF4kMgwom2I5cQxAFIy8jVulgr9eozILl/SZE53QOqnW/+vviC+wQWLv+AunBG+8Q0TLoeSsSxRQ==", + "version": "3.46.0", + "resolved": "https://registry.npmjs.org/core-js-pure/-/core-js-pure-3.46.0.tgz", + "integrity": "sha512-NMCW30bHNofuhwLhYPt66OLOKTMbOhgTTatKVbaQC3KRHpTCiRIBYvtshr+NBYSnBxwAFhjW/RfJ0XbIjS16rw==", "hasInstallScript": true, "license": "MIT", "funding": { @@ -6551,9 +6584,9 @@ } }, "node_modules/css-what": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.1.0.tgz", - "integrity": "sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==", + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.2.2.tgz", + "integrity": "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==", "license": "BSD-2-Clause", "engines": { "node": ">= 6" @@ -6731,9 +6764,9 @@ "license": "MIT" }, "node_modules/cytoscape": { - "version": "3.32.0", - "resolved": "https://registry.npmjs.org/cytoscape/-/cytoscape-3.32.0.tgz", - "integrity": "sha512-5JHBC9n75kz5851jeklCPmZWcg3hUe6sjqJvyk3+hVqFaKcHwHgxsjeN1yLmggoUc6STbtm9/NQyabQehfjvWQ==", + "version": "3.33.1", + "resolved": "https://registry.npmjs.org/cytoscape/-/cytoscape-3.33.1.tgz", + "integrity": "sha512-iJc4TwyANnOGR1OmWhsS9ayRS3s+XQ185FmuHObThD+5AeJCakAAbWv8KimMTt08xCCLNgneQwFp+JRJOr9qGQ==", "license": "MIT", "engines": { "node": ">=0.10" @@ -6948,15 +6981,6 @@ "node": ">=12" } }, - "node_modules/d3-dsv/node_modules/commander": { - "version": "7.2.0", - "resolved": "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz", - "integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==", - "license": "MIT", - "engines": { - "node": ">= 10" - } - }, "node_modules/d3-ease": { "version": "3.0.1", "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz", @@ -7310,15 +7334,15 @@ } }, "node_modules/dayjs": { - "version": "1.11.13", - "resolved": "https://registry.npmjs.org/dayjs/-/dayjs-1.11.13.tgz", - "integrity": "sha512-oaMBel6gjolK862uaPQOVTA7q3TZhuSvuMQAAglQDOWYO9A91IrAOUJEyKVlqJlHE0vq5p5UXxzdPfMH/x6xNg==", + "version": "1.11.18", + "resolved": "https://registry.npmjs.org/dayjs/-/dayjs-1.11.18.tgz", + "integrity": "sha512-zFBQ7WFRvVRhKcWoUh+ZA1g2HVgUbsZm9sbddh8EC5iv93sui8DVVz1Npvz+r6meo9VKfa8NyLWBsQK1VvIKPA==", "license": "MIT" }, "node_modules/debug": { - "version": "4.4.0", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz", - "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==", + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", "license": "MIT", "dependencies": { "ms": "^2.1.3" @@ -7333,9 +7357,9 @@ } }, "node_modules/decimal.js": { - "version": "10.5.0", - "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.5.0.tgz", - "integrity": "sha512-8vDa8Qxvr/+d94hSh5P3IJwI5t8/c0KsMp+g8bNw9cY2icONa5aPfvKeieW1WlG0WQYwwhJ7mjui2xtiePQSXw==", + "version": "10.6.0", + "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz", + "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==", "license": "MIT" }, "node_modules/dedent": { @@ -7628,9 +7652,9 @@ } }, "node_modules/dompurify": { - "version": "3.2.5", - "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.2.5.tgz", - "integrity": "sha512-mLPd29uoRe9HpvwP2TxClGQBzGXeEC/we/q+bFlmPPmj2p2Ugl3r6ATu/UU1v77DXNcehiBg9zsr1dREyA/dJQ==", + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.3.0.tgz", + "integrity": "sha512-r+f6MYR1gGN1eJv0TVQbhA7if/U7P87cdPl3HN5rikqaBSBxLiCb/b9O+2eG0cxz0ghyU+mU1QkbsOwERMYlWQ==", "license": "(MPL-2.0 OR Apache-2.0)", "optionalDependencies": { "@types/trusted-types": "^2.0.7" @@ -7723,9 +7747,9 @@ } }, "node_modules/electron-to-chromium": { - "version": "1.5.152", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.152.tgz", - "integrity": "sha512-xBOfg/EBaIlVsHipHl2VdTPJRSvErNUaqW8ejTq5OlOlIYx1wOllCHsAvAIrr55jD1IYEfdR86miUEt8H5IeJg==", + "version": "1.5.237", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.237.tgz", + "integrity": "sha512-icUt1NvfhGLar5lSWH3tHNzablaA5js3HVHacQimfP8ViEBOQv+L7DKEuHdbTZ0SKCO1ogTJTIL1Gwk9S6Qvcg==", "license": "ISC" }, "node_modules/emittery": { @@ -7765,9 +7789,9 @@ } }, "node_modules/enhanced-resolve": { - "version": "5.18.1", - "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.18.1.tgz", - "integrity": "sha512-ZSW3ma5GkcQBIpwZTSRAI8N71Uuwgs93IezB7mf7R60tC8ZbJideoDNKjHn2O9KIlx6rkGTTEk1xUCK2E1Y2Yg==", + "version": "5.18.3", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.18.3.tgz", + "integrity": "sha512-d4lC8xfavMeBjzGr2vECC3fsGXziXZQyJxD868h2M/mBI3PwAuODxAkLkq5HYuvrPYcUtiLzsTo8U3PgX3Ocww==", "license": "MIT", "dependencies": { "graceful-fs": "^4.2.4", @@ -7787,9 +7811,9 @@ } }, "node_modules/error-ex": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", - "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.4.tgz", + "integrity": "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==", "license": "MIT", "dependencies": { "is-arrayish": "^0.2.1" @@ -7805,27 +7829,27 @@ } }, "node_modules/es-abstract": { - "version": "1.23.9", - "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.23.9.tgz", - "integrity": "sha512-py07lI0wjxAC/DcfK1S6G7iANonniZwTISvdPzk9hzeH0IZIshbuuFxLIU96OyF89Yb9hiqWn8M/bY83KY5vzA==", + "version": "1.24.0", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.24.0.tgz", + "integrity": "sha512-WSzPgsdLtTcQwm4CROfS5ju2Wa1QQcVeT37jFjYzdFz1r9ahadC8B8/a4qxJxM+09F18iumCdRmlr96ZYkQvEg==", "license": "MIT", "dependencies": { "array-buffer-byte-length": "^1.0.2", "arraybuffer.prototype.slice": "^1.0.4", "available-typed-arrays": "^1.0.7", "call-bind": "^1.0.8", - "call-bound": "^1.0.3", + "call-bound": "^1.0.4", "data-view-buffer": "^1.0.2", "data-view-byte-length": "^1.0.2", "data-view-byte-offset": "^1.0.1", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", - "es-object-atoms": "^1.0.0", + "es-object-atoms": "^1.1.1", "es-set-tostringtag": "^2.1.0", "es-to-primitive": "^1.3.0", "function.prototype.name": "^1.1.8", - "get-intrinsic": "^1.2.7", - "get-proto": "^1.0.0", + "get-intrinsic": "^1.3.0", + "get-proto": "^1.0.1", "get-symbol-description": "^1.1.0", "globalthis": "^1.0.4", "gopd": "^1.2.0", @@ -7837,21 +7861,24 @@ "is-array-buffer": "^3.0.5", "is-callable": "^1.2.7", "is-data-view": "^1.0.2", + "is-negative-zero": "^2.0.3", "is-regex": "^1.2.1", + "is-set": "^2.0.3", "is-shared-array-buffer": "^1.0.4", "is-string": "^1.1.1", "is-typed-array": "^1.1.15", - "is-weakref": "^1.1.0", + "is-weakref": "^1.1.1", "math-intrinsics": "^1.1.0", - "object-inspect": "^1.13.3", + "object-inspect": "^1.13.4", "object-keys": "^1.1.1", "object.assign": "^4.1.7", "own-keys": "^1.0.1", - "regexp.prototype.flags": "^1.5.3", + "regexp.prototype.flags": "^1.5.4", "safe-array-concat": "^1.1.3", "safe-push-apply": "^1.0.0", "safe-regex-test": "^1.1.0", "set-proto": "^1.0.0", + "stop-iteration-iterator": "^1.1.0", "string.prototype.trim": "^1.2.10", "string.prototype.trimend": "^1.0.9", "string.prototype.trimstart": "^1.0.8", @@ -7860,7 +7887,7 @@ "typed-array-byte-offset": "^1.0.4", "typed-array-length": "^1.0.7", "unbox-primitive": "^1.1.0", - "which-typed-array": "^1.1.18" + "which-typed-array": "^1.1.19" }, "engines": { "node": ">= 0.4" @@ -8145,9 +8172,9 @@ } }, "node_modules/eslint-module-utils": { - "version": "2.12.0", - "resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.12.0.tgz", - "integrity": "sha512-wALZ0HFoytlyh/1+4wuZ9FJCD/leWHQzzrxJ8+rebyReSLk7LApMyd3WJaLVoN+D5+WIdJyDK1c6JnE65V4Zyg==", + "version": "2.12.1", + "resolved": "https://registry.npmjs.org/eslint-module-utils/-/eslint-module-utils-2.12.1.tgz", + "integrity": "sha512-L8jSWTze7K2mTg0vos/RuLRS5soomksDPoJLXIslC7c8Wmut3bx7CPpJijDcBZtxQ5lrbUdM+s0OlNbz0DCDNw==", "license": "MIT", "dependencies": { "debug": "^3.2.7" @@ -8189,29 +8216,29 @@ } }, "node_modules/eslint-plugin-import": { - "version": "2.31.0", - "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.31.0.tgz", - "integrity": "sha512-ixmkI62Rbc2/w8Vfxyh1jQRTdRTF52VxwRVHl/ykPAmqG+Nb7/kNn+byLP0LxPgI7zWA16Jt82SybJInmMia3A==", + "version": "2.32.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-import/-/eslint-plugin-import-2.32.0.tgz", + "integrity": "sha512-whOE1HFo/qJDyX4SnXzP4N6zOWn79WhnCUY/iDR0mPfQZO8wcYE4JClzI2oZrhBnnMUCBCHZhO6VQyoBU95mZA==", "license": "MIT", "dependencies": { "@rtsao/scc": "^1.1.0", - "array-includes": "^3.1.8", - "array.prototype.findlastindex": "^1.2.5", - "array.prototype.flat": "^1.3.2", - "array.prototype.flatmap": "^1.3.2", + "array-includes": "^3.1.9", + "array.prototype.findlastindex": "^1.2.6", + "array.prototype.flat": "^1.3.3", + "array.prototype.flatmap": "^1.3.3", "debug": "^3.2.7", "doctrine": "^2.1.0", "eslint-import-resolver-node": "^0.3.9", - "eslint-module-utils": "^2.12.0", + "eslint-module-utils": "^2.12.1", "hasown": "^2.0.2", - "is-core-module": "^2.15.1", + "is-core-module": "^2.16.1", "is-glob": "^4.0.3", "minimatch": "^3.1.2", "object.fromentries": "^2.0.8", "object.groupby": "^1.0.3", - "object.values": "^1.2.0", + "object.values": "^1.2.1", "semver": "^6.3.1", - "string.prototype.trimend": "^1.0.8", + "string.prototype.trimend": "^1.0.9", "tsconfig-paths": "^3.15.0" }, "engines": { @@ -8799,9 +8826,9 @@ "license": "MIT" }, "node_modules/exsolve": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/exsolve/-/exsolve-1.0.5.tgz", - "integrity": "sha512-pz5dvkYYKQ1AHVrgOzBKWeP4u4FRb3a6DNK2ucr0OoNwYIU4QWsJ+NM36LLzORT+z845MzKHHhpXiUF5nvQoJg==", + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/exsolve/-/exsolve-1.0.7.tgz", + "integrity": "sha512-VO5fQUzZtI6C+vx4w/4BWJpg3s/5l+6pRQEHzFRM8WFi4XffSP1Z+4qi7GbjWbvRQEbdIco5mIMq+zX4rPuLrw==", "license": "MIT" }, "node_modules/fast-deep-equal": { @@ -8851,9 +8878,9 @@ "license": "MIT" }, "node_modules/fast-uri": { - "version": "3.0.6", - "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.0.6.tgz", - "integrity": "sha512-Atfo14OibSv5wAp4VWNsFYE1AchQRTv9cBGWET4pZWHzYshFSS9NQI6I57rdKn9croWVMbYFbLhJ+yJvmZIIHw==", + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.0.tgz", + "integrity": "sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==", "funding": [ { "type": "github", @@ -8968,9 +8995,9 @@ } }, "node_modules/filelist/node_modules/brace-expansion": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", - "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz", + "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==", "license": "MIT", "dependencies": { "balanced-match": "^1.0.0" @@ -9093,9 +9120,9 @@ "license": "ISC" }, "node_modules/follow-redirects": { - "version": "1.15.9", - "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz", - "integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==", + "version": "1.15.11", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz", + "integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==", "funding": [ { "type": "individual", @@ -9253,14 +9280,15 @@ } }, "node_modules/form-data": { - "version": "4.0.2", - "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.2.tgz", - "integrity": "sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w==", + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz", + "integrity": "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==", "license": "MIT", "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", + "hasown": "^2.0.2", "mime-types": "^2.1.12" }, "engines": { @@ -9313,9 +9341,9 @@ } }, "node_modules/fs-monkey": { - "version": "1.0.6", - "resolved": "https://registry.npmjs.org/fs-monkey/-/fs-monkey-1.0.6.tgz", - "integrity": "sha512-b1FMfwetIKymC0eioW7mTywihSQE4oLzQn1dB6rZB5fx/3NpNEdAWeCSMB+60/AeT0TCXsxzAlcYVEFCTAksWg==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fs-monkey/-/fs-monkey-1.1.0.tgz", + "integrity": "sha512-QMUezzXWII9EV5aTFXW1UBVUO77wYPpjqIF8/AviUCThNeSYZykpoTixUeaNNBwmCev0AMDWMAni+f8Hxb1IFw==", "license": "Unlicense" }, "node_modules/fs.realpath": { @@ -9376,6 +9404,15 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/generator-function": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/generator-function/-/generator-function-2.0.1.tgz", + "integrity": "sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, "node_modules/gensync": { "version": "1.0.0-beta.2", "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", @@ -9553,12 +9590,15 @@ } }, "node_modules/globals": { - "version": "11.12.0", - "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz", - "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==", + "version": "15.15.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-15.15.0.tgz", + "integrity": "sha512-7ACyT3wmyp3I61S4fG682L0VA2RGD9otkqGJIwNUMF1SWUombIIk+af1unuDYgMm082aHYwD+mzJvv9Iu8dsgg==", "license": "MIT", "engines": { - "node": ">=4" + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" } }, "node_modules/globalthis": { @@ -9862,10 +9902,19 @@ "node": ">=12" } }, + "node_modules/html-minifier-terser/node_modules/commander": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz", + "integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==", + "license": "MIT", + "engines": { + "node": ">= 12" + } + }, "node_modules/html-webpack-plugin": { - "version": "5.6.3", - "resolved": "https://registry.npmjs.org/html-webpack-plugin/-/html-webpack-plugin-5.6.3.tgz", - "integrity": "sha512-QSf1yjtSAsmf7rYBV7XX86uua4W/vkhIt0xNXKbsi2foEeW7vjJQz4bhnpL3xH+l1ryl1680uNv968Z+X6jSYg==", + "version": "5.6.4", + "resolved": "https://registry.npmjs.org/html-webpack-plugin/-/html-webpack-plugin-5.6.4.tgz", + "integrity": "sha512-V/PZeWsqhfpE27nKeX9EO2sbR+D17A+tLf6qU+ht66jdUsN0QLKJN27Z+1+gHrVMKgndBahes0PU6rRihDgHTw==", "license": "MIT", "dependencies": { "@types/html-minifier-terser": "^6.0.0", @@ -9993,18 +10042,6 @@ } } }, - "node_modules/http-proxy-middleware/node_modules/is-plain-obj": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-3.0.0.tgz", - "integrity": "sha512-gwsOE28k+23GP1B6vFl1oVh/WOzmawBrKwo5Ev6wMKzPkaXaCDIQKzLnvsA42DRlbVTWorkgTKIviAKCWkfUwA==", - "license": "MIT", - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, "node_modules/https-proxy-agent": { "version": "5.0.1", "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-5.0.1.tgz", @@ -10399,13 +10436,14 @@ } }, "node_modules/is-generator-function": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.1.0.tgz", - "integrity": "sha512-nPUB5km40q9e8UfN/Zc24eLlzdSf9OfKByBw9CIdw4H1giPMeA0OIJvbchsCu4npfI2QcMVBsGEBHKZ7wLTWmQ==", + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.1.2.tgz", + "integrity": "sha512-upqt1SkGkODW9tsGNG5mtXTXtECizwtS2kA161M+gJPc1xdb/Ax629af6YrTwcOeQHbewrPNlE5Dx7kzvXTizA==", "license": "MIT", "dependencies": { - "call-bound": "^1.0.3", - "get-proto": "^1.0.0", + "call-bound": "^1.0.4", + "generator-function": "^2.0.0", + "get-proto": "^1.0.1", "has-tostringtag": "^1.0.2", "safe-regex-test": "^1.1.0" }, @@ -10446,6 +10484,18 @@ "integrity": "sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==", "license": "MIT" }, + "node_modules/is-negative-zero": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.3.tgz", + "integrity": "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, "node_modules/is-number": { "version": "7.0.0", "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", @@ -10489,6 +10539,18 @@ "node": ">=8" } }, + "node_modules/is-plain-obj": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-3.0.0.tgz", + "integrity": "sha512-gwsOE28k+23GP1B6vFl1oVh/WOzmawBrKwo5Ev6wMKzPkaXaCDIQKzLnvsA42DRlbVTWorkgTKIviAKCWkfUwA==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/is-potential-custom-element-name": { "version": "1.0.1", "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz", @@ -10778,9 +10840,9 @@ } }, "node_modules/istanbul-reports": { - "version": "3.1.7", - "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.1.7.tgz", - "integrity": "sha512-BewmUXImeuRk2YY0PVbxgKAysvhRPUQE0h5QRM++nVWyubKGV0l8qQ5op8+B2DOmwSe63Jivj0BjkPQVf8fP5g==", + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/istanbul-reports/-/istanbul-reports-3.2.0.tgz", + "integrity": "sha512-HGYWWS/ehqTV3xN10i23tkPkpH46MLCIMFNCaaKNavAXTF1RkqxawEPtnjnGZ6XKSInBKkiOA5BKS+aZiY3AvA==", "license": "BSD-3-Clause", "dependencies": { "html-escaper": "^2.0.0", @@ -10823,15 +10885,14 @@ } }, "node_modules/jake": { - "version": "10.9.2", - "resolved": "https://registry.npmjs.org/jake/-/jake-10.9.2.tgz", - "integrity": "sha512-2P4SQ0HrLQ+fw6llpLnOaGAvN2Zu6778SJMrCUwns4fOoG9ayrTiZk3VV8sCPkVZF8ab0zksVpS8FDY5pRCNBA==", + "version": "10.9.4", + "resolved": "https://registry.npmjs.org/jake/-/jake-10.9.4.tgz", + "integrity": "sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA==", "license": "Apache-2.0", "dependencies": { - "async": "^3.2.3", - "chalk": "^4.0.2", + "async": "^3.2.6", "filelist": "^1.0.4", - "minimatch": "^3.1.2" + "picocolors": "^1.1.1" }, "bin": { "jake": "bin/cli.js" @@ -11664,9 +11725,9 @@ } }, "node_modules/jest-watch-typeahead/node_modules/strip-ansi": { - "version": "7.1.0", - "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", - "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.2.tgz", + "integrity": "sha512-gmBGslpoQJtgnMAvOVqGZpEz9dyoKTCzy2nfz/n8aIFhN/jCE/rCmcxabB6jOOHV+0WNnylOxaxBQPSvcWklhA==", "license": "MIT", "dependencies": { "ansi-regex": "^6.0.1" @@ -11679,9 +11740,9 @@ } }, "node_modules/jest-watch-typeahead/node_modules/strip-ansi/node_modules/ansi-regex": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz", - "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==", + "version": "6.2.2", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz", + "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==", "license": "MIT", "engines": { "node": ">=12" @@ -11812,14 +11873,15 @@ } }, "node_modules/jsdom/node_modules/form-data": { - "version": "3.0.3", - "resolved": "https://registry.npmjs.org/form-data/-/form-data-3.0.3.tgz", - "integrity": "sha512-q5YBMeWy6E2Un0nMGWMgI65MAKtaylxfNJGJxpGh45YDciZB4epbWpaAfImil6CPAPTYB4sh0URQNDRIZG5F2w==", + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-3.0.4.tgz", + "integrity": "sha512-f0cRzm6dkyVYV3nPoooP8XlccPQukegwhAnpoLcXy+X+A8KfpGOoXwDr9FLZd3wzgLaBGQBE3lY93Zm/i1JvIQ==", "license": "MIT", "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", + "hasown": "^2.0.2", "mime-types": "^2.1.35" }, "engines": { @@ -11881,9 +11943,9 @@ } }, "node_modules/jsonfile": { - "version": "6.1.0", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz", - "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==", + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz", + "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==", "license": "MIT", "dependencies": { "universalify": "^2.0.0" @@ -11940,9 +12002,9 @@ } }, "node_modules/katex": { - "version": "0.16.22", - "resolved": "https://registry.npmjs.org/katex/-/katex-0.16.22.tgz", - "integrity": "sha512-XCHRdUw4lf3SKBaJe4EvgqIuWwkPSo9XoeO8GjQW94Bp7TWv9hNhzZjZ+OH9yf1UmLygb7DIT5GSFQiyt16zYg==", + "version": "0.16.25", + "resolved": "https://registry.npmjs.org/katex/-/katex-0.16.25.tgz", + "integrity": "sha512-woHRUZ/iF23GBP1dkDQMh1QBad9dmr8/PAwNA54VrSOVYgI12MAcE14TqnDdQOdzyEonGzMepYnqBMYdsoAr8Q==", "funding": [ "https://opencollective.com/katex", "https://github.com/sponsors/katex" @@ -11955,6 +12017,15 @@ "katex": "cli.js" } }, + "node_modules/katex/node_modules/commander": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz", + "integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==", + "license": "MIT", + "engines": { + "node": ">= 12" + } + }, "node_modules/keyv": { "version": "4.5.4", "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", @@ -12037,13 +12108,13 @@ } }, "node_modules/launch-editor": { - "version": "2.10.0", - "resolved": "https://registry.npmjs.org/launch-editor/-/launch-editor-2.10.0.tgz", - "integrity": "sha512-D7dBRJo/qcGX9xlvt/6wUYzQxjh5G1RvZPgPv8vi4KRU99DVQL/oW7tnVOCCTm2HGeo3C5HvGE5Yrh6UBoZ0vA==", + "version": "2.11.1", + "resolved": "https://registry.npmjs.org/launch-editor/-/launch-editor-2.11.1.tgz", + "integrity": "sha512-SEET7oNfgSaB6Ym0jufAdCeo3meJVeCaaDyzRygy0xsp2BFKCprcfHljTq4QkzTLUxEKkFK6OK4811YM2oSrRg==", "license": "MIT", "dependencies": { - "picocolors": "^1.0.0", - "shell-quote": "^1.8.1" + "picocolors": "^1.1.1", + "shell-quote": "^1.8.3" } }, "node_modules/layout-base": { @@ -12090,12 +12161,16 @@ "license": "MIT" }, "node_modules/loader-runner": { - "version": "4.3.0", - "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.3.0.tgz", - "integrity": "sha512-3R/1M+yS3j5ou80Me59j7F9IMs4PXs3VqRrm0TU3AbKPxlmpoY1TNscJV/oGJXo8qCatFGTfDbY6W6ipGOYXfg==", + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-4.3.1.tgz", + "integrity": "sha512-IWqP2SCPhyVFTBtRcgMHdzlf9ul25NwaFx4wCEH/KjAXuuHY4yNjvPXsBokp8jCB936PyWRaPKUNh8NvylLp2Q==", "license": "MIT", "engines": { "node": ">=6.11.5" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" } }, "node_modules/loader-utils": { @@ -12113,14 +12188,14 @@ } }, "node_modules/local-pkg": { - "version": "1.1.1", - "resolved": "https://registry.npmjs.org/local-pkg/-/local-pkg-1.1.1.tgz", - "integrity": "sha512-WunYko2W1NcdfAFpuLUoucsgULmgDBRkdxHxWQ7mK0cQqwPiy8E1enjuRBrhLtZkB5iScJ1XIPdhVEFK8aOLSg==", + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/local-pkg/-/local-pkg-1.1.2.tgz", + "integrity": "sha512-arhlxbFRmoQHl33a0Zkle/YWlmNwoyt6QNZEIJcqNbdrsix5Lvc4HyyI3EnwxTYlZYc32EbYrQ8SzEZ7dqgg9A==", "license": "MIT", "dependencies": { "mlly": "^1.7.4", - "pkg-types": "^2.0.1", - "quansync": "^0.2.8" + "pkg-types": "^2.3.0", + "quansync": "^0.2.11" }, "engines": { "node": ">=14" @@ -12256,15 +12331,15 @@ } }, "node_modules/marked": { - "version": "15.0.11", - "resolved": "https://registry.npmjs.org/marked/-/marked-15.0.11.tgz", - "integrity": "sha512-1BEXAU2euRCG3xwgLVT1y0xbJEld1XOrmRJpUwRCcy7rxhSCwMrmEu9LXoPhHSCJG41V7YcQ2mjKRr5BA3ITIA==", + "version": "16.4.0", + "resolved": "https://registry.npmjs.org/marked/-/marked-16.4.0.tgz", + "integrity": "sha512-CTPAcRBq57cn3R8n3hwc2REddc28hjR7RzDXQ+lXLmMJYqn20BaI2cGw6QjgZGIgVfp2Wdfw4aMzgNteQ6qJgQ==", "license": "MIT", "bin": { "marked": "bin/marked.js" }, "engines": { - "node": ">= 18" + "node": ">= 20" } }, "node_modules/math-intrinsics": { @@ -12328,14 +12403,14 @@ } }, "node_modules/mermaid": { - "version": "11.6.0", - "resolved": "https://registry.npmjs.org/mermaid/-/mermaid-11.6.0.tgz", - "integrity": "sha512-PE8hGUy1LDlWIHWBP05SFdqUHGmRcCcK4IzpOKPE35eOw+G9zZgcnMpyunJVUEOgb//KBORPjysKndw8bFLuRg==", + "version": "11.12.0", + "resolved": "https://registry.npmjs.org/mermaid/-/mermaid-11.12.0.tgz", + "integrity": "sha512-ZudVx73BwrMJfCFmSSJT84y6u5brEoV8DOItdHomNLz32uBjNrelm7mg95X7g+C6UoQH/W6mBLGDEDv73JdxBg==", "license": "MIT", "dependencies": { - "@braintree/sanitize-url": "^7.0.4", - "@iconify/utils": "^2.1.33", - "@mermaid-js/parser": "^0.4.0", + "@braintree/sanitize-url": "^7.1.1", + "@iconify/utils": "^3.0.1", + "@mermaid-js/parser": "^0.6.2", "@types/d3": "^7.4.3", "cytoscape": "^3.29.3", "cytoscape-cose-bilkent": "^4.1.0", @@ -12343,31 +12418,18 @@ "d3": "^7.9.0", "d3-sankey": "^0.12.3", "dagre-d3-es": "7.0.11", - "dayjs": "^1.11.13", - "dompurify": "^3.2.4", - "katex": "^0.16.9", + "dayjs": "^1.11.18", + "dompurify": "^3.2.5", + "katex": "^0.16.22", "khroma": "^2.1.0", "lodash-es": "^4.17.21", - "marked": "^15.0.7", + "marked": "^16.2.1", "roughjs": "^4.6.6", "stylis": "^4.3.6", "ts-dedent": "^2.2.0", "uuid": "^11.1.0" } }, - "node_modules/mermaid/node_modules/uuid": { - "version": "11.1.0", - "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz", - "integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==", - "funding": [ - "https://github.com/sponsors/broofa", - "https://github.com/sponsors/ctavan" - ], - "license": "MIT", - "bin": { - "uuid": "dist/esm/bin/uuid" - } - }, "node_modules/methods": { "version": "1.1.2", "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz", @@ -12433,9 +12495,9 @@ } }, "node_modules/mini-css-extract-plugin": { - "version": "2.9.2", - "resolved": "https://registry.npmjs.org/mini-css-extract-plugin/-/mini-css-extract-plugin-2.9.2.tgz", - "integrity": "sha512-GJuACcS//jtq4kCtd5ii/M0SZf7OZRH+BxdqXZHaJfb8TJiVl+NgQRPwiYt2EuqeSkNydn/7vP+bcE27C5mb9w==", + "version": "2.9.4", + "resolved": "https://registry.npmjs.org/mini-css-extract-plugin/-/mini-css-extract-plugin-2.9.4.tgz", + "integrity": "sha512-ZWYT7ln73Hptxqxk2DxPU9MmapXRhxkJD6tkSR04dnQxm8BGu2hzgKLugK5yySD97u/8yy7Ma7E76k9ZdvtjkQ==", "license": "MIT", "dependencies": { "schema-utils": "^4.0.0", @@ -12501,15 +12563,15 @@ } }, "node_modules/mlly": { - "version": "1.7.4", - "resolved": "https://registry.npmjs.org/mlly/-/mlly-1.7.4.tgz", - "integrity": "sha512-qmdSIPC4bDJXgZTCR7XosJiNKySV7O215tsPtDN9iEO/7q/76b/ijtgRu/+epFXSJhijtTCCGp3DWS549P3xKw==", + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/mlly/-/mlly-1.8.0.tgz", + "integrity": "sha512-l8D9ODSRWLe2KHJSifWGwBqpTZXIXTeo8mlKjY+E2HAakaTeNpqAyBZ8GSqLzHgw4XmHmC8whvpjJNMbFZN7/g==", "license": "MIT", "dependencies": { - "acorn": "^8.14.0", - "pathe": "^2.0.1", - "pkg-types": "^1.3.0", - "ufo": "^1.5.4" + "acorn": "^8.15.0", + "pathe": "^2.0.3", + "pkg-types": "^1.3.1", + "ufo": "^1.6.1" } }, "node_modules/mlly/node_modules/confbox": { @@ -12630,9 +12692,9 @@ "license": "MIT" }, "node_modules/node-releases": { - "version": "2.0.19", - "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.19.tgz", - "integrity": "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==", + "version": "2.0.23", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.23.tgz", + "integrity": "sha512-cCmFDMSm26S6tQSDpBCg/NR8NENrVPhAJSf+XbxBG4rPFaaonlEoE9wHQmun+cls499TQGSb7ZyPBRlzgKfpeg==", "license": "MIT" }, "node_modules/normalize-path": { @@ -12690,9 +12752,9 @@ } }, "node_modules/nwsapi": { - "version": "2.2.20", - "resolved": "https://registry.npmjs.org/nwsapi/-/nwsapi-2.2.20.tgz", - "integrity": "sha512-/ieB+mDe4MrrKMT8z+mQL8klXydZWGR5Dowt4RAGKbJ3kIGEx3X4ljUo+6V73IXtUPWgfOlU5B9MlGxFO5T+cA==", + "version": "2.2.22", + "resolved": "https://registry.npmjs.org/nwsapi/-/nwsapi-2.2.22.tgz", + "integrity": "sha512-ujSMe1OWVn55euT1ihwCI1ZcAaAU3nxUiDwfDQldc51ZXaB9m2AyOn6/jh1BLe2t/G8xd6uKG1UBF2aZJeg2SQ==", "license": "MIT" }, "node_modules/object-assign": { @@ -12859,9 +12921,9 @@ } }, "node_modules/on-headers": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/on-headers/-/on-headers-1.0.2.tgz", - "integrity": "sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/on-headers/-/on-headers-1.1.0.tgz", + "integrity": "sha512-737ZY3yNnXy37FHkQxPzt4UZ2UWPWiCZWLvFZ4fu5cueciegX0zGPnrlY6bwRg4FdQOe9YU8MkmJwGhoMybl8A==", "license": "MIT", "engines": { "node": ">= 0.8" @@ -12998,9 +13060,9 @@ "license": "BlueOak-1.0.0" }, "node_modules/package-manager-detector": { - "version": "1.3.0", - "resolved": "https://registry.npmjs.org/package-manager-detector/-/package-manager-detector-1.3.0.tgz", - "integrity": "sha512-ZsEbbZORsyHuO00lY1kV3/t72yp6Ysay6Pd17ZAlNGuGwmWDLCJxFpRs0IzfXfj1o4icJOkUEioexFHzyPurSQ==", + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/package-manager-detector/-/package-manager-detector-1.4.1.tgz", + "integrity": "sha512-dSMiVLBEA4XaNJ0PRb4N5cV/SEP4BWrWZKBmfF+OUm2pQTiZ6DDkKeWaltwu3JRhLoy59ayIkJ00cx9K9CaYTg==", "license": "MIT" }, "node_modules/param-case": { @@ -13205,13 +13267,13 @@ } }, "node_modules/pkg-types": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-2.1.0.tgz", - "integrity": "sha512-wmJwA+8ihJixSoHKxZJRBQG1oY8Yr9pGLzRmSsNms0iNWyHHAlZCa7mmKiFR10YPZuz/2k169JiS/inOjBCZ2A==", + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-2.3.0.tgz", + "integrity": "sha512-SIqCzDRg0s9npO5XQ3tNZioRY1uK06lA41ynBC1YmFTmnY6FjUjVt6s4LoADmwoig1qqD0oK8h1p/8mlMx8Oig==", "license": "MIT", "dependencies": { - "confbox": "^0.2.1", - "exsolve": "^1.0.1", + "confbox": "^0.2.2", + "exsolve": "^1.0.7", "pathe": "^2.0.3" } }, @@ -13299,9 +13361,9 @@ } }, "node_modules/postcss": { - "version": "8.5.3", - "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.3.tgz", - "integrity": "sha512-dle9A3yYxlBSrt8Fu+IpjGT8SY8hN0mlaA6GY8t0P5PjIOZemULz/E2Bnm/2dcUOena75OTNkHI76uZBNUUq3A==", + "version": "8.5.6", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz", + "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==", "funding": [ { "type": "opencollective", @@ -13318,7 +13380,7 @@ ], "license": "MIT", "dependencies": { - "nanoid": "^3.3.8", + "nanoid": "^3.3.11", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" }, @@ -13746,9 +13808,19 @@ } }, "node_modules/postcss-js": { - "version": "4.0.1", - "resolved": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.0.1.tgz", - "integrity": "sha512-dDLF8pEO191hJMtlHFPRa8xsizHaM82MLfNkUHdUtVEV3tgTp5oj+8qbEqYM57SLfc74KSbw//4SeJma2LRVIw==", + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.1.0.tgz", + "integrity": "sha512-oIAOTqgIo7q2EOwbhb8UalYePMvYoIeRY2YKntdpFQXNosSu3vLrniGgmH9OKs/qAkfoj5oB3le/7mINW1LCfw==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], "license": "MIT", "dependencies": { "camelcase-css": "^2.0.1" @@ -13756,10 +13828,6 @@ "engines": { "node": "^12 || ^14 || >= 16" }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/postcss/" - }, "peerDependencies": { "postcss": "^8.4.21" } @@ -13784,65 +13852,6 @@ "postcss": "^8.2" } }, - "node_modules/postcss-load-config": { - "version": "4.0.2", - "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-4.0.2.tgz", - "integrity": "sha512-bSVhyJGL00wMVoPUzAVAnbEoWyqRxkjv64tUl427SKnPrENtq6hJwUojroMz2VB+Q1edmi4IfrAPpami5VVgMQ==", - "funding": [ - { - "type": "opencollective", - "url": "https://opencollective.com/postcss/" - }, - { - "type": "github", - "url": "https://github.com/sponsors/ai" - } - ], - "license": "MIT", - "dependencies": { - "lilconfig": "^3.0.0", - "yaml": "^2.3.4" - }, - "engines": { - "node": ">= 14" - }, - "peerDependencies": { - "postcss": ">=8.0.9", - "ts-node": ">=9.0.0" - }, - "peerDependenciesMeta": { - "postcss": { - "optional": true - }, - "ts-node": { - "optional": true - } - } - }, - "node_modules/postcss-load-config/node_modules/lilconfig": { - "version": "3.1.3", - "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz", - "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==", - "license": "MIT", - "engines": { - "node": ">=14" - }, - "funding": { - "url": "https://github.com/sponsors/antonk52" - } - }, - "node_modules/postcss-load-config/node_modules/yaml": { - "version": "2.7.1", - "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.7.1.tgz", - "integrity": "sha512-10ULxpnOCQXxJvBgxsn9ptjq6uviG/htZKk9veJGhlqn3w/DxQ631zFF+nlQXLwmImeS5amR2dl2U8sg6U9jsQ==", - "license": "ISC", - "bin": { - "yaml": "bin.mjs" - }, - "engines": { - "node": ">= 14" - } - }, "node_modules/postcss-loader": { "version": "6.2.1", "resolved": "https://registry.npmjs.org/postcss-loader/-/postcss-loader-6.2.1.tgz", @@ -14528,15 +14537,6 @@ "postcss": "^8.2.15" } }, - "node_modules/postcss-svgo/node_modules/commander": { - "version": "7.2.0", - "resolved": "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz", - "integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==", - "license": "MIT", - "engines": { - "node": ">= 10" - } - }, "node_modules/postcss-svgo/node_modules/css-tree": { "version": "1.1.3", "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-1.1.3.tgz", @@ -14785,9 +14785,9 @@ } }, "node_modules/quansync": { - "version": "0.2.10", - "resolved": "https://registry.npmjs.org/quansync/-/quansync-0.2.10.tgz", - "integrity": "sha512-t41VRkMYbkHyCYmOvx/6URnN80H7k4X0lLdBMGsz+maAwrJQYB1djpV6vHrQIBE0WBSGqhtEHrK9U3DWWH8v7A==", + "version": "0.2.11", + "resolved": "https://registry.npmjs.org/quansync/-/quansync-0.2.11.tgz", + "integrity": "sha512-AifT7QEbW9Nri4tAwR5M/uzpBuqfZf+zwaEM/QkzEjj7NBuFD2rBuy0K3dE+8wltbezDV7JMA0WfnCPYRSYbXA==", "funding": [ { "type": "individual", @@ -15214,9 +15214,9 @@ "license": "MIT" }, "node_modules/regenerate-unicode-properties": { - "version": "10.2.0", - "resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.0.tgz", - "integrity": "sha512-DqHn3DwbmmPVzeKj9woBadqmXxLvQoQIwu7nopMc72ztvxVmVk2SBhSnx67zuye5TP+lJsb/TBQsjLKhnDf3MA==", + "version": "10.2.2", + "resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.2.tgz", + "integrity": "sha512-m03P+zhBeQd1RGnYxrGyDAPpWX/epKirLrp8e3qevZdVkKtnCrjjWczIbYc8+xd6vcTStVlqfycTx1KR4LOr0g==", "license": "MIT", "dependencies": { "regenerate": "^1.4.2" @@ -15258,17 +15258,17 @@ } }, "node_modules/regexpu-core": { - "version": "6.2.0", - "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-6.2.0.tgz", - "integrity": "sha512-H66BPQMrv+V16t8xtmq+UC0CBpiTBA60V8ibS1QVReIp8T1z8hwFxqcGzm9K6lgsN7sB5edVH8a+ze6Fqm4weA==", + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-6.4.0.tgz", + "integrity": "sha512-0ghuzq67LI9bLXpOX/ISfve/Mq33a4aFRzoQYhnnok1JOFpmE/A2TBGkNVenOGEeSBCjIiWcc6MVOG5HEQv0sA==", "license": "MIT", "dependencies": { "regenerate": "^1.4.2", - "regenerate-unicode-properties": "^10.2.0", + "regenerate-unicode-properties": "^10.2.2", "regjsgen": "^0.8.0", - "regjsparser": "^0.12.0", + "regjsparser": "^0.13.0", "unicode-match-property-ecmascript": "^2.0.0", - "unicode-match-property-value-ecmascript": "^2.1.0" + "unicode-match-property-value-ecmascript": "^2.2.1" }, "engines": { "node": ">=4" @@ -15281,29 +15281,17 @@ "license": "MIT" }, "node_modules/regjsparser": { - "version": "0.12.0", - "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.12.0.tgz", - "integrity": "sha512-cnE+y8bz4NhMjISKbgeVJtqNbtf5QpjZP+Bslo+UqkIt9QPnX9q095eiRRASJG1/tz6dlNr6Z5NsBiWYokp6EQ==", + "version": "0.13.0", + "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.13.0.tgz", + "integrity": "sha512-NZQZdC5wOE/H3UT28fVGL+ikOZcEzfMGk/c3iN9UGxzWHMa1op7274oyiUVrAG4B2EuFhus8SvkaYnhvW92p9Q==", "license": "BSD-2-Clause", "dependencies": { - "jsesc": "~3.0.2" + "jsesc": "~3.1.0" }, "bin": { "regjsparser": "bin/parser" } }, - "node_modules/regjsparser/node_modules/jsesc": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.0.2.tgz", - "integrity": "sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==", - "license": "MIT", - "bin": { - "jsesc": "bin/jsesc" - }, - "engines": { - "node": ">=6" - } - }, "node_modules/relateurl": { "version": "0.2.7", "resolved": "https://registry.npmjs.org/relateurl/-/relateurl-0.2.7.tgz", @@ -15752,9 +15740,9 @@ } }, "node_modules/schema-utils": { - "version": "4.3.2", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.3.2.tgz", - "integrity": "sha512-Gn/JaSk/Mt9gYubxTtSn/QCV4em9mpAPiR1rqy/Ocu19u/G9J5WWdNoUT4SiV6mFC3y6cxyFcFwdzPM3FgxGAQ==", + "version": "4.3.3", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.3.3.tgz", + "integrity": "sha512-eflK8wEtyOE6+hsaRVPxvUKYCpRgzLqDTb8krvAsRIwOGlHoSgYLgBXoubGgLd2fT41/OUYdb48v4k4WWHQurA==", "license": "MIT", "dependencies": { "@types/json-schema": "^7.0.9", @@ -15824,9 +15812,9 @@ } }, "node_modules/semver": { - "version": "7.7.2", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.2.tgz", - "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==", + "version": "7.7.3", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.3.tgz", + "integrity": "sha512-SdsKMrI9TdgjdweUSR9MweHA4EJ8YxHn8DFaDisvhVlUOe4BF1tLD7GAj0lIqWVl+dPb/rExr0Btby5loQm20Q==", "license": "ISC", "bin": { "semver": "bin/semver.js" @@ -16059,9 +16047,9 @@ } }, "node_modules/shell-quote": { - "version": "1.8.2", - "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.8.2.tgz", - "integrity": "sha512-AzqKpGKjrj7EM6rKVQEPpB288oCfnrEIuyoT9cyF4nmGa7V8Zk6f7RRqYisX8X9m+Q7bd632aZW4ky7EhbQztA==", + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.8.3.tgz", + "integrity": "sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw==", "license": "MIT", "engines": { "node": ">= 0.4" @@ -16199,6 +16187,15 @@ "websocket-driver": "^0.7.4" } }, + "node_modules/sockjs/node_modules/uuid": { + "version": "8.3.2", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz", + "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==", + "license": "MIT", + "bin": { + "uuid": "dist/bin/uuid" + } + }, "node_modules/source-list-map": { "version": "2.0.1", "resolved": "https://registry.npmjs.org/source-list-map/-/source-list-map-2.0.1.tgz", @@ -16206,12 +16203,12 @@ "license": "MIT" }, "node_modules/source-map": { - "version": "0.7.4", - "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.4.tgz", - "integrity": "sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA==", + "version": "0.7.6", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.7.6.tgz", + "integrity": "sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==", "license": "BSD-3-Clause", "engines": { - "node": ">= 8" + "node": ">= 12" } }, "node_modules/source-map-js": { @@ -16449,6 +16446,19 @@ "node": ">= 0.8" } }, + "node_modules/stop-iteration-iterator": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/stop-iteration-iterator/-/stop-iteration-iterator-1.1.0.tgz", + "integrity": "sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "internal-slot": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + } + }, "node_modules/string_decoder": { "version": "1.3.0", "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", @@ -16764,9 +16774,9 @@ } }, "node_modules/sucrase/node_modules/brace-expansion": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz", - "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==", + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz", + "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==", "license": "MIT", "dependencies": { "balanced-match": "^1.0.0" @@ -17024,9 +17034,9 @@ "license": "MIT" }, "node_modules/tailwindcss": { - "version": "3.4.17", - "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.17.tgz", - "integrity": "sha512-w33E2aCvSDP0tW9RZuNXadXlkHXqFzSkQew/aIa2i/Sj8fThxwovwlXHSPXTbAHwEIhBFXAedUhP2tueAKP8Og==", + "version": "3.4.18", + "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.18.tgz", + "integrity": "sha512-6A2rnmW5xZMdw11LYjhcI5846rt9pbLSabY5XPxo+XWdxwZaFEn47Go4NzFiHu9sNNmr/kXivP1vStfvMaK1GQ==", "license": "MIT", "dependencies": { "@alloc/quick-lru": "^5.2.0", @@ -17037,7 +17047,7 @@ "fast-glob": "^3.3.2", "glob-parent": "^6.0.2", "is-glob": "^4.0.3", - "jiti": "^1.21.6", + "jiti": "^1.21.7", "lilconfig": "^3.1.3", "micromatch": "^4.0.8", "normalize-path": "^3.0.0", @@ -17046,7 +17056,7 @@ "postcss": "^8.4.47", "postcss-import": "^15.1.0", "postcss-js": "^4.0.1", - "postcss-load-config": "^4.0.2", + "postcss-load-config": "^4.0.2 || ^5.0 || ^6.0", "postcss-nested": "^6.2.0", "postcss-selector-parser": "^6.1.2", "resolve": "^1.22.8", @@ -17072,13 +17082,73 @@ "url": "https://github.com/sponsors/antonk52" } }, + "node_modules/tailwindcss/node_modules/postcss-load-config": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-6.0.1.tgz", + "integrity": "sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "lilconfig": "^3.1.1" + }, + "engines": { + "node": ">= 18" + }, + "peerDependencies": { + "jiti": ">=1.21.0", + "postcss": ">=8.0.9", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "jiti": { + "optional": true + }, + "postcss": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/tailwindcss/node_modules/yaml": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.1.tgz", + "integrity": "sha512-lcYcMxX2PO9XMGvAJkJ3OsNMw+/7FKes7/hgerGUYWIoWu5j/+YQqcZr5JnPZWzOsEBgMbSbiSTn/dv/69Mkpw==", + "license": "ISC", + "optional": true, + "peer": true, + "bin": { + "yaml": "bin.mjs" + }, + "engines": { + "node": ">= 14.6" + } + }, "node_modules/tapable": { - "version": "2.2.1", - "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz", - "integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==", + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.0.tgz", + "integrity": "sha512-g9ljZiwki/LfxmQADO3dEY1CbpmXT5Hm2fJ+QaGKwSXUylMybePR7/67YW7jOrrvjEgL1Fmz5kzyAjWVWLlucg==", "license": "MIT", "engines": { "node": ">=6" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" } }, "node_modules/temp-dir": { @@ -17137,13 +17207,13 @@ } }, "node_modules/terser": { - "version": "5.39.0", - "resolved": "https://registry.npmjs.org/terser/-/terser-5.39.0.tgz", - "integrity": "sha512-LBAhFyLho16harJoWMg/nZsQYgTrg5jXOn2nCYjRUcZZEdE3qa2zb8QEDRUGVZBW4rlazf2fxkg8tztybTaqWw==", + "version": "5.44.0", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.44.0.tgz", + "integrity": "sha512-nIVck8DK+GM/0Frwd+nIhZ84pR/BX7rmXMfYwyg+Sri5oGVE99/E3KvXqpC2xHFxyqXyGHTKBSioxxplrO4I4w==", "license": "BSD-2-Clause", "dependencies": { "@jridgewell/source-map": "^0.3.3", - "acorn": "^8.8.2", + "acorn": "^8.15.0", "commander": "^2.20.0", "source-map-support": "~0.5.20" }, @@ -17527,9 +17597,9 @@ } }, "node_modules/typescript": { - "version": "4.9.5", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz", - "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==", + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", "license": "Apache-2.0", "peer": true, "bin": { @@ -17537,7 +17607,7 @@ "tsserver": "bin/tsserver" }, "engines": { - "node": ">=4.2.0" + "node": ">=14.17" } }, "node_modules/ufo": { @@ -17571,9 +17641,9 @@ "license": "MIT" }, "node_modules/undici-types": { - "version": "6.21.0", - "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz", - "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==", + "version": "7.14.0", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.14.0.tgz", + "integrity": "sha512-QQiYxHuyZ9gQUIrmPo3IA+hUl4KYk8uSA7cHrcKd/l3p1OTpZcM0Tbp9x7FAtXdAYhlasd60ncPpgu6ihG6TOA==", "license": "MIT" }, "node_modules/unicode-canonical-property-names-ecmascript": { @@ -17599,18 +17669,18 @@ } }, "node_modules/unicode-match-property-value-ecmascript": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.0.tgz", - "integrity": "sha512-4IehN3V/+kkr5YeSSDDQG8QLqO26XpL2XP3GQtqwlT/QYSECAwFztxVHjlbh0+gjJ3XmNLS0zDsbgs9jWKExLg==", + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-2.2.1.tgz", + "integrity": "sha512-JQ84qTuMg4nVkx8ga4A16a1epI9H6uTXAknqxkGF/aFfRLw1xC/Bp24HNLaZhHSkWd3+84t8iXnp1J0kYcZHhg==", "license": "MIT", "engines": { "node": ">=4" } }, "node_modules/unicode-property-aliases-ecmascript": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.1.0.tgz", - "integrity": "sha512-6t3foTQI9qne+OZoVQB/8x8rk2k1eVy1gRXhV3oFQ5T6R1dqQ1xtin3XqSlx3+ATBkliTaR/hHyJBm+LVPNM8w==", + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-2.2.0.tgz", + "integrity": "sha512-hpbDzxUY9BFwX+UeBnxv3Sh1q7HFxj48DTmXchNgRa46lO8uj3/1iEn3MiNUYTg1g9ctIqXCCERn8gYZhHC5lQ==", "license": "MIT", "engines": { "node": ">=4" @@ -17748,12 +17818,16 @@ } }, "node_modules/uuid": { - "version": "8.3.2", - "resolved": "https://registry.npmjs.org/uuid/-/uuid-8.3.2.tgz", - "integrity": "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg==", + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz", + "integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==", + "funding": [ + "https://github.com/sponsors/broofa", + "https://github.com/sponsors/ctavan" + ], "license": "MIT", "bin": { - "uuid": "dist/bin/uuid" + "uuid": "dist/esm/bin/uuid" } }, "node_modules/v8-to-istanbul": { @@ -17866,9 +17940,9 @@ } }, "node_modules/watchpack": { - "version": "2.4.2", - "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.2.tgz", - "integrity": "sha512-TnbFSbcOCcDgjZ4piURLCbJ3nJhznVh9kw6F6iokjiFPl8ONxe9A6nMDVXDiNbrSfLILs6vB07F7wLBrwPYzJw==", + "version": "2.4.4", + "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.4.tgz", + "integrity": "sha512-c5EGNOiyxxV5qmTtAB7rbiXxi1ooX1pQKMLX/MIabJjRA0SJBQOjKF+KSVfHkr9U1cADPon0mRiVe/riyaiDUA==", "license": "MIT", "dependencies": { "glob-to-regexp": "^0.4.1", @@ -17897,21 +17971,22 @@ } }, "node_modules/webpack": { - "version": "5.99.8", - "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.99.8.tgz", - "integrity": "sha512-lQ3CPiSTpfOnrEGeXDwoq5hIGzSjmwD72GdfVzF7CQAI7t47rJG9eDWvcEkEn3CUQymAElVvDg3YNTlCYj+qUQ==", + "version": "5.102.1", + "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.102.1.tgz", + "integrity": "sha512-7h/weGm9d/ywQ6qzJ+Xy+r9n/3qgp/thalBbpOi5i223dPXKi04IBtqPN9nTd+jBc7QKfvDbaBnFipYp4sJAUQ==", "license": "MIT", "dependencies": { "@types/eslint-scope": "^3.7.7", - "@types/estree": "^1.0.6", + "@types/estree": "^1.0.8", "@types/json-schema": "^7.0.15", "@webassemblyjs/ast": "^1.14.1", "@webassemblyjs/wasm-edit": "^1.14.1", "@webassemblyjs/wasm-parser": "^1.14.1", - "acorn": "^8.14.0", - "browserslist": "^4.24.0", + "acorn": "^8.15.0", + "acorn-import-phases": "^1.0.3", + "browserslist": "^4.26.3", "chrome-trace-event": "^1.0.2", - "enhanced-resolve": "^5.17.1", + "enhanced-resolve": "^5.17.3", "es-module-lexer": "^1.2.1", "eslint-scope": "5.1.1", "events": "^3.2.0", @@ -17921,11 +17996,11 @@ "loader-runner": "^4.2.0", "mime-types": "^2.1.27", "neo-async": "^2.6.2", - "schema-utils": "^4.3.2", - "tapable": "^2.1.1", + "schema-utils": "^4.3.3", + "tapable": "^2.3.0", "terser-webpack-plugin": "^5.3.11", - "watchpack": "^2.4.1", - "webpack-sources": "^3.2.3" + "watchpack": "^2.4.4", + "webpack-sources": "^3.3.3" }, "bin": { "webpack": "bin/webpack.js" @@ -18026,9 +18101,9 @@ } }, "node_modules/webpack-dev-server/node_modules/ws": { - "version": "8.18.2", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.2.tgz", - "integrity": "sha512-DMricUmwGZUVr++AEAe2uiVM7UoO9MAVZMDu05UQOaUII0lp+zOzLLU4Xqh/JvTqklB1T4uELaaPBKyjE1r4fQ==", + "version": "8.18.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", + "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", "license": "MIT", "engines": { "node": ">=10.0.0" @@ -18085,9 +18160,9 @@ } }, "node_modules/webpack-sources": { - "version": "3.2.3", - "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.2.3.tgz", - "integrity": "sha512-/DyMEOrDgLKKIG0fmvtz+4dUX/3Ghozwgm6iPp8KRhvn+eQf9+Q7GWxVNMk3+uCPWfdXYC4ExGBckIXdFEfH1w==", + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.3.3.tgz", + "integrity": "sha512-yd1RBzSGanHkitROoPFd6qsrxt+oFhg/129YzheDGqeustzX0vTZJZsSsQjVQC4yzBQ56K55XU8gaNCtIzOnTg==", "license": "MIT", "engines": { "node": ">=10.13.0" @@ -18419,6 +18494,7 @@ "version": "0.8.0-beta.0", "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.8.0-beta.0.tgz", "integrity": "sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==", + "deprecated": "The work that was done in this beta branch won't be included in future versions", "license": "BSD-3-Clause", "dependencies": { "whatwg-url": "^7.0.0" diff --git a/frontend/public/config.js b/frontend/public/config.js index 3b9c90b..7e7494f 100644 --- a/frontend/public/config.js +++ b/frontend/public/config.js @@ -1,16 +1,16 @@ window.__APP_CONFIG__ = { - "_comment": "Dynamic base path configuration - set basePath to override auto-detection", - "basePath": "/video_query", - "domain": "https://ai-sandbox.oliver.solutions", + "_comment": "PRODUCTION CONFIG - Dynamic base path configuration - set basePath to override auto-detection", + "basePath": "/video-query", + "domain": "https://brandtechsandbox.oliver.solutions", "msal": { "clientId": "9079054c-9620-4757-a256-23413042f1ef", "authority": "https://login.microsoftonline.com/e519c2e6-bc6d-4fdf-8d9c-923c2f002385", - "redirectUri": "https://ai-sandbox.oliver.solutions/video_query/", - "postLogoutRedirectUri": "https://ai-sandbox.oliver.solutions/video_query/", + "redirectUri": "https://brandtechsandbox.oliver.solutions/video-query/", + "postLogoutRedirectUri": "https://brandtechsandbox.oliver.solutions/video-query/", "tenantId": "e519c2e6-bc6d-4fdf-8d9c-923c2f002385" }, "api": { - "videoProcessingEndpoint": "https://ai-sandbox.oliver.solutions/video_query_back/api/process", - "chunkedUploadEndpoint": "https://ai-sandbox.oliver.solutions/video_query_back" + "videoProcessingEndpoint": "https://brandtechsandbox.oliver.solutions/video_query_back/api/process", + "chunkedUploadEndpoint": "https://brandtechsandbox.oliver.solutions/video_query_back" } }; \ No newline at end of file diff --git a/frontend/public/config.json b/frontend/public/config.json index 7262b50..d0cbc90 100644 --- a/frontend/public/config.json +++ b/frontend/public/config.json @@ -1,16 +1,16 @@ { - "_comment": "Dynamic base path configuration - set basePath to override auto-detection", - "basePath": "/video_query", - "domain": "https://ai-sandbox.oliver.solutions", + "_comment": "LOCAL DEVELOPMENT CONFIG - Points to localhost backend on port 5010", + "basePath": "/", + "domain": "http://localhost:3000", "msal": { "clientId": "9079054c-9620-4757-a256-23413042f1ef", "authority": "https://login.microsoftonline.com/e519c2e6-bc6d-4fdf-8d9c-923c2f002385", - "redirectUri": "https://ai-sandbox.oliver.solutions/video_query/", - "postLogoutRedirectUri": "https://ai-sandbox.oliver.solutions/video_query/", + "redirectUri": "http://localhost:3000/", + "postLogoutRedirectUri": "http://localhost:3000/", "tenantId": "e519c2e6-bc6d-4fdf-8d9c-923c2f002385" }, "api": { - "videoProcessingEndpoint": "https://ai-sandbox.oliver.solutions/video_query_back/api/process", - "chunkedUploadEndpoint": "https://ai-sandbox.oliver.solutions/video_query_back" + "videoProcessingEndpoint": "http://localhost:5010/api/process", + "chunkedUploadEndpoint": "http://localhost:5010" } } \ No newline at end of file diff --git a/frontend/public/index.html b/frontend/public/index.html index 8a594b6..b2fc74b 100644 --- a/frontend/public/index.html +++ b/frontend/public/index.html @@ -38,7 +38,11 @@ } })(); + + + + diff --git a/frontend/src/App.js b/frontend/src/App.js index cbfbcae..553afaf 100644 --- a/frontend/src/App.js +++ b/frontend/src/App.js @@ -1,4 +1,4 @@ -import React, { useState } from 'react'; +import React, { useState, useEffect } from 'react'; import { authApiClient } from './auth/authApiClient'; import { AuthenticatedTemplate, UnauthenticatedTemplate, useMsal } from '@azure/msal-react'; import { InteractionStatus } from '@azure/msal-browser'; @@ -6,11 +6,22 @@ import AuthenticatedContent from './components/AuthenticatedContent'; import Login from './components/Login'; import ChunkedUploader from './utils/chunkedUploader'; import { loginRequest } from './auth/authConfig'; -import { getApiConfig } from './utils/configLoader'; +import { loadConfig, getApiConfig } from './utils/configLoader'; -function App() { - // MSAL authentication hook +// Component that uses MSAL hooks (only when auth is enabled) +function AppWithAuth() { const { instance, inProgress, accounts } = useMsal(); + return ; +} + +// Component without auth dependencies +function AppWithoutAuth() { + return ; +} + +// Main app content component that receives auth props +function AppContent({ instance, inProgress, accounts, authDisabled }) { + const [selectedFile, setSelectedFile] = useState(null); const [fileName, setFileName] = useState(''); const [mode, setMode] = useState('meeting_summary'); @@ -21,46 +32,94 @@ function App() { const [isLoading, setIsLoading] = useState(false); const [error, setError] = useState(''); const [uploadProgress, setUploadProgress] = useState(0); - const [authChecked, setAuthChecked] = useState(false); + const [chunksProcessed, setChunksProcessed] = useState(0); + const [totalChunks, setTotalChunks] = useState(0); + const [authChecked, setAuthChecked] = useState(authDisabled); // Skip auth check if disabled + const [configLoaded, setConfigLoaded] = useState(false); + + // Queue state for multiple files + const [uploadQueue, setUploadQueue] = useState([]); + const [currentFileIndex, setCurrentFileIndex] = useState(-1); + const [isProcessingQueue, setIsProcessingQueue] = useState(false); - const handleVideoSelect = (file) => { - setSelectedFile(file); - setFileName(file.name); + // Load configuration when authentication is disabled + useEffect(() => { + if (authDisabled) { + loadConfig() + .then(() => { + console.log('Configuration loaded successfully'); + setConfigLoaded(true); + }) + .catch(error => { + console.error('Failed to load configuration:', error); + setError('Failed to load application configuration'); + }); + } else { + // Configuration is loaded by AuthProvider when auth is enabled + setConfigLoaded(true); + } + }, [authDisabled]); + + const handleVideoSelect = (files) => { + // Handle both single file and multiple files + const fileArray = Array.isArray(files) ? files : [files]; + + // Create queue items + const queueItems = fileArray.map((file, index) => ({ + id: Date.now() + index, + file: file, + fileName: file.name, + status: 'queued', // queued, processing, completed, failed, cancelled + progress: 0, + result: null, + error: null, + processingTime: null, + abortController: new AbortController() // For cancellation support + })); + + setUploadQueue(prev => [...prev, ...queueItems]); setError(''); }; - const handleProcessVideo = async () => { - // Validation - if (!selectedFile) { - setError('Please select a video file first'); + // Process a single file from the queue + const processSingleFile = async (queueItem) => { + const fileId = queueItem.id; + const file = queueItem.file; + const abortSignal = queueItem.abortController.signal; + + // Update status to processing + setUploadQueue(prev => prev.map(item => + item.id === fileId ? { ...item, status: 'processing', progress: 0 } : item + )); + + const startTime = Date.now(); + + // Check if already aborted + if (abortSignal.aborted) { + setUploadQueue(prev => prev.map(item => + item.id === fileId ? { ...item, status: 'cancelled' } : item + )); return; } - - if (!prompt.trim()) { - setError('Please enter a prompt'); - return; - } - - setError(''); - setIsLoading(true); - setResult(''); - setUploadProgress(0); - + try { - const fileSize = selectedFile.size; + const fileSize = file.size; const fileSizeMB = fileSize / (1024 * 1024); let response; - - console.log(`Starting upload of ${selectedFile.name} (${fileSizeMB.toFixed(2)} MB)`); - + + console.log(`Starting upload of ${file.name} (${fileSizeMB.toFixed(2)} MB)`); + // Always use chunked upload regardless of file size console.log('Using chunked upload for all files'); - + // Create chunked uploader with runtime config const apiConfigForUpload = getApiConfig(); - const uploader = new ChunkedUploader(selectedFile, (progress) => { + const uploader = new ChunkedUploader(file, (progress) => { console.log(`Upload progress: ${progress}%`); - setUploadProgress(progress); + // Update queue item progress + setUploadQueue(prev => prev.map(item => + item.id === fileId ? { ...item, progress } : item + )); }, apiConfigForUpload.chunkedUploadEndpoint); // Variable to store upload result @@ -98,35 +157,194 @@ function App() { headers: { 'Content-Type': 'application/json' }, - timeout: 3600000 // 60 minutes timeout + timeout: 3600000, // 60 minutes timeout + signal: abortSignal // Support cancellation } ); // Handle success with additional error checking if (response && response.data && response.data.success) { - console.log('Processing successful, setting result'); - setResult(response.data.content); + console.log('Processing successful for', file.name); + const processingTime = ((Date.now() - startTime) / 1000).toFixed(2); + + // Update queue item as completed + setUploadQueue(prev => prev.map(item => + item.id === fileId ? { + ...item, + status: 'completed', + progress: 100, + result: response.data.content, + processingTime: `${processingTime}s` + } : item + )); } else { const errorMessage = response?.data?.message || 'Processing failed'; console.error('Processing failed:', errorMessage); - setError(errorMessage); + + // Update queue item as failed + setUploadQueue(prev => prev.map(item => + item.id === fileId ? { + ...item, + status: 'failed', + error: errorMessage + } : item + )); } } catch (err) { console.error('Error processing video:', err); - setError( - err.response?.data?.message || - 'Failed to process the video. Please try again or use a shorter video.' - ); - } finally { - setIsLoading(false); + + // Check if error is due to cancellation + if (err.name === 'CanceledError' || err.code === 'ERR_CANCELED' || abortSignal.aborted) { + console.log('Video processing was cancelled by user'); + setUploadQueue(prev => prev.map(item => + item.id === fileId ? { + ...item, + status: 'cancelled', + error: 'Processing cancelled by user' + } : item + )); + return; + } + + const errorMessage = err.response?.data?.message || + 'Failed to process the video. Please try again or use a shorter video.'; + + // Update queue item as failed + setUploadQueue(prev => prev.map(item => + item.id === fileId ? { + ...item, + status: 'failed', + error: errorMessage + } : item + )); } }; + + // Process all files in queue with parallel processing + const handleProcessQueue = async () => { + // Validation + if (uploadQueue.length === 0) { + setError('Please add video files to the queue first'); + return; + } + + if (!prompt.trim()) { + setError('Please enter a prompt'); + return; + } + + if (!configLoaded) { + setError('Configuration not loaded yet. Please wait a moment and try again.'); + return; + } + + setError(''); + setIsProcessingQueue(true); + + // Parallel processing with max 2 concurrent videos (safe for API rate limits) + const MAX_PARALLEL = 2; + const queuedItems = uploadQueue.filter(item => + item.status === 'queued' || item.status === 'cancelled' + ); + + console.log(`Starting parallel processing of ${queuedItems.length} videos (max ${MAX_PARALLEL} concurrent)`); + + // Process in batches + for (let i = 0; i < queuedItems.length; i += MAX_PARALLEL) { + const batch = queuedItems.slice(i, i + MAX_PARALLEL); + console.log(`Processing batch: ${batch.map(item => item.fileName).join(', ')}`); + + // Process batch in parallel using Promise.allSettled + // allSettled ensures all promises complete even if some fail + await Promise.allSettled( + batch.map(queueItem => processSingleFile(queueItem)) + ); + + console.log(`Batch completed`); + } + + setIsProcessingQueue(false); + setCurrentFileIndex(-1); + console.log('All videos processed'); + }; + + // Cancel/Stop processing for a specific file + const handleCancelProcessing = (fileId) => { + const item = uploadQueue.find(q => q.id === fileId); + if (item && item.abortController) { + console.log(`Cancelling processing for: ${item.fileName}`); + item.abortController.abort(); + // Status will be updated in processSingleFile's catch block + } + }; + + // Retry a cancelled or failed file + const handleRetryProcessing = async (fileId) => { + console.log(`Retrying file: ${fileId}`); + + // Reset the file status and create new abort controller + setUploadQueue(prev => prev.map(item => + item.id === fileId ? { + ...item, + status: 'queued', + error: null, + progress: 0, + abortController: new AbortController() + } : item + )); + + // Start processing this specific file + const item = uploadQueue.find(q => q.id === fileId); + if (item) { + // Create updated item with new abort controller + const updatedItem = { + ...item, + status: 'queued', + error: null, + progress: 0, + abortController: new AbortController() + }; + await processSingleFile(updatedItem); + } + }; + + // Remove file from queue completely + const handleRemoveFromQueue = (fileId) => { + const item = uploadQueue.find(q => q.id === fileId); + + // If currently processing, cancel it first + if (item && item.status === 'processing' && item.abortController) { + item.abortController.abort(); + } + + // Remove from queue + setUploadQueue(prev => prev.filter(item => item.id !== fileId)); + }; + + // Clear entire queue + const handleClearQueue = () => { + // Cancel all processing items + uploadQueue.forEach(item => { + if (item.status === 'processing' && item.abortController) { + item.abortController.abort(); + } + }); + + setUploadQueue([]); + setCurrentFileIndex(-1); + setError(''); + }; const resetForm = () => { setSelectedFile(null); setFileName(''); setResult(''); setError(''); + setChunksProcessed(0); + setTotalChunks(0); + setUploadQueue([]); + setCurrentFileIndex(-1); + setIsProcessingQueue(false); }; // Handle login @@ -150,6 +368,12 @@ function App() { // Check for token in URL hash (from implicit flow) and handle auth status React.useEffect(() => { + // Skip auth check if authentication is disabled + if (authDisabled) { + setAuthChecked(true); + return; + } + const checkAuthStatus = async () => { try { // Check if we were redirected here due to token expiration @@ -320,7 +544,7 @@ function App() { }; checkAuthStatus(); - }, [instance, inProgress, accounts]); + }, [instance, inProgress, accounts, authDisabled]); // Check if we have a manually stored token (from implicit flow) const isManuallyAuthenticated = () => { @@ -351,7 +575,7 @@ function App() {
{/* Show loading while auth is being checked */} - {!authChecked || inProgress === InteractionStatus.Login ? ( + {!authChecked || (!authDisabled && inProgress === InteractionStatus.Login) ? (
Loading... @@ -359,9 +583,9 @@ function App() {

Verifying authentication status...

) : ( - // Check both MSAL auth and our manual token auth - (accounts.length > 0 || isManuallyAuthenticated()) ? ( - // User is authenticated - show the application + // If auth is disabled, always show the app. Otherwise check authentication + (authDisabled || accounts.length > 0 || isManuallyAuthenticated()) ? ( + // User is authenticated or auth is disabled - show the application ) : ( // User is not authenticated - show login @@ -388,4 +621,15 @@ function App() { ); } +// Main App component that decides which version to use +function App() { + const authDisabled = process.env.REACT_APP_DISABLE_AUTH === 'true'; + + if (authDisabled) { + return ; + } else { + return ; + } +} + export default App; \ No newline at end of file diff --git a/frontend/src/auth/AuthProvider.js b/frontend/src/auth/AuthProvider.js index 01d7bc7..540857c 100644 --- a/frontend/src/auth/AuthProvider.js +++ b/frontend/src/auth/AuthProvider.js @@ -105,9 +105,19 @@ export const AuthProvider = ({ children }) => { const [isInitialized, setIsInitialized] = useState(false); const [initError, setInitError] = useState(null); + // Check if authentication is disabled + const authDisabled = process.env.REACT_APP_DISABLE_AUTH === 'true'; + // Initialize MSAL on component mount useEffect(() => { const initialize = async () => { + // Skip MSAL initialization if auth is disabled + if (authDisabled) { + console.log("AuthProvider: Authentication disabled, skipping MSAL initialization"); + setIsInitialized(true); + return; + } + try { console.log("AuthProvider: Starting initialization..."); msalInstance = await createMsalInstance(); @@ -121,7 +131,7 @@ export const AuthProvider = ({ children }) => { }; initialize(); - }, []); + }, [authDisabled]); // Show loading until MSAL is initialized if (!isInitialized) { @@ -150,6 +160,11 @@ export const AuthProvider = ({ children }) => { ); } + // If auth is disabled, render children directly without MSAL provider + if (authDisabled) { + return children; + } + // Only render MSAL provider if instance was created successfully if (!msalInstance) { return ( diff --git a/frontend/src/auth/authApiClient.js b/frontend/src/auth/authApiClient.js index 871ab7b..1ab1c3d 100644 --- a/frontend/src/auth/authApiClient.js +++ b/frontend/src/auth/authApiClient.js @@ -49,6 +49,11 @@ const redirectToLogin = async () => { // Add request interceptor to add auth token to all API requests authApiClient.interceptors.request.use( async (config) => { + // Skip token injection if authentication is disabled + if (process.env.REACT_APP_DISABLE_AUTH === 'true') { + console.log("API: Authentication disabled, skipping token injection"); + return config; + } // First check for ID token (preferred for backend compatibility) const idToken = sessionStorage.getItem("idToken"); if (idToken) { @@ -136,6 +141,11 @@ authApiClient.interceptors.response.use( return response; }, async (error) => { + // Skip auth error handling if authentication is disabled + if (process.env.REACT_APP_DISABLE_AUTH === 'true') { + return Promise.reject(error); + } + // Check if error is due to an unauthorized request (status 401) if (error.response && error.response.status === 401) { console.log("API: Received 401 Unauthorized response, redirecting to login"); diff --git a/frontend/src/components/AuthenticatedContent.js b/frontend/src/components/AuthenticatedContent.js index 67bf1fd..1d31095 100644 --- a/frontend/src/components/AuthenticatedContent.js +++ b/frontend/src/components/AuthenticatedContent.js @@ -1,100 +1,237 @@ -import React from 'react'; -import { useMsal } from '@azure/msal-react'; -import VideoUpload from './VideoUpload'; -import PromptSelector from './PromptSelector'; -import ResultDisplay from './ResultDisplay'; - -const AuthenticatedContent = (props) => { - const { instance } = useMsal(); - const activeAccount = instance.getActiveAccount(); - - const handleLogout = () => { - instance.logoutRedirect(); - }; - - return ( -
-
-

Video Query Tool

-
- {activeAccount && ( -
- Signed in as: {activeAccount.name} -
- )} - -
-
- - {!props.result && ( - <> - - - {props.selectedFile && ( -
-
- - - -
- Video selected: {props.fileName} -
-
-
- )} - - - - {props.error && ( -
- {props.error} -
- )} - -
- -
- - )} - - - - {props.result && ( -
- -
- )} -
- ); -}; - +import React from 'react'; +import { useMsal } from '@azure/msal-react'; +import VideoUpload from './VideoUpload'; +import PromptSelector from './PromptSelector'; +import ResultDisplay from './ResultDisplay'; + +const AuthenticatedContent = (props) => { + const { instance } = useMsal(); + const activeAccount = instance.getActiveAccount(); + + const handleLogout = () => { + instance.logoutRedirect(); + }; + + return ( +
+
+

Video Query Tool

+
+ {activeAccount && ( +
+ Signed in as: {activeAccount.name} +
+ )} + +
+
+ + {/* Always show video upload area */} + + + {/* Active Queue Display - queued, processing, cancelled */} + {props.uploadQueue && props.uploadQueue.filter(item => ['queued', 'processing', 'cancelled'].includes(item.status)).length > 0 && ( +
+
+
+
+ Processing Queue ({props.uploadQueue.filter(item => ['queued', 'processing', 'cancelled'].includes(item.status)).length} videos) + {props.uploadQueue.filter(item => item.status === 'processing').length > 0 && ( + + {props.uploadQueue.filter(item => item.status === 'processing').length} processing + + )} +
+ +
+
+
+ {props.uploadQueue + .filter(item => ['queued', 'processing', 'cancelled'].includes(item.status)) + .map((item, index) => ( +
+
+
+
+ {/* Status Icon */} + {item.status === 'queued' && ( + ⏳ Queued + )} + {item.status === 'processing' && ( + + + Processing + + )} + {item.status === 'cancelled' && ( + ⚠️ Cancelled + )} + + {item.fileName} +
+ + {/* Progress Bar */} + {item.status === 'processing' && ( +
+
+ {item.progress}% +
+
+ )} + + {/* Error Message */} + {item.error && ( +
+ {item.error} +
+ )} +
+ + {/* Action Buttons */} +
+ {/* Stop Button - Only for processing videos */} + {item.status === 'processing' && ( + + )} + + {/* Retry Button - Only for cancelled or failed videos */} + {(item.status === 'cancelled') && ( + + )} + + {/* Remove Button - Always visible */} + +
+
+
+ ))} +
+
+
+
+ )} + + {/* Prompt Selector and Process Button - Always Visible */} + + + {props.error && ( +
+ {props.error} +
+ )} + +
+ +
+ + {/* Processed List - Completed and Failed Videos */} + {props.uploadQueue && props.uploadQueue.some(item => ['completed', 'failed'].includes(item.status)) && ( +
+
+
+
+ ✅ Processed Videos ({props.uploadQueue.filter(item => ['completed', 'failed'].includes(item.status)).length}) +
+
+
+ {props.uploadQueue.filter(item => ['completed', 'failed'].includes(item.status)).map(item => ( +
+
+
+
+
+ {item.fileName} + {item.status === 'completed' && ( + ✓ Completed + )} + {item.status === 'failed' && ( + ✗ Failed + )} +
+ {item.processingTime && ( + ⏱️ Processing time: {item.processingTime} + )} +
+ +
+ + {item.status === 'completed' && item.result && ( + + )} + + {item.status === 'failed' && item.error && ( +
+ Error: {item.error} +
+ )} +
+
+ ))} +
+
+
+ )} +
+ ); +}; + export default AuthenticatedContent; \ No newline at end of file diff --git a/frontend/src/components/ResultDisplay.js b/frontend/src/components/ResultDisplay.js index e68d17c..d970dad 100644 --- a/frontend/src/components/ResultDisplay.js +++ b/frontend/src/components/ResultDisplay.js @@ -1,405 +1,508 @@ -import React, { useRef, useEffect, useState } from 'react'; -import showdown from 'showdown'; -import mermaid from 'mermaid'; -import { getApiConfig } from '../utils/configLoader'; - -const ResultDisplay = ({ result, isLoading, uploadProgress = 0, fileName = '' }) => { - const resultRef = useRef(null); - const [htmlContent, setHtmlContent] = useState(''); - - // Initialize mermaid - useEffect(() => { - mermaid.initialize({ - startOnLoad: true, - theme: 'default', - securityLevel: 'loose' - }); - }, []); - - // Convert markdown to HTML using showdown - useEffect(() => { - if (result) { - const converter = new showdown.Converter({ - tables: true, - tasklists: true, - strikethrough: true, - ghCodeBlocks: true - }); - const html = converter.makeHtml(result); - setHtmlContent(html); - } - }, [result]); - - // Render mermaid diagrams after HTML content is set - useEffect(() => { - if (htmlContent && resultRef.current) { - setTimeout(() => { - try { - // Find text containing "graph" or "sequenceDiagram" or "flowchart" outside of code blocks - const textNodes = Array.from(resultRef.current.childNodes) - .filter(node => node.nodeType === Node.TEXT_NODE || - (node.nodeType === Node.ELEMENT_NODE && - node.tagName !== 'PRE' && - node.tagName !== 'CODE')); - - // Standard code blocks with mermaid - const mermaidCodeBlocks = resultRef.current.querySelectorAll('pre code.language-mermaid'); - - // Also try to find any pre/code with mermaid content when class wasn't set correctly - const potentialMermaidBlocks = Array.from(resultRef.current.querySelectorAll('pre')) - .filter(pre => { - const codeEl = pre.querySelector('code'); - if (!codeEl) return false; - const content = codeEl.textContent.trim(); - return content.startsWith('graph ') || - content.startsWith('sequenceDiagram') || - content.startsWith('flowchart ') || - content.includes('mermaid'); - }); - - // Process all known mermaid code blocks - const processBlock = (element, index) => { - const isPreElement = element.tagName === 'PRE'; - const codeEl = isPreElement ? element.querySelector('code') : null; - const mermaidCode = codeEl ? codeEl.textContent : element.textContent; - - if (!mermaidCode.trim()) return; - - // Create a div to hold the rendered diagram - const diagramDiv = document.createElement('div'); - diagramDiv.className = 'mermaid'; - diagramDiv.id = `mermaid-diagram-${index}`; - diagramDiv.textContent = mermaidCode; - - // Store the original code as an attribute so we can access it later - diagramDiv.setAttribute('data-original-code', mermaidCode); - - // Replace the original element with the diagram div - if (isPreElement && element.parentElement) { - element.parentElement.replaceChild(diagramDiv, element); - } else if (element.parentElement) { - element.parentElement.replaceChild(diagramDiv, element); - } - }; - - // Process standard mermaid blocks - mermaidCodeBlocks.forEach(processBlock); - - // Process potential mermaid blocks not correctly marked - potentialMermaidBlocks.forEach((block, index) => { - // Only process if it wasn't already processed as a standard mermaid block - if (!block.querySelector('code.language-mermaid')) { - processBlock(block, mermaidCodeBlocks.length + index); - } - }); - - // Now run mermaid rendering - mermaid.run(); - } catch (error) { - console.error('Error rendering mermaid diagrams:', error); - } - }, 100); // Small delay to ensure DOM is fully updated - } - }, [htmlContent]); - - // This function is no longer needed with the new approach - - const copyToClipboard = () => { - if (!htmlContent) return; - - // Clone the current content with rendered diagrams - const contentToExport = resultRef.current.cloneNode(true); - document.body.appendChild(contentToExport); - - // Select the content - const range = document.createRange(); - range.selectNode(contentToExport); - window.getSelection().removeAllRanges(); - window.getSelection().addRange(range); - - // Copy the selected content as HTML - document.execCommand('copy'); - - // Clean up - window.getSelection().removeAllRanges(); - document.body.removeChild(contentToExport); - - alert('Formatted content copied to clipboard! You can now paste it into Word or other applications.'); - }; - - const [isPdfLoading, setIsPdfLoading] = useState(false); - - const downloadPdf = async () => { - if (!htmlContent) return; - - setIsPdfLoading(true); - - try { - // Wait for any final rendering - await new Promise(resolve => setTimeout(resolve, 1000)); - - // Force re-render if necessary and wait - if (resultRef.current && resultRef.current.querySelectorAll('.mermaid:not(:empty) svg').length !== resultRef.current.querySelectorAll('.mermaid').length) { - // console.log("Forcing mermaid.run() for PDF export."); - try { - mermaid.run({ nodes: resultRef.current.querySelectorAll('.mermaid') }); - await new Promise(resolve => setTimeout(resolve, 1500)); // Longer wait after explicit run - } catch(e) { - console.error("Error during mermaid.run() for PDF:", e); - } - } - - const diagramPngs = {}; // Store base64 PNGs keyed by diagram ID - const textDiagrams = {}; // Still useful for alt text or if PNG fails - - // It's crucial to work on the live DOM state that mermaid.js has modified. - // Clone the resultRef.current to avoid altering the displayed content if we assign IDs. - const contentToExport = resultRef.current.cloneNode(true); - - const mermaidDivs = contentToExport.querySelectorAll('.mermaid'); - // console.log(`Found ${mermaidDivs.length} .mermaid elements for PDF export.`); - - // Create an array of promises for all conversions - const conversionPromises = Array.from(mermaidDivs).map(async (div, index) => { - let diagramId = div.id; - if (!diagramId) { - // If a div.mermaid doesn't have an ID, assign one. - diagramId = `mermaid-export-${index}`; - div.id = diagramId; // Assign ID to the div in our cloned content - // console.log(`Assigned dynamic ID ${diagramId} to a .mermaid div for export.`); - } - - const originalCode = div.getAttribute('data-original-code') || - (div.firstChild && div.firstChild.nodeType === Node.TEXT_NODE ? div.firstChild.textContent.trim() : div.textContent.trim()); - - if (originalCode) { - textDiagrams[diagramId] = originalCode; - } else { - console.warn(`No original code found for .mermaid div with ID: ${diagramId}`); - } - - const svgElement = div.querySelector('svg'); - if (svgElement) { - try { - const svgString = new XMLSerializer().serializeToString(svgElement); - const svgDataUrl = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svgString)}`; - - const image = new Image(); - - // Create a promise for each image load and canvas conversion - await new Promise((resolve, reject) => { - image.onload = () => { - const canvas = document.createElement('canvas'); - // --- Determine canvas size --- - // Option 1: Use SVG's explicit width/height if they are pixel values - let svgWidth = parseFloat(svgElement.getAttribute('width')); - let svgHeight = parseFloat(svgElement.getAttribute('height')); - - // Option 2: If no explicit width/height, use viewBox (more robust) - if (isNaN(svgWidth) || isNaN(svgHeight) || svgWidth <= 0 || svgHeight <= 0) { - const viewBox = svgElement.getAttribute('viewBox'); - if (viewBox) { - const parts = viewBox.split(' '); - svgWidth = parseFloat(parts[2]); - svgHeight = parseFloat(parts[3]); - } - } - - // Fallback if dimensions still not found - if (isNaN(svgWidth) || isNaN(svgHeight) || svgWidth <= 0 || svgHeight <= 0) { - console.warn(`Could not determine dimensions for SVG ${diagramId}, using fallback.`); - svgWidth = 600; // Default/fallback width - svgHeight = 400; // Default/fallback height - } - - // Apply a scale factor for better resolution - const scaleFactor = 2; // 2x resolution - canvas.width = svgWidth * scaleFactor; - canvas.height = svgHeight * scaleFactor; - - const ctx = canvas.getContext('2d'); - if (!ctx) { - console.error('Could not get 2D context from canvas'); - reject(new Error('Canvas 2D context unavailable')); - return; - } - - // Fill background with white to ensure opaque PNG - ctx.fillStyle = 'white'; - ctx.fillRect(0, 0, canvas.width, canvas.height); - - ctx.drawImage(image, 0, 0, canvas.width, canvas.height); - - diagramPngs[diagramId] = canvas.toDataURL('image/png'); - // console.log(`Converted SVG ${diagramId} to PNG (length: ${diagramPngs[diagramId].length})`); - resolve(); - }; - image.onerror = (err) => { - console.error(`Error loading SVG into Image object for ${diagramId}:`, err); - reject(new Error(`Image loading error for SVG ${diagramId}`)); - }; - image.src = svgDataUrl; - }); - } catch (e) { - console.error(`Error converting SVG ${diagramId} to PNG:`, e); - // No PNG for this diagram if conversion fails - } - } else { - console.warn(`No SVG element found in .mermaid div ID: ${diagramId}. Original code snippet: ${(originalCode || '').substring(0,30)}`); - } - }); - - // Wait for all SVG to PNG conversions to complete - await Promise.all(conversionPromises); - - // The HTML to send is the innerHTML of our (potentially ID-modified) cloned container. - const htmlToSend = contentToExport.innerHTML; - - // Debug logging commented out - // console.log("Sending to backend for PDF generation:", { - // htmlLength: htmlToSend.length, - // numTextDiagrams: Object.keys(textDiagrams).length, - // numDiagramPngs: Object.keys(diagramPngs).length, - // }); - // if (Object.keys(diagramPngs).length > 0) { - // console.log("Diagram PNG IDs:", Object.keys(diagramPngs)); - // } - - // Debug logging commented out - // console.log("HTML CONTENT START -------------------"); - // console.log(htmlToSend); - // console.log("HTML CONTENT END ---------------------"); - - // Make API request to generate PDF - const authApiClient = require('../auth/authApiClient').authApiClient; - const apiConfig = getApiConfig(); - const pdfEndpoint = `${apiConfig.chunkedUploadEndpoint}/api/generate-pdf`; - const response = await authApiClient.post( - pdfEndpoint, - { - html: htmlToSend, - textDiagrams: textDiagrams, - diagramPngs: diagramPngs, // Send the base64 PNGs instead of SVGs - videoFileName: fileName // Send the original video filename - }, - { - headers: { - 'Content-Type': 'application/json' - } - } - ); - - if (response.data.success) { - // Convert base64 PDF to blob - const pdfData = atob(response.data.pdf); - const pdfBytes = new Uint8Array(pdfData.length); - for (let i = 0; i < pdfData.length; i++) { - pdfBytes[i] = pdfData.charCodeAt(i); - } - const pdfBlob = new Blob([pdfBytes], { type: 'application/pdf' }); - const pdfUrl = URL.createObjectURL(pdfBlob); - - // Create download link and trigger download - const downloadLink = document.createElement('a'); - downloadLink.href = pdfUrl; - downloadLink.download = response.data.filename || 'video_query_result.pdf'; - document.body.appendChild(downloadLink); - downloadLink.click(); - - // Clean up - document.body.removeChild(downloadLink); - setTimeout(() => { - URL.revokeObjectURL(pdfUrl); - }, 100); - } else { - throw new Error(response.data.message || 'PDF generation failed'); - } - } catch (error) { - console.error('Error downloading PDF:', error); - alert('Failed to generate PDF. Please try again later.'); - } finally { - setIsPdfLoading(false); - } - }; - - if (isLoading) { - const isUploading = uploadProgress < 100; - return ( -
-
- Loading... -
-

- {isUploading - ? `Uploading video: ${uploadProgress}% complete...` - : 'Processing video... This may take several minutes depending on the video length.'} -

-
-
-
- {!isUploading && ( -
- - Note: Your video has been uploaded successfully and is being processed by Gemini AI. - This may take several minutes for longer videos (up to 55 minutes supported). - -
- )} -
- ); - } - - if (!result) { - return null; - } - - return ( -
-
-

Result

-
- - -
-
- -
- -
-

Tip: Click "Copy Formatted" to copy the content in a format suitable for pasting into Word or other document editors.

-
-
- ); -}; - +import React, { useRef, useEffect, useState } from 'react'; +import showdown from 'showdown'; +import mermaid from 'mermaid'; +import { getApiConfig } from '../utils/configLoader'; + +const ResultDisplay = ({ result, isLoading, uploadProgress = 0, fileName = '', chunksProcessed = 0, totalChunks = 0 }) => { + const resultRef = useRef(null); + const [htmlContent, setHtmlContent] = useState(''); + const [showChunkInfo, setShowChunkInfo] = useState(true); + + // Initialize mermaid + useEffect(() => { + mermaid.initialize({ + startOnLoad: true, + theme: 'default', + securityLevel: 'loose' + }); + }, []); + + // Convert markdown to HTML using showdown + useEffect(() => { + if (result) { + const converter = new showdown.Converter({ + tables: true, + tasklists: true, + strikethrough: true, + ghCodeBlocks: true + }); + const html = converter.makeHtml(result); + setHtmlContent(html); + } + }, [result]); + + // Render mermaid diagrams after HTML content is set + useEffect(() => { + if (htmlContent && resultRef.current) { + setTimeout(() => { + try { + // Find text containing "graph" or "sequenceDiagram" or "flowchart" outside of code blocks + const textNodes = Array.from(resultRef.current.childNodes) + .filter(node => node.nodeType === Node.TEXT_NODE || + (node.nodeType === Node.ELEMENT_NODE && + node.tagName !== 'PRE' && + node.tagName !== 'CODE')); + + // Standard code blocks with mermaid + const mermaidCodeBlocks = resultRef.current.querySelectorAll('pre code.language-mermaid'); + + // Also try to find any pre/code with mermaid content when class wasn't set correctly + const potentialMermaidBlocks = Array.from(resultRef.current.querySelectorAll('pre')) + .filter(pre => { + const codeEl = pre.querySelector('code'); + if (!codeEl) return false; + const content = codeEl.textContent.trim(); + return content.startsWith('graph ') || + content.startsWith('sequenceDiagram') || + content.startsWith('flowchart ') || + content.includes('mermaid'); + }); + + // Process all known mermaid code blocks + const processBlock = (element, index) => { + const isPreElement = element.tagName === 'PRE'; + const codeEl = isPreElement ? element.querySelector('code') : null; + const mermaidCode = codeEl ? codeEl.textContent : element.textContent; + + if (!mermaidCode.trim()) return; + + // Create a div to hold the rendered diagram + const diagramDiv = document.createElement('div'); + diagramDiv.className = 'mermaid'; + diagramDiv.id = `mermaid-diagram-${index}`; + diagramDiv.textContent = mermaidCode; + + // Store the original code as an attribute so we can access it later + diagramDiv.setAttribute('data-original-code', mermaidCode); + + // Replace the original element with the diagram div + if (isPreElement && element.parentElement) { + element.parentElement.replaceChild(diagramDiv, element); + } else if (element.parentElement) { + element.parentElement.replaceChild(diagramDiv, element); + } + }; + + // Process standard mermaid blocks + mermaidCodeBlocks.forEach(processBlock); + + // Process potential mermaid blocks not correctly marked + potentialMermaidBlocks.forEach((block, index) => { + // Only process if it wasn't already processed as a standard mermaid block + if (!block.querySelector('code.language-mermaid')) { + processBlock(block, mermaidCodeBlocks.length + index); + } + }); + + // Now run mermaid rendering + mermaid.run(); + } catch (error) { + console.error('Error rendering mermaid diagrams:', error); + } + }, 100); // Small delay to ensure DOM is fully updated + } + }, [htmlContent]); + + // This function is no longer needed with the new approach + + const copyToClipboard = () => { + if (!htmlContent) return; + + // Clone the current content with rendered diagrams + const contentToExport = resultRef.current.cloneNode(true); + document.body.appendChild(contentToExport); + + // Select the content + const range = document.createRange(); + range.selectNode(contentToExport); + window.getSelection().removeAllRanges(); + window.getSelection().addRange(range); + + // Copy the selected content as HTML + document.execCommand('copy'); + + // Clean up + window.getSelection().removeAllRanges(); + document.body.removeChild(contentToExport); + + alert('Formatted content copied to clipboard! You can now paste it into Word or other applications.'); + }; + + const [isPdfLoading, setIsPdfLoading] = useState(false); + + const downloadPdf = async () => { + if (!htmlContent) return; + + setIsPdfLoading(true); + + try { + // Wait for any final rendering + await new Promise(resolve => setTimeout(resolve, 1000)); + + // Force re-render if necessary and wait + if (resultRef.current && resultRef.current.querySelectorAll('.mermaid:not(:empty) svg').length !== resultRef.current.querySelectorAll('.mermaid').length) { + // console.log("Forcing mermaid.run() for PDF export."); + try { + mermaid.run({ nodes: resultRef.current.querySelectorAll('.mermaid') }); + await new Promise(resolve => setTimeout(resolve, 1500)); // Longer wait after explicit run + } catch(e) { + console.error("Error during mermaid.run() for PDF:", e); + } + } + + const diagramPngs = {}; // Store base64 PNGs keyed by diagram ID + const textDiagrams = {}; // Still useful for alt text or if PNG fails + + // It's crucial to work on the live DOM state that mermaid.js has modified. + // Clone the resultRef.current to avoid altering the displayed content if we assign IDs. + const contentToExport = resultRef.current.cloneNode(true); + + const mermaidDivs = contentToExport.querySelectorAll('.mermaid'); + // console.log(`Found ${mermaidDivs.length} .mermaid elements for PDF export.`); + + // Create an array of promises for all conversions + const conversionPromises = Array.from(mermaidDivs).map(async (div, index) => { + let diagramId = div.id; + if (!diagramId) { + // If a div.mermaid doesn't have an ID, assign one. + diagramId = `mermaid-export-${index}`; + div.id = diagramId; // Assign ID to the div in our cloned content + // console.log(`Assigned dynamic ID ${diagramId} to a .mermaid div for export.`); + } + + const originalCode = div.getAttribute('data-original-code') || + (div.firstChild && div.firstChild.nodeType === Node.TEXT_NODE ? div.firstChild.textContent.trim() : div.textContent.trim()); + + if (originalCode) { + textDiagrams[diagramId] = originalCode; + } else { + console.warn(`No original code found for .mermaid div with ID: ${diagramId}`); + } + + const svgElement = div.querySelector('svg'); + if (svgElement) { + try { + const svgString = new XMLSerializer().serializeToString(svgElement); + const svgDataUrl = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svgString)}`; + + const image = new Image(); + + // Create a promise for each image load and canvas conversion + await new Promise((resolve, reject) => { + image.onload = () => { + const canvas = document.createElement('canvas'); + // --- Determine canvas size --- + // Option 1: Use SVG's explicit width/height if they are pixel values + let svgWidth = parseFloat(svgElement.getAttribute('width')); + let svgHeight = parseFloat(svgElement.getAttribute('height')); + + // Option 2: If no explicit width/height, use viewBox (more robust) + if (isNaN(svgWidth) || isNaN(svgHeight) || svgWidth <= 0 || svgHeight <= 0) { + const viewBox = svgElement.getAttribute('viewBox'); + if (viewBox) { + const parts = viewBox.split(' '); + svgWidth = parseFloat(parts[2]); + svgHeight = parseFloat(parts[3]); + } + } + + // Fallback if dimensions still not found + if (isNaN(svgWidth) || isNaN(svgHeight) || svgWidth <= 0 || svgHeight <= 0) { + console.warn(`Could not determine dimensions for SVG ${diagramId}, using fallback.`); + svgWidth = 600; // Default/fallback width + svgHeight = 400; // Default/fallback height + } + + // Apply a scale factor for better resolution + const scaleFactor = 2; // 2x resolution + canvas.width = svgWidth * scaleFactor; + canvas.height = svgHeight * scaleFactor; + + const ctx = canvas.getContext('2d'); + if (!ctx) { + console.error('Could not get 2D context from canvas'); + reject(new Error('Canvas 2D context unavailable')); + return; + } + + // Fill background with white to ensure opaque PNG + ctx.fillStyle = 'white'; + ctx.fillRect(0, 0, canvas.width, canvas.height); + + ctx.drawImage(image, 0, 0, canvas.width, canvas.height); + + diagramPngs[diagramId] = canvas.toDataURL('image/png'); + // console.log(`Converted SVG ${diagramId} to PNG (length: ${diagramPngs[diagramId].length})`); + resolve(); + }; + image.onerror = (err) => { + console.error(`Error loading SVG into Image object for ${diagramId}:`, err); + reject(new Error(`Image loading error for SVG ${diagramId}`)); + }; + image.src = svgDataUrl; + }); + } catch (e) { + console.error(`Error converting SVG ${diagramId} to PNG:`, e); + // No PNG for this diagram if conversion fails + } + } else { + console.warn(`No SVG element found in .mermaid div ID: ${diagramId}. Original code snippet: ${(originalCode || '').substring(0,30)}`); + } + }); + + // Wait for all SVG to PNG conversions to complete + await Promise.all(conversionPromises); + + // The HTML to send is the innerHTML of our (potentially ID-modified) cloned container. + const htmlToSend = contentToExport.innerHTML; + + // Debug logging commented out + // console.log("Sending to backend for PDF generation:", { + // htmlLength: htmlToSend.length, + // numTextDiagrams: Object.keys(textDiagrams).length, + // numDiagramPngs: Object.keys(diagramPngs).length, + // }); + // if (Object.keys(diagramPngs).length > 0) { + // console.log("Diagram PNG IDs:", Object.keys(diagramPngs)); + // } + + // Debug logging commented out + // console.log("HTML CONTENT START -------------------"); + // console.log(htmlToSend); + // console.log("HTML CONTENT END ---------------------"); + + // Make API request to generate PDF + const authApiClient = require('../auth/authApiClient').authApiClient; + const apiConfig = getApiConfig(); + const pdfEndpoint = `${apiConfig.chunkedUploadEndpoint}/api/generate-pdf`; + const response = await authApiClient.post( + pdfEndpoint, + { + html: htmlToSend, + textDiagrams: textDiagrams, + diagramPngs: diagramPngs, // Send the base64 PNGs instead of SVGs + videoFileName: fileName // Send the original video filename + }, + { + headers: { + 'Content-Type': 'application/json' + } + } + ); + + if (response.data.success) { + // Convert base64 PDF to blob + const pdfData = atob(response.data.pdf); + const pdfBytes = new Uint8Array(pdfData.length); + for (let i = 0; i < pdfData.length; i++) { + pdfBytes[i] = pdfData.charCodeAt(i); + } + const pdfBlob = new Blob([pdfBytes], { type: 'application/pdf' }); + const pdfUrl = URL.createObjectURL(pdfBlob); + + // Create download link and trigger download + const downloadLink = document.createElement('a'); + downloadLink.href = pdfUrl; + downloadLink.download = response.data.filename || 'video_query_result.pdf'; + document.body.appendChild(downloadLink); + downloadLink.click(); + + // Clean up + document.body.removeChild(downloadLink); + setTimeout(() => { + URL.revokeObjectURL(pdfUrl); + }, 100); + } else { + throw new Error(response.data.message || 'PDF generation failed'); + } + } catch (error) { + console.error('Error downloading PDF:', error); + + // Better error message based on error type + let errorMessage = 'Failed to generate PDF. '; + if (error.response) { + // Server returned an error + errorMessage += error.response.data?.message || `Server error: ${error.response.status}`; + } else if (error.request) { + // Request was made but no response received + errorMessage += 'No response from server. The PDF may be too large or the connection timed out.'; + } else if (error.message) { + errorMessage += error.message; + } else { + errorMessage += 'Please try again later.'; + } + + alert(errorMessage); + } finally { + setIsPdfLoading(false); + } + }; + + if (isLoading) { + const isUploading = uploadProgress < 100; + return ( +
+
+ Loading... +
+

+ {isUploading + ? `Uploading video: ${uploadProgress}% complete...` + : 'Processing video... This may take several minutes depending on the video length.'} +

+
+
+
+ {!isUploading && ( +
+ + Note: Your video has been uploaded successfully and is being processed by Gemini AI. + This may take several minutes for longer videos (up to 55 minutes supported). + +
+ )} +
+ ); + } + + if (!result) { + return null; + } + + return ( +
+ {/* Chunk Processing Info - Collapsible */} + {totalChunks > 1 && ( +
+
setShowChunkInfo(!showChunkInfo)} + > +
+ + + + Long Video Processing Info +
+
+ {chunksProcessed}/{totalChunks} chunks processed + + {showChunkInfo ? ( + + ) : ( + + )} + +
+
+ {showChunkInfo && ( +
+
+
+

+ + + + + Your video was longer than 25 minutes and was processed in {totalChunks} separate chunks. +

+
+
+ {chunksProcessed}/{totalChunks} chunks +
+
+
    + {[...Array(totalChunks)].map((_, index) => ( +
  • + {index < chunksProcessed ? ( + + + + ) : ( + + + + )} + + Chunk {index + 1} ({index * 25}-{Math.min((index + 1) * 25, (index + 1) * 25)} minutes) + {index < chunksProcessed && ' ✓ Completed'} + +
    • + ))} +
+
+ + Note: Videos longer than 25 minutes are automatically split into chunks to avoid API timeouts. + Each chunk is processed separately and the results are combined intelligently. + +
+
+
+
+ )} +
+ )} + +
+

Result

+
+ + +
+
+ +
+ +
+

Tip: Click "Copy Formatted" to copy the content in a format suitable for pasting into Word or other document editors.

+
+
+ ); +}; + export default ResultDisplay; \ No newline at end of file diff --git a/frontend/src/components/VideoUpload.js b/frontend/src/components/VideoUpload.js index 092dc84..61cfe44 100644 --- a/frontend/src/components/VideoUpload.js +++ b/frontend/src/components/VideoUpload.js @@ -5,29 +5,34 @@ const MAX_FILE_SIZE = 5 * 1024 * 1024 * 1024; // 5GB const VideoUpload = ({ onVideoSelect }) => { const [error, setError] = useState(''); - + const onDrop = useCallback((acceptedFiles) => { setError(''); - + // Handle the uploaded files if (acceptedFiles && acceptedFiles.length > 0) { - const file = acceptedFiles[0]; - - // Check file size - if (file.size > MAX_FILE_SIZE) { - setError(`File is too large. Maximum size is 5GB.`); - return; - } - - // Check file type const validTypes = ['video/mp4', 'video/avi', 'video/quicktime', 'video/x-ms-wmv', 'video/x-matroska', 'video/webm']; - if (!validTypes.includes(file.type)) { - setError('Please upload a valid video file (MP4, AVI, MOV, WMV, MKV, WEBM)'); - return; + const validFiles = []; + + // Validate each file + for (const file of acceptedFiles) { + // Check file size + if (file.size > MAX_FILE_SIZE) { + setError(`File "${file.name}" is too large. Maximum size is 5GB per file.`); + return; + } + + // Check file type + if (!validTypes.includes(file.type)) { + setError(`File "${file.name}" is not a valid video format. Supported: MP4, AVI, MOV, WMV, MKV, WEBM`); + return; + } + + validFiles.push(file); } - - // Pass the file to parent component - onVideoSelect(file); + + // Pass all valid files to parent component + onVideoSelect(validFiles); } }, [onVideoSelect]); @@ -36,7 +41,7 @@ const VideoUpload = ({ onVideoSelect }) => { accept: { 'video/*': ['.mp4', '.avi', '.mov', '.wmv', '.mkv', '.webm'] }, - maxFiles: 1 + multiple: true }); return ( @@ -55,18 +60,18 @@ const VideoUpload = ({ onVideoSelect }) => {

- {isDragActive ? - 'Drop the video here...' : - 'Drag and drop a video file here, or click to select a file'} + {isDragActive ? + 'Drop the videos here...' : + 'Drag and drop video files here, or click to select files'}

-

Supported formats: MP4, AVI, MOV, WMV, MKV, WEBM (max 5GB)

+

Supported formats: MP4, AVI, MOV, WMV, MKV, WEBM (max 5GB per file) • Multiple files supported

{error &&
{error}
}
- Important: The Gemini AI model can only process videos up to 55 minutes in length. - Longer videos will fail to process. + Note: Videos longer than 25 minutes are automatically split into chunks and processed in parallel. + Maximum video length: No limit (automatic splitting enabled).
); diff --git a/video-query.zip b/video-query.zip new file mode 100644 index 0000000000000000000000000000000000000000..88f409b89393f682bc5ffd0df5388eff4b839e9d GIT binary patch literal 572714 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⁢` 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

O60iJxg1ABL1RWc+k9DQiKpQbk>D2hEU*j3 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

)wS}haG@mx#9$7>RVMi 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%0A=ZbwB&HlWlLt`xhF2?!CKMUXtKBcJJfUUT?dm zF1_)kVehNDzPZ^Bs=Zm-mzc2Uu1){?u^-mQ+wCSlVb83cpEx96e&8hemAsdGp>OX! zml7-k+ji2Q08gCKbDrWX_59~}w)4%zH#e6}{N|m}&+iP;30M(AeyUeej#!X1C>at`P_$@BgDm;2cdn>5%zFB(JM>n8XI!EXKFG+%Oa z|13ie+z@X4Q zHin_=^xwQVZm9ylwCL~W6AOldFBl%%Xl+d#8 z3rmYex+U_Q$A@!xlW3edhQN}eki~JcDw8QML`Pw}th=tK53->EqKapAb38a4F(Ss} z0#U=U3MaqgXM0w?znHrBI=wGouh_W^pWuNGZ+f@D3Db(!N3J>S*&-tLAhman`CQz0 z>u!y5Spa}o$42N>cC<)O=3BSs7<^x^ahj<|^At^?c&gS?9TGF4->(ShA**I~t=oGJ z+raMjny@&W~2d~0{KlBkY@;AlI6!vV( zdR-MdBGfMu&&$?(T-B^Pp#V|tO-pusH$3R_qv}x&PP=^h@N2qq5J%rMbw=;p4So8M zcW8fm;RzkMKWaTW-f(Mv1|f3O1qaN5ysF-TWSQTV5!jTBbp?)DAZtuKX`9z2}M}ynO*f~;B@Td_v$k(}i zHD{4ffTNCq<7H?Yb~&1|WS{QX+{Rbyn8iDMZ#71mEt5cOl4Dw!qJ%(QLpcOB1Dj?C z^0T{_ZX5aY%NU2dTGrdhxgas}L=0?H??7u54>zk(OK?q1@-4NIh3s%`&D?R*hW$#~GzkG7#x&PxQSJL{lZ@jGPAFrKzSv2YO{qP?y232m> z`_JFRF0VbXe!Nf}K0WW;X6FwVT<5E2xLLV(zPgfJBT;|2n{9yn2 zuP+w+;EQ)U&6oW17pjBg>kDr%j(&FibJn}~BZ4pA<(NGq;EpZW(C!{@rr;Nw3iuwA z!86#an7Rxv&4UNIz-^gMdKw}FlqcG}%(n$OiTB;EN7M-d$xCP4_mf$#)Wmqh+6p7@ zusAGRt0V5DBaUa@)^4n`}zNJBl| zY$K!EaPwHI8l8nkNMlFa8HbXKF!0^fCuh6W43#kh(ka1|am8N1lQ!eryo zOH$lK#)==qrkKi)SeV}~Z)a}*a*2aKyZB+j_!PkRlK7)={Cnrxv*z$6UqE;9#Rcq@ zFD}CiUkqxX&R{C8iRLIIlPaoWf^EZY$xfGWFA9h;iJFRwa|4T7vl+Wa(=X^+^r&!> z0|Cq8Q0;MOW#J0Ia7%qsFq|D~fcFT#cwXwSB>kJI@?8VgJ3Z3RU~g2pWOWVoLm$t* z)-9uV#`RK$7SBu`ehKI&6N3xN)v()zaKwnX9VI5x1eW4nRT1P#nX z31P9=a_yp15~&-iMn4p-&noX1#;v=0rM?1wM(yR`=>l#@`X6(gX$lua#|kBsd17~# zvpy{JdhXcMwHRspWo8BR2o(g=>4IIPEyFP z{1W%@J!X?fAKk;A9ByH22ik@+U+8;iHG>Fr1=pK{;Je;GE}L#z#e?;;Gt?Vi%U|ej zp6k|{U)YScp~+Yld1t@uGQ(x@Zj?yyTF%H)O?D%>==N4mBfjh8<;>$W0AO`EjoFE> zI~=!cRd`m6Jcd>xUyHndL_7PST>Z_H;$qZz^n9oeHi z=U^fh7-*|fWw5-dFr-=1Dwa`nuBRLm=j43XLenNC4=YmYS!oBz{90J^Z5ITSNxE*6 z(eLZiZ`+gp`94nfT&?x+6bJRKcFlV`Q`uf9JhW8S0e&uWdQJ?nZ^wUy)jOc)`|7J5 z>iM?QzmIp_P7kI4ZTzH@ zEpe}FtqWKMz`~gv*LbH)hd7? zAXCKHFSuQsTL-z7F;^Io+sLkm0D}(!HVD1+<{5Xg?>cc<IY-@0``jD%WyD$qdbziB@CuWw%Ck?xrb+Lx!(Ki z66vIAq#eU$780f|&k9UtmLmmcP(36Yk2=ST|PWUOQ%YBD87&FrFm$nt%a zNdLqh`q@kHV2$bm_C}QRaIj8w>^6W}(W5om*A59{&v)IS%qf}&g0jy>uP9gFa8;w>aD}#(;Hq){r?bQlkeJ+ zK=)HNx#YUPj0f9Cw*8vJX{Ol%dR~))zVLQz#jQ!)tdk&WGAWt3r=_O`7h5)v)m3;f zV0u5>Bjm~eC*!wDzI2d2Yg%n^Y)RekL*jd-Y3OQK(9DG4K4^B)Hn(u z;uP@=!H`&Ns~-usaDy6(tVqiI%$9X|K{Vkiyw@ zkw=?-0diKohE+0z<%ilt;J>iHz<+?<-#RG2B+Y$hs~6B$0=*nw$TY-sH8TLpE%%Lu zp_VhY8;=dA6FZ1H&1Z@*RVYNRiPb^YB)01VaYDz3Wy$*cI70SQY~#>oLAhPxD*0%V z>Md0=%W?D1^Zk3H{exHWH^8rGesf~*ijG*@3M!>3f;1Uv7Q8F05ME!=f#tR2E`di2 z>M#}?jGi^b7Q*_yPZ8<@(|nt?~qNG_)qH?iWW{<3yOx9WqxOi(_W;KhFHGkqQrH{2SmKX0Hds8UA3=#KG9M zt^=uCpP7zE?rJT^y1Lc0c`{4nz)X9|Wts zaeHeTG8D5jW9d+Hx6``9#-?~UtK`v?C&#>sGJvaLNm1BgcIYE!3}-V-TTVB&2QBBb z&Xx7iY%I;Q@n{s0RXZ-dR%JD4zc&7Pu~3=mwX@6@=?D;fPyXHu;45mclkjeSZ=9Z!UOy1!G^|jWW71mn2+d6CwSO#u2_c?6s^~3>*%P5*hgxe z*fB|gZdwIP#z@`NiTsO(gMs?tHB#oIb^1BX>R-_Ch~QVG{Za%Ie8%d1?Egau(-qbL z3XMUg+z9}VpX4o5DUcSe7$$1%exy&GDoCOw=HG$verQ`x=Nc_aY-0o8nvTJsu zg$!$x<56xoRL|_)*Si7l!;bDgH%c;r`eZPXEg=*o8dNxwAy}yizrdSp2Lq*I> zB+74b?%SF0CGXxLK3?FSu>Uf?@b3`$5l_e1c7NK!+p}?PR-3v@cgRv1vyGWC35a>-TfO9GsJjK-J~(3J z0`|tAm*Cx@(IWGmj^d~XsVrf7$d>Sp&?S{@-Ow|xh+>H@PUwnJ$<$3toAFy}B?1hz zjbh(e_#;V1+$Ghka4JQUOdaWq9UdLJM_WeDX}h1<316dyp&`L@=OywhbK~tne|>3> zeDkn#q#pV=Z%uy;!G7>A^}_?+^3Kc2!FyL4sj!tE?5OR;nDq{n!6+_d)qbfLE;+8I zl%oVZ!aBr+lE!8y__U2_vx&`g0I{)zy6d#60RSjj^0ShuF#_J7c3^*lJ>e%D@(!@)iUH_;T`5|>Gp=mp;K8*&O!Yrty(t1VeqG`f-#N36T^(qo~q zITcEYu=Fc!9U2m!?j(D+rDT}w(cZCyV=)!tF8(jrYxv)0_rmw0_oEJg40QUc=3?Bm z^8{H+n?NaGdK@9nBJ0{6v&dQe=*P&+qBEY@B#@W6LWeUk#97!8M#MGa&nUW@$3#D} zj|&Hzv@lJVbB%sv5bCY4+~3RjH!=HQId+D6CCWug50zM(LI_X00w=W8rG|2zm2A9e zm`B@E)Yn@+wI=h7B+!OfE(K1nxP@Yjq}%{JEh3jim}?LX>~VGr+Y_1~b|M%@@}oTh z|9~`lzp_0tNBceSHx#=0!iMH#+kCeg$HxgFHr^OsO&4uO$s`|W3bI5T6fkHpDjh*x zcQf*EFoYt3wr+vSm>rW=W5-RZY~uCWoUXlDO*k|;#l^??IiJ-A=pUj}`FOk31?($r z%E4Bt)OLA*@4BUpq%8t9y^w9;)C>-@Q3+F<(P9r)hh67D{NcbUNkIDRs$3pysr6JS z!<#Xi1V;+;92xB6)e1C2XtVz3JvHx=BOZ<07uYuhzZ?(7GMx(tH>^|zuRRd&$_0v` z6HxE%MM>~ZJ02sO5r9z2lC4Zbljh(tsR4;LP8hhGhw%b! z|9-XVrx5_pS(?zjIWLcm5P1F7PqOeo=x-lI^iR0$mWcRZt?vx=%312aM zu51=M-I#l8)ri&tKbU?h@op^nPPaHNmnT_i;_wJaeULvMc+ivp%*2)(Z#|o<1lvF> zY6T)0;_}gS(zpMH8B?D^d7m})_pijJS2|DUiScEo;<^7FbdMx@1%2j{*Q2K^#36~K zhnQdVvP&YU+Q*_`cBCF1_Za{MW(7&BmYnX_%PB)-Yc5k69mdK)-ZVi2fRfJ43Ju(M ztcI*i3Yd~GU!nvjiN9YZ{8A0z+@O>CP+K(4Y_sy8UK)Wy#9#1Ge>=G{V|bCmt<=QX2;w0qIwQ)pGh8((D!+ zD`wcm$7Nt2{E^p28AZD?b>u<}&W|$+l94Ta`28X=re#_eZvC-*{kcs_>pdl>74Nx} z{J%a_S$nFj}0uqfE94 zSm*(8R3V+P&e?a=(p|2JcO z$5=sH<>!udZ}Ulhfw?l*y%x29q=)L$XZ*-q*YkrtS7Vi2xk){pr=_>Gr7WHAWP7oz zVx4m)^Vy23b2A0~0Ged*u7pK_o>qtXmL`p^nFHur_jr5~)`!uSPsjLjiBt0Y?_nMqU zpPq}}-lO%MVV*H_{`+(RG9>O>*LDEcO}2oBkLg9WV@(F#*E!WCqa7A)f&92NC#*7a z`i-BR6umMTp?HszERFjmsO?*(szkPYp2OVlA^$Vv3lBUWJYC@p-~{q8HA%TUl)%WQ zP+#@26~gf?ht(vo2Zd^xk37;6TWY_BgS{l0n7MKff)hA8q{nkmm$z-}^F$Ih0o>Jr zvyxS#y?=(--&92f|03?gk$tU#dL2AnzzoSr#9d*%DpH!Idp}rvvo$eZ9~Z#^jBK(p zS;~xwI&Cl+$f6Lp(RAm=i=w7DHpts&!9$EZp)4+WNG5SZJ!G|D1lsu9OJ1zLp3>jNMmUjfi+o11yDO~IuDN9imb(T^)#JUA%t)@95yYp4Cba>zZ4`+MjYOusubxWl{K zsuEvWmU!F&ll3ewX5(UeV!A~LiPmzJkjv$SJF?+~L;{sp#>_mKuDkU}U*R}3HpeoT zI1{*MTcbXXR)9ohBZKiC*W%mhoc*N%#lNt7?GVG0ksbF0=&DoZWtKZ--G8H(-6uSL ze8iP{Kb*dF4;dm>%JK5R9pjuP4>&VY`CXQcMl8K8szn)j#8P#+AYHCzeiCJ6OBf?t zGB&(ijbsg{j`Qfa?A>X~Ek#%lY-l7}3q%|JzGmW_+tXb>>kTeHYt#NSHQ&o}``=l; zzak+vkNpJ`e?HiT`2qYZH@%!1Y|)%nAXSJy*|$jKt6{*0!J13Wxj}Vtv72rQepB}I z&h9pZxN@38cJo-uWgPGM*{-RPaA9Icsf~;l@+gLb8^K277B(|7dDo5;2Ii3S+rncYuz+;%>#70O%%hjtoc;;@kWI~ zk_o4%Q4|12wF1$A2V4S4!`Jk*#*CV=6ny&o<*C0AgwHeZ?d0^$>Q!RdPPH$Cynda_ zALn{zg=d>fwCg`b~YSPq_=b)Bf`U_`+7t2T#~QOAnbI{E;zsDBPSdYB`sR zWe$+21tBc8w*_mCtzajVCq8PUl|U&A6d|A@Ybd*v!=-;nSBbC3n4czv#W0|2l$4SF zz9+WKtfs2Z4Os0rtvZqSrof*eym#z#^F_x@{`|)12HuDCSKv3qzn-|5*@j5ZU9V0F z(WM}BF$R@xfeQ0dV8=#GFm?q^>4dTO*~V;*bTK8=sh^8p-EbUi(x+A0BxDtZ!fvJR zARs(5wd((*9~;I=9=3NU!(F%$<5QB!E2F6q%6L|?S2|$eCE;gJTK?@q~34| z@8_!sD6`4Ywh))|aR{h@bXB;t@=@h&&hFZQ z$ULDU>%Uus?!xB<>IJ2j(PhCIf>pTU=e%Yb9A_#}iw3+ZW+LdP%Pld__drTc(L$Z@ zEh!f>-EfJ0LwhO1cH_Kt%*}q~942s#2zj`jbcopJvh10>_du+^T`W!?{EQ?L1i@=N z$3Md zzMi6*x6G<;i@WrOU#I-iYI1fgrTebe*K7@swz09JX*7FIh@^44qc=Kdg0K zzx?{UuX6r=2gxVMZ!mm1dV+_d7ZkZh&Qt9$o6?%tup(Awt5zM)Nu-=rjWk*s21@~m z2stw=Mce%&XnUpL;4&i=9;b_IwtYfH^@TF}>@7Ik!@n?W|5&2$ zilOtbE@kFk@$~`p>-kS^y+?yZFFTN5nO`q-9quDJBZB%}AISyCkU+o*!NjG_n|!*m z=+y{fvU+a$VO_+uWz!0?U&BhytUTv1* zUYJ+x@=-pLU+A&(ExMCOM^^G} z$4tLda_$MVcmaIo!xfT;AW{wQrlXgwdwIo1(MFqy?<$j^b>5k?o;Iy z&52RJwoSmqU)WvS$9K>#XnT9&=?Zs9nLfyy&<0(J-lAm|qb;c);?WY%m|2Kfo_Tb4 z>qV|&lhnypD?>3S6P>V=Q2|3j4{sO-Ge#RnnT|IewAvpIRf%e~C_kvX_t}sA+~WJq z_@otLf8CTs2>XS}9+XdBoLPT9IBfq0_Ckg0aB#4`9+i4d%@tHITw%UFN{d8m=9>Uo z>od2l5Q0dl{T{=B+QO$z(a-RFFJrV7u*?a(3Cf}GDM}GHlGhnQuxCbaxXZ-E6q6m!8^PQR z#}ZFFRRl@nm~WO?1n);qW6$kHH!X~2H4(TFkMiG->i&<|3HE;NIqmrm5adt$6FT=d z1@TT_!qA;(wy(=?_nh}xQf^?+bh-@(r)l)+NX7!hAG^eS9NDNaCr!c`i=r;h7n;em z?N(n0A-7!;$1>hdm*9A2uwl5;V|@oH9yTscPW#MT*cVd0Ier2M+G;!->2q%7O3RY+v5*rAl0hm~ z(k7u3lxYm=0=BbNh}J>Lu0ac0nYzi^JSssZ>fea14=aJxnkgf2$dQD5QENST`t z@Wo__6FZ5M)^9@gf7tkDiEpNMd`)Eg7y6!UFB7K@Zr-pTx{coNJULD96P~m1BZdF3 zn^)!kga-4+`)~YWdxhLN8Q%cE^2eJKgL}hE3q~75W_4NLRK9?$f0^qq1DY zseLvgcBSR6=B1slHsW|4f^e0eHoTBXv=e_J2dfmFs4Q^g4@QgOUc$Z?pRf4;zhCkH zKCJGU39eLlOXEKVxw%{md+o>aCK&I3e9EQ6GjvWk?e-G40=!5v^kdc6?i6&gj0*bL{Wd(BD$#-IY&Y=u1cG9h3UU2b@^r$CDSw z>7W`8@vaqClV~e+vgfE4i!pubNr{pZdP{IrDK8j>(P|gVT${@0PSxsxRA*k!NF)Y^ z$6%$HW$Dbj6qC6?D{>2N>0bISMZlobdb> z)tB<)V$D8XYVYhW_Qyk_6VB554W{o{SM#O}+;3aSVs|mZ74DS}uH#D$8*E6^vc<}V zsU}k#ip>x03f8(wJeSAEx#2LA(<}yxku{5x)hY?$9A0}dQsT7M0P8h$Ac(0U?j1iE zd(^QiAzNX38nF2<+2DU&t`_HY;txsr<8@E+zrDHnIa2+bWc~j*GeiZ{WpfhO_QeMB zs!9=qiSfL{`C@q_?^JItV6UXO44*EbhIBij@JX1tIRP&*j`Q=-%dBybY#BFOg&nl% zz_DsjD+JWX_D+X&PFRB)G`7L$2s`4A3ZhW(Sc~a}jvSA17Fr-aLO*muzTY=|>h$?) z*8WsMe&7VX;QiO9XZ^JQN%xz3VoYyfFC1|lUTg$IVo8MqmI|?t_eyD(^F!zGu!Hrm zqpb62omHHU(lD(e5qX(%jOjpKP>)76>QatiLJyKc`&@?_`18Mi=|`gq%7^L#xOPCBYMB^HKeak&g4 z@`DwS!GYA*k9WG zB=8I2=J)D;!wq9i9y{H4_Q(4gsNBF_=zJYsl9YzHO~ZPMZ|4XB?j~FSP;<@X1-a9; z-4sNz5vriR76Bc!?z6(Qd!Fj3iKhmT5^tvRj9kN2w^*p@ESi|hz%SyE<#ca(cespW zR<&6LX4(e!*Qxw>nrYtyKOyV=iNS_ijwH41PTx~Tuw@k)1&}>fhN0_4p}**LIBw>g z@5~v+5@lT461~=2W~$~>V`q{*v01OEZ8F_&&5_feWR6J$i$cHKOXN6DZctX=h8Eo+ zKc2y!(R3SL+-QURnaehz7QV91M*7-R#L+=%7_FF-6zA=7f1`?#J@Xt3uT+3RrE7!h`q!{?c?CiMxDQsWOu2(Rc7haX$`wn z8V;Iog2PX`0d|Kl{p=xUVt;b_>GqHTjBKz4aK=NwE}j+YV}_IG(T-eW1Cr#ISG*ai?vXt&n&UteKi*G0x$=d#i~%Nl@2L`At&| z@-CTi1A9i-ZTNHnH2^`))IF@jP3g{g-tUtRh>mz(#wTU3g&IOHCmxiU6nfll$*$Yv zi^aM*El>+u18sl0vyC}M0!+SI09ZsrBUG=!qH_fwh3hsmWJ{x{lxx3g-thSyWiaYp`F;q8WpR z@QJSz&srDN4)zxWELQ6^L1G@I7+!`{;7;^5F$!w|na zb;`ei{EVsV(O}m+5cNxlWZWQajh&Td)U036otaM(!h}4j6k~ZF#5TLLm`3UKnUox$ zH3VkVc$|~QW;fl4Vj~MZH|H8`x20)=2RHD8Qb+z6sLP(#k<;Oo-5(hq`2zQh+voA% zU`ZKFDOL&41m{m$*amWDadP0t#E#i?4TW&!vJaNkd;-Shl3(ga#p`f=UNpTcd%KN= zKnH*B8L6ABMA1mPREm^w>HX7bBu?s^>E5xQZaDj9Pko=D{s8}i>i4IfuCRyXL8&^D znAkkp%VREYcbclu94Qjex@o=YgmdROCK8uWaIl_`JBtr&C!2~w$fmGF30&OaWi;0` zCW5;4M1UD+3vYklk?xh|-f^4w$*o>&fFJBgW^P*XZyNq@@rgs}`r?-VV#?gNvAKc0 zknuWvf(LG9ataPyOg!Qc#ewa}jQDb~W5J~Xt}JY7Ae14svQ`_aEz6R*WkE!R8cxp9 z#Fut8ZIoSsZUPA>wpy?lXE2VC8TG3+;k(SR&!76sOX%4e@bvZic{UN;vwq&do{4Z9 zURwPOSvd)N#)?Vd%v7d^cjIbO23aYjDYAp}aOB!llyJD5=`9KX)5R#*Gh=rTu8D%5 z1XWRLm7s+!>WZ@-&UH#E)Ot#yzdwae%i5)+d{A9W{e#0Z7_KNdZLjyyQ*M^k*ESFM zzRC(eKHvrMZ%wBZ;6O09)Q-94gejX6EE>BS_*j+!yoTPk_06i(8tB^J2alx;~$XXPuB{ z?!Pe&z{ow>B5y#Sk^Xx0bcHxX?DQZJp9D_W(Gy_0cLhkr=R`n@S(*mB|Chb@YEoTG z7KH!Gj((cC8V>Rj-&2DCAwUQ(!Nk22@&%tQb7Pr_7TYpW=_Pj^R0oU==2k&-fV z<;u*JCS5X%y)rF!Eu&BeAhTs6LrRikT6GSaipp_*eY!4*tHB?R z&X4=#gZp2UYkW{@_0eZMtD{+C>_=I|C$86LB|*ODqb={BDhY_O=R7MmP>!m~B*tD; z1>`x}{ z#+-fqk3OKfALWkZ*&n49PBZoJz?;FgCy91!n9&nfyK!t^-ui772l&zOkN18A?)cu( zlb0<=c&U3L$1V6{Z#L0xM79?{0dQW5E*ZJ9wy@h#)tvay>h4MKq(JG-kh6V#gaF;% zE@fDFp1Zd*3%whBV8)Nnx&wA02R;YgeO9W9yHM4hV8^L4H9olS84*rX=u`;xJP5gw z8IMbL+>iJ}j3QHaPr5a9gXfakmmqE@`~kuK#mv%dQ9lpHZr&&oHT8sS*>h#_lSdwm z^OMLp?h8GcWQS2l$40D1&-g9+%~U;7_2L7{bLW#|Y7AB{q;~7~!%IaVjGwFn7c6wk zj>z+Y4@CWMM&Af~^y%muu-B}SxRRIMNnhx$D!C~ek0%HDFIPZDJxeb~jSWvJ*X&F^ zOJMtpY7wtFP`-TFNnv|FpmzO}RKbVB%E<>#OfE4I&O&vSj%0co;2NX>e98=WrnL%8 zS{@cq5V%`?iVMsLnB@$=!t5ncPJ&6cvTc-<3X=wwi;evHHrOLwfQ@p`E!uOwH+fGYKh?N8abDs&8d{Xl_rf>DQR}2=|EO# z?xo>=3UB#wkD;Y0SgPN zKUs|zxE!T_0&dMxGdfg+`iyaSXLYj&PdMWH_G;}4XGzxu`aLKQyG2fcKIOG=r~@+t zNny#n*`~J9sEaBz&Ih5j#*j|CYo#L51t8IL;4qr3wQ=6nS54K__x6w;f+ROX)Axmp zylhE5s5AFSJG{2K4B}n(sAhp@t2gtgbVnMw1h=<^$#7$%8~6?e zz-fvlOb@qrTobosj!GhJhmQ?*;0uD*84JrTu~G6Ew9vJ;n(gs~o@^wA2X>vGtnoK) zfVW1xTth!%?ea?P_?JGd4`72VMibL%*_K5pqPy!)Wrku#Ey~9v2asWXw%Djs!xw1` zP@{0nbxniuLKm2-c%L2?ydliIc)BMLYbn}_@Rka#cY^2d&E@x!?48x3?jLZZ+Req< zwWBP2&lg%queDsrbQR#h42uk0-e+x32gN2jR}^@J;0495F?9$uftYK%`kW(WuFFn% zX+2lgwnJ}cV|cSb@;NCntG^H7zANM_$$Gn_Je1GZewx2Ke;B6INZd&F4tsH5&gmB! zw%=G>UZcxspFq^@=-X}^QvU6E24 z4RfxrW;wjSiuN;GU#)~0TrN?*!FR_&w~$oo=L*h0oNzY|)Hmz?m(Y&{yS!4{4oCsa z86tGj9|IF>9S`k&t}Kk82dNXpK&BEyG_i3z+6<>nIEWKgu(UBe_6Li3;Gq(#F8bK0 z*&RSbVYF%w79DuSW8ho%)oQsZ)zk9xFooV)Pzn$oV001&7I~hVz%tiQ&u#$ptjBa!d+%^sP3eF5bDY*vxgk(o0d4* zuC4Ykm;uCjQmm6r^nsBi%Plkxl zE;57;$cUd8Lvbxy^9W4VSsUK8cZvjA4!qe-3zWuHebsO0ZN$a)agW)m+H{BUBDxZ! zQL@0a(Qe2qdi$R$TJkJSF2g2kbANfNtM1#i%@f=s^^V82bxU|+Gu>sn;)fH^nNMe& z63;q?v>NOcdIL|PwXn!nBr-#?QN|MdK!9g9sf+@GglDa#K3h$=aj)oYl9p7ACl(Zt zB!i`I?7R_G>+7-i2Kr!!HV(xKg~t^OyRSG>r=HJ)81f5R9U{p;E>!X4*AFN!R(8Gm zIrMzx#n|&FHA8D82uEHL%4)+AD`8Pp#=&a`#(Xf*)#WRIPhzrPs`d2=xa8W;lLlC` z*4N6?ML%(PTVjn}M=zGdW+!7CVYNi@K4^{-azP6LD9Py*Q;MbmPHhWU-Cos16!O zICW~6_+FZKGk?9<_&XtN@zXs#ZEvY~V)_uf$3{yYTu@0U?3*o<^W|{Rnu@`yXYZn* z*TH?t2nKX_PW6|0xV34+9ZzVp{Y4FvrC~VX<5xoWv~=c1G)`@VPIB zbpNB{YU`iI<2SPIH2wrSJQt9=bsnCF9kXC=`J)!{1EhRUtA8os5DD_@nnn=_W?v7MVry;H>v~(xlOvec9k-}akQ`HKDm0>Z54l|y zFYjt%6gLiS<wh#Jn^cWkWsD<(3V!DkC=WPwO-IAY7=5i99wB zJpLYjunlnXF_mv|+Z$gGMc+`J4>m+^z3#f}h0oLj(@DbeKSTToC57%oWlm*TAJNmS zic}tgTq0BXo)$S{3yR6mKb`%A+egpjrhau06vR(f25|J*2a_Kb&&Y4C|y+zUl_iq;Y)nf@Wp>r zrmmdluI$-WmY%s+4<^LvrN6QGH%>A-RI6ZC(SNFp5wFG&JbcQhc5r*ALDWsv$HPgn z-!bYyTq>l~ob?Q7yYs*iLv-2{zuUR$BEqAVJlaytAxsE}x}D=IKZdNGvu&dN5g@F% z=`>?|69TZMm7p!`pL?$VDv6S6mrGxGmckX8ua~9ckP`wvV#QBmuQ~j$VGAeUXhf%m8RSMy0`00#i2s2(S44kxo*TcHs|^hHFq5df%jx*AtzW9 z>deS@G_^bHnaCsedL@!hd*WyP{+8W7lkW}+GF*Rm(@GY9DvlIA=S5v z&8BUlOG7hfd$S1pGj+dQ3WM0C0$x*z3~C#CFOru9zLmz3=8fm$X`(M@c_%h-jokL; z>(wIX2mNl7;1e{4gxNd0okQQk{mF3pO#wFO#l3~QM|{qt%d3s!6YA_!wZ~g<(D(A# z&W$DnplPyg^@miqX{-ETRuo}2B!N(s^0~Sg?}%~RXLAMNhvIncO@J;2@QgCdyCX=( zhi(tY*622W{}g&buA+5B>Vt0c_s*EZ4{=#>7Zne&^nJm)db)Yu)cGv7IRCK?wtuEi~ zEmJq|7rsq&@+QA#5HYkI97p5xZ19#U7IbG3mKxF{`x1FsQ-WXA zlunBNi4;-p#$tA$$XVM*Z}zvZe-MYIWm}b2J}HW&8v6Oe)&o89q?1A4)X8pj=O=3i z0{vj^xO&DNm!1@d<1=b7shK%D28ZX83^!A9t!23ZS+n_4nJ@boyw1}3dSEy6-L&ll zG%%5f=5FEwQa+x7<7}!kM8UTqd>E7PBA14Y>#(MXyutPh<4E+Hkt{#4&yInYrYqZt z^3fyqHm~k5=rU2rbQN2yG=JqHMGO1-H}*$lC-NwR^JeI2SLea#uXM^Q-{qs6!>=^{ z${B+^Z;~ol?TI(5niwhL@cO$VUV9&`W&j)7$na z1?`W$XeSqe*0%{-&i-VQ>JD44qv(anlg=;;yxQM|X%Ou3V7BC|~^z{mz2Cup*MNVoEKIN#;rEL(E8V6o4u zDqQ!2zuz?Y6w%eD!SU>B)1W@)Pu|JLvjlrJOXBtkcbZsrv2lc71N&2cyy^+6+9#;i zj2;DhWg!(~&Kxf@Kyp2zIiOmqs;N`0C&3so>ko7yR}sY^!S;5&6UF9y7Iiw%tjW!1 zdmR>tJ~;Wg|SVR;~k_1JfHVqcx0k85bC>8 z+Um3sc{u1!br*g^Q|izZ8=ss0*khyO+lI}TmPZvRaNxU7iy6GrW5rBud~CI$$7SyN z{wba5^X2ci$raI2LosRC>b}H`5v!*AL~XvVMOnp0z`si;xnlT=AEL|99i;s1YfH`+ zT|E(XwGn@ohqx`5@HX4zab*bb!7lriZE;2Cm-|ejKiz$LYBK!PTsUvxJ=q9Hh*w(5 zJb1*Nz&QGOj!&pl`Y~1$A6x`02-}rbOwh}b z#jF_yc}DS*LJJk7X)8HCVC^ofg2V3G@9J>CysM?KZ z^m~qsM_K8QbD?iyhLP{ME$+nwT*clT&EvcEzNQek6adwiw|?ZsxN%Tie|?n|ebG6n zREo&EA~>J>iwCD_!&S5RhScBla~x10+V+Qj1i@ebAS@YI{1kP6hR36p;Huko>8p@} zCrKUn&vl-Q=RA>OhkK2~!|I5#!Zs(v0Hsa0+mXAZKJ8$8Fg0+U43Ndj#C!cdn30oa zXWW{4>j)I%gqBglE7*C?@$He4id&3xC9WqT{2Wjg^eCDAJ<~hBLGBMF{6>F2lKz>p z-T+@_fd4pM{*|3B4@mf%s>qLJX{g`ZRr?2D$NpE zF#YuJ;SaoY0b=B~dk$naF*8=;a7NF3 zfON41sHcmy!)dL_EVNio*JfLr(chUS8me+~ULPLC=srjkeLp+Bxl=&b$AXLKP35 z@k#LO>$OW*i2HCP)2{4KrRicd5bzEX#S^;Njry^NsAHfzVo_k7v*Fq`rZTdh%f;HJ z0wgh#KBvt0-NAA#Bt^P|wxd-TbZ3KE>s>2P^Gbrltq&1?n^|?(eM`M?ck+M09RGElXhNCJvA4WU)*oZ6n=#)-KzIX5Uf1txI-&u|m zZ{?Z0*MAa9{E~5S4ZJeSt}ZmlnneIvf7P47oTtRABHNE- zK~rqW*j(c2F-$QiMfCjXf?O>-jBmSku{9^j8pBhdpG>kGiSsvXURHJBJ`DAj<=lH} zyc`nAZ}9u=Zazl~=IWXl>Sq_mQwPxtoN)$Q^2GV@;2WyL4J6Rw167jxg)g+YIlzlJ z2e-tC@pN_07BU^TnTg`FgF)WbAy5M`anWCQB)J#RT5~F-P|s>_OEbSI^*TDz-6!Gb zdB5*z9vhz9_*A{?dpz#y%c2_*krlLz zq5$_o7bskSNOQlZqM9(vC`WMujgETLS>~A3V#Xk%)nB(DX}yT{lQbJZCcY`V*4I*u6V5*iKl6+Q5m z!L&P>%Z{@dCwe%yhIS|B_w#qe0O+4S^`{{s_b%0of)q48r|LDut_9ZIC%97holjZOc zm8xBRs!b8qUKX)8nj)jvT@SLQ3r_}}MR&dWx!LMBjvw>L`uP_Zyj8;AZ=g*c4BNkX*MU;Fr6##x9fzEN; z%xt^^q(zfd07qOd+PewVXLbxSeku_DSIG M)N0;_tq|NAfhQdB(^DSJr1)@#)x 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%0D3!9}y~gNXEFk67GadNfG8&n+H>u zmKm1lRex41AVu5xVta^0Ir0$nPDAIxpm-HBn(Cs!>qz`|cgyZl+r($u@aSWY1g+Z} zDvN4@kx7q?Kdn&aw=2VP#g^|@?fQhMARtSI{CLui>@_72J%P}PKQ%{6)FDU0xM9r8 z6ekE=`lx71xg}3;Iz@+qpoep^um&DDPf3&=4O+B0kqg+i$)N&PWgnlV;y7tGWQcGF8{`wc^8ue z!}T@<4F(0VYou&s67#T3ZKX`Z!%sJ!BgSBl4f}&+0^z7hIkECLC+dne+*R&flw%XWYyA9VY)SFxSk9psT7_*< zUKG`l!X0espXl!~Oj$9K*gv-6t1^6YBmIz~D^T7)q!LYwc29fl#k@d=3J60w5~@N4 z=1D)TVm>bxJIY&RqPdhnep0tdp0`g)x#Yk-p#sROXk^kQUVEt>7#O+W*Xomn#}gBz z)g@I;X*{{3-nh1Iw7Cvn`I`?jI2lHz$p~LIz6s%oZ!kwkta;F=i7$?WFy6h+Gh=0L zP&MTJ9)&nVgv?J=nz?jkOVKqNom-dCHWsrjt^#$*f|odIow=8WJ?Gx@`*Swm9n#!C z2dON5pdq@36G2&_z}&;Y$T14C4*KDvU2=50qG~Ep;`1EQ-D&u7dH(3y# zN-(A-pL(7L#bU|?wsim=EtGlNC=!`#c$fsNjEOj{M^&4$JLPVInNhw{3LG6O3nQt< ztPI$z2GNm9(onOhDtU!?C-ME=r-%=6Cb4&m)RsToK#(GQn=Kv1JK-x(H$mJzOW@6A z>AAA-kx)IuNTKeX@LPw+9A^H=4S`BJ$osw{MUe|%U&7r-hM%)}Tw%(m6iFdD#uHQY zRx^V;`dhd}F&A;Ve)HSIIdc*Bc0-9LL}7brVH+dZ#ZoZ_@NM((bcp(Tfk_A+r28Vb z@aZP{B2sAvRxm$J3=C1m>ptW&eRXTqWF7h;zfe4nr7*7nmIZs7u%s{DgL+K{{W^-k z*?OajmHG#32j#~cIS^6ziqKOHG+lDf#3)$r10=7~9MpHC#j&nKUS|x`UKF#s?+XON_aXgvwVx-)FMa zv=PJja%;A@?W=al&98J~u`8wK%1mqy>?Mkl-=(V&Zo``5?!PMb!><31Wrwv;Wlkn9 z4XR=%9zo29Lco`%2)Nb3T}~`)GlS@5<03V%`^>5GSw!a7qp7dasbQli85sNYQ%-y% z=9)Rl2DP?Xc#q`bl4%cV@_wi~J14?bmY}ECGJjTaVC8yGus}F_UzAIuOB{|2K?zQq z6s5xu`N6%0o){W5$TPn^c+YMvogyDJ6LqwYNhr}Uhx9` zu*lT(HA=__O+8m{NM6QK#9r6StACuq_lzhZDF#y-ovs+4fs>>RZ~ItN!%z_ow_OF6 zu?xZEabBmlr@r8aUW%wDDd3uz1Z=BhCi0wfl!^!}Xc&FBb%6rbNc*pA}Q@ z2I{;(Sd)|s@9rp-+6O%K)l1)gAgnpVX0>M7&M85g%E{0rA44p3GpsxF+kyejEV;c` zMB=Nl6_EK$i*`LON{#fE;n(87aTvXbEVS>Dbgw?9k(bwbVO~I0G}E|TdK)22onWZb&bpsn2c4r%nNe)- zAl-e?%dh!^xdn!X5=H1^waU+S^0ktEjUw_NsJ#ZfzVPP_E7i$Pl+l;h&XXRNx{H?f zFRs5~9Gct@d%xf#%^7`9$h$6}ANhru&RnACFq|lzwm3qyb-<$gBte&gmjf1VA^lKQ zJUy}q271yAij^d~yo{EB`Q#6MA_P&LB4TvP^qLp7^@(9iKYV2=D)q#^ZGFst#a%*)}{31*8g{i6p*h zg0DvMJal1Rlh`hyuC{~xo~W(Yo2zqPyB;?xzdFILjJM#f?k!-_v?H+2ke0+ z6E0_j6g0g_){Cc}LL)cE#>W(_g*9P38h7p^;PK6q@^igmP;9#wuc!9rhFjNXWoeh` zI42>{l+08`=={-bEECCbzhwWnp=Cbp%YE^ilycXZ>GdvWfW#;wkN9r`t;{vs~{t2(vJ z^t&>7DY168zV_dQkWe>vd7Khe%B!VI!S6+m8*gMEY_2wb!BBgyWWo z7weJ6!*^N%JI=jP?sItW2fK|D4_nsI^7zL$ZBVs`ZO>9MKT*e9zTKg$x)y}~+Trih z^UE_b8Z1Xbn@_P-=+uU@3~IyMf8_O+CAJDP>g`>>OaAyhrGPQY}Xt6v}#74*|SQyMf97_xzg$5@okJ^Y=D*8agv)9f{-8xQRh%!QtgkX^W9zKW3d_PaN zZ8T$2eCX$&MG{}k2jwZAMvEVZvMa1~w`er&jdty})^RUWA&E5<#*C{bfuK}918P1F zu*u*KqLUWhd4G7+)FeipH@pM4#QhV_c_&;`#6=NCS!$d%sym8B7Nio^$lPPEMZOLb z5Wv)}Te!P>^SSO)oERN{1LGW50b1Pi%wcxP&-Y@=-hkK3dD&t4za+Y83;9~XvK5fp zR7a?EGR=>r-AU63Xs{c3sw#(&-!NVTpZGTU<5mRYVxcLt(NZ7j*1+PvNf91?7rPx- zsMtY-uzb~OnKHVnkZ!Dm9ILl;EREt1nEt}~neXX`C}h-|*ai}+4B=IDv%TMa4oYQ1 z4<42%Iujm^Ru`t+O~m8iHt{A#zCi-pb*Slt*NQK@BW2h_AShxeMc%O&bNjA!>gAK#q@?WebuJJSmljY2=N zzDuq6LYq(YxYP@4(Y0M^4SGNLV^5Ipq=y6dyLpr?HT}fGZZNDxgTJd6{|>aSXbE9e zZ7pYEje-ibHd8QJqtqabpQ>0%bcLWI?!=&zhE|@dul%SttLL`4UPWbI{svEh9=xlS z_hx2le(QC-Efk-%d|F$Zxb6JcaqQQX-Jed{CcVahQ%B;8#`M6>KQ!7ec@5MU%#FcxLcvp#J-=)h4v2sgYuQno$=d)#zViy(?R|b!iOfo+b^tE zpCM68RXh27)zH2=36W^|2_fPQl=ZT@m`J zW*?*B#5U)y^Sd!9wz3esGP(aWN8HVR9-~KPJ*~I{I=Eco0Y==RRj8POXU9+X&l)$$ zb@T6p0J&Jz-P%ZQy=?Zhflp>fEgX^ASb_^VR2xkd8hPzB7GNP)-Llo(f(E6oP}II% z3y0ZA0Zp>EC}nafQuDCYHX3ypuGox})d~teHY<2Z8bWquU$yE&3RPt-0&8w*{XlW5 zTdJ^>F-{&}vzw~JQ6!$U_4B{~{56GiiP5c(P34Z?llf;XFx9jPV`0!NYHp(sa?hYW z#L}gr0(F#3-&JiQVmKrNVMembT3f6`JMN*r|4v$#O&}%sQ{hv{VptYA`9B-jIv!25 zohO+s?BA>g?~lyZ3FPczHaCib;n?k?S8`v`aJd8r2QoL?_`G+GcUT z7OVR6%c$<%WziuP!l0B^u8A?E+!j{KnaKKdvirmf?C!7O%CI8MW-t)?8aryXZ4s3s zeHWnx0Iw`@!eMTSZ)A0x2%t z7Svj;hQa7zo7F*NaI}zxA|BVa#h>YSG+~-rMI$~8mnk=C--ncNL9)*rq zjtG8cp%c!KO%JYBy-80lFOy)+p{!PPd|=`iyW-{~baahXiyy_=d9(ou3n(Lwh; zJPak{9c~PA;T9(-zo0{u=IklC*UlbX+T_QbJHArVw`j#CSYJyvCTFg}A%-d`DY@t= zP*3orWzo)a1MHnNs$ViWH{<5f7`Q=qz;h%gF3x|Cv~4*+jiIZeK-7RGnuRX;J>T=N zZ_H*?K4>L3$AUDAB$EPu-obvWRdKt#^}R;k*F76IAJ*-LaoA(9m}uy;GzrE}Ty0tr zzML9@Kk*sx3~)o=X|j+zEyH)br@4;<_VO?+FNSsw9H`$lKJZx|cwQea#5mT)ydJu# zu=S94ExH`9{!pMTwe|5h>2~0uj5;00!wsV<9<~;~>#|9bF72jKKwAo}1Y!CoK`&cb zuo@>DKY6g#)K;v`43~85p(EG%rHYr#Skh0i=ohhY1*R~z)iGf`Y1;jfi;nde5v-}bob>UFpVQc@$`56F zNr7X2Bio(en&&yLJw)@no2$N)-*}$vIp%0hSOmWCbzLoGC`?teOOK8h7=;q`^s*|X720sJyR-aJSnTrZM6BjL^9OX(J!CuY--`5 zc=yj}MOFtlv$Y|kg}5f=EHNi?HJaT8eIardS0H&4A?Z(2oWjbtk%k4W)%TJWD|H~0 zzrX2SBkX~3B(Li4beWi z(TJfyzJpLxkX#m_Db*DHgTYVIdEiu6Y)W-npLYbu+zF!ScJdnx@;8%TyzeV(AzIEI z+{3pH&yVX{n8}_hJJ4PCV7>MrY;zVBoaJE$vTUPI%%emlq>7w6#wJ$z{3J3{gLl|g zYa@!w^3@t`@sk(^$yKR35t!>%iEx5$uWp3FTO{qO7b87MPRvN=o6QjqR>kwjE-K$L zo`UH@+G118W}+yXPmr!WYWvt&cb8Tt!8=!zP{3jd0k54YJl%S5vEQ&)xa&>?e&q@( zUF>}v+od&%S8hqgvoPQtDZF$G(nri{^GUZ!zY3rl{P<|YC*jEFny9Z>`5y0!VQe#B z8?+LZLq9w&%$EDU#jM~Ur^;+378J)A1m=_$DF z-}r`!>6O%KCWolCQPl`0g&Lkp|4?^Pv^M_e377at8D8>Rv#}@8Q66US1&nbz3N+2M z7n`6{P{*=|RGTSc#AZr&OY}1=%N_qt@#p)6x8`_%-o!u}B0x=J2i>d_)v|TEPkQ?U zlOA7VvKtdoRIYX3W6qzYUGy%W?cv9Sb}N>preoar$&@!z50`7Or@t}C7OM^rxg@#2 z^_izAh9Q;TDa0U9kzAwIga%n$ZQNC|P3px158hf5cB^{p>JS7Te#zaFDt+~w250#P{ZqL;pxANuiq1SCecfnJ%OmRUcZzQX5)cRN6Z zS*Kq)UO)t)a`p&zzhvU6Zd@P%O$t|qUG}y9XKZB>F7%H`!t$oGvyldCb>dZD4ZkHL zDZ>%YW{#^x!-aWPB>C)_yHZxH=Z*a$vU{X5UL+O6wd_4EOyaKGdBuGxNiotDnXd0B zj|T*fOT>uyGGi7qBvBr`CM$fsw~VJ}1)I;aEy#^OZ}RaPhNj)eP<>R#d1$5B`gj*+ z=AqsC1BtFZY-Vwih@8BPjxypoA?TmiVOJAv4gwFSA2Hz(@)kPiGr2}dE`OaT3vH=s z&x*U9q1Mz?B2dLoaN~`Lc?RbXv9vpbi;E-g?4tdu>ggjBTh{#_5t-ZT5@;`qx|3N4 zFNk_|@^;PLwkJWTkZ(p(<51+CkN1!H6epXn_K`Z0Yym5buaz-9I!SyUd-S+}lUGBU zy*p$qdoWzS_sjF9f$dElh82d7o6NKh2n&(asjt|8J=@1lps*RI4y{m}ZR#XqUj-EH z?Vm)%I>PAeKaz`VbL(l1((tb{mgg|9Ih3=Ah?jKYGSd>;J-V5tO_!p273TrokqZpk6&6$01ga}KcpB6%1m~}3qJ7i|M*)nyr)g z-mcN8V{@DB>=!y@kJIap(^lhO15VkqHx~0Bh9sO7*EEYrY ziLd+E+DG!-rLmQ7s?w;V?OTB5G0b1!7^e#rYsx4kJy4V{uX5nxuwb*gmjzZH-(2L( zv%=2n?|N5QpN189yOskvSfAC%Vl(u+#FvIlDcb^ppG&LDmX9m8G=v3>Ucq2u9wD5Z zs)$^DyV;Bc1=afN;6F4B4lK^e0I1|NC=VGRGoIXOXtBx3@mynjj#V zKgWGSJV0?586S|r81OMbNJbRMkp4C9e~247IN00=PVkyoFxonsGdUaCI@o~DV&^Qx z`Q3J`9RST2pic{dH~{npI0q4UHqh46<-b5%c_45f8#r;~h7AS90)Zxc^1mku!+-4m zm*)TB&&=7@-p&$ucZ1RWgh^W?yDRb-hqluY0w}E(_~;-|doj*Mb+C7KVRUsc1s*HB zB3w^{91Job(yV_eu@CcnI42O}|0(i{i1|tw#G!x!9f6n0A(f~GTo67-tPTL;KZ?8} znz+!0{xKlRWPm>=2yxy6=G$M;Y(Y-u|0O0SCdytdFu(MHQw=l_n7x3T{R^gptFy%w z`SV}YRGtFNk?Q)N(u5}ZE0z<;*vR>+))M)CH%1zeBn7}7q;YCdU4Ui+vUIyD+|qR} zmRSI55D+Bf3?#hyH#i5Q|23EYV%`rRAg#^<{$w2JH3DfeKDW+C1yslAV$Wz|0Wz_+ zcLnM_SMqEMqe-&8z@&gf{*%*5hI28UL3XAfTO&&wMmHlH%l~5Xe_H*C5DjoD3V4>A z5QfUkdM@gf-ONcW;jy+eClByu511()1QHk58A!kG`=7NcT(roYrhP0j3oP9Knr@bM zX7*=>7H6$E?t)#Ed4T&^1wK-Uaq|nGM;qi}V&iIh;i3jm{8yL-Ieb--Gazj2&Cgz< zPmAVvXu;)|zGa5)LHx47sH$-C+br$WnfLQzw+@93@``JjP_2eg9;{qlaFDt7VCo3lxCp$aH)RfJbo5|AD<07~H z+g`Mc_e9&B;GoulPYGgB>ze<62X(^2Wk)5mC^EnaL^uzCume(5+MRI!UQB*l)PEr= zCy?7^2enoPqFP`|#7FKNfL5 zm-f}%_mg+#aP$BxbihY(%9P5$T^Atyx1Jkvrh}cr9g8$xh;c=KExsfQ zA_D|=@WQqWT;SiE}VC71I^x6i9=3g-y&M5;s7AYEqq-}gM_v}nB?V9@^x(xFGC_oep&^=xJ zfgL-WG84$|(vHI~V)s@sI~3F?5Whmke<|ls2h#ep_CL=kj-AAR3#K^MnLzmvOacXU zTB&8=NNjirZ~0p;My@UvR{&^oe_o0U6bi_J&bg=OLm4=g_-ugx^r13v{iiwZ8GE_s z@IuM;GejQn{Eq?8PY$68daARb%q%?&tn5#c=zm{7I0xibXzo5W01yjgw5NlzGVt_` zvq3EFfb#=3HU{q27B03nF7^(lW>>%?f_8xK1(?zTa!bhk1x#}`-uWl-&tWNu4+kj* zu-;DKgJh|O_H2mL2Wc1`?z6M9oOzt)9K7B>*C|dwgsec~3YoOF(_M^r6(nfRJ8auIk{PyT(|)I4pw={H1$=1DhVY}je#ub8SwuF%)r6P-UQ_A3_Qbp zc}H~j<2^xRK#=%=f#X6jMk51>B_=0wPh5h@*7Tw8GY3Jvzo0NF60v~@aPDg!S7 z9U4!`hgn=gNlsBqUP3|b3gm}k&3}>sx`T--8n1@vHWQqs7BPixIE z&L;vEoiw1B3aNNy^$So8oa~KVozFas^@q0soY}ut{?p1h7MTFbyQd{)=45Z@a+Rgu zP-);=2LN-jhXSb#c7t!2N|A2-q_XB#`FrBV2PdTP6&a4 z`bmlU$E=_NT+W%oImu0ofWo?sy@@r@zvb**veO~hZ`19DLA7@SBoz*DWSiA&0^o1~W*|cv#|sdcEL@CCPTa|5r~9jS z+~wu~3>F|WNT|%UzccgC9_d*PcK(!_s}5GGuSwa-HVA+dl!6@j(;bZT1$W<5Ly?#gju$*_gy z9>7l3zl@Os*lIu1S)2|OFB7<(HHlAqR-h~ma}Lx=m*LAQhkZatniJR^-R1i;Q`q?% zc@ZGBI-`a09~0^<9!{&|SmY)4UwAmluP)6}C#tD#!gQb{_ zC2$`85`6u36n8BH-`oOB4G}Q4+Yr$W0kEi_X$B{{`Nh}CFR@>zH?9Ck(;xA|5ty>; z#86O-5P%gV7XgX@fJ#pGC!=z@1msz|JDs8&i=^ND3nZ|??O<4Zf9($WNQho*pVfe_{@>b!YNHBT0hE*wz0fII~9lkRc@kh2GN z87?8*-v;!o;-jb=U_1dpzW`1MmK#|whX`oY*1<&;WCLsl0Fn8{bMiOz={I~hAfT(b zF9)pxa(1vptH^--Yw^KpjepCAk?)h(R zoP%?^$2nwl_e%RhoQoBB*2Fwr<2e=?*ZB*~KYa%;yF8q3rppQ;GXdQTK`zlo{TvaV z?ym^x%tehahP|L~?>U&Kn=(N<^Vb#^V*a&{<2it*n}wYAtYzTu4v>JC?)-EP(&;`H zrxSrPaGe_@(uJ)^&OtbR3+;4jSq2XGfJC@*tabXT66D}n10YFXHN^Vu7*5}^fvmQh zKmHTp+zU|W2}w|4%QK0FZQKtWjm|2_fxMEsFJ^#JOB0Io6| AMgRZ+ literal 0 HcmV?d00001

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­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