From 8dff841ef0140a69972bd385b69b9d277e5d896c Mon Sep 17 00:00:00 2001 From: Robert Dennyson Date: Fri, 2 May 2025 17:10:22 +0100 Subject: [PATCH] pathrag react and fastapi demo app --- Demo/.gitignore | 180 + Demo/INSTALLATION.md | 600 + Demo/QUICKSTART.md | 125 + Demo/README.md | 453 + Demo/Screens/Chat.png | Bin 0 -> 67262 bytes Demo/Screens/Chat2.png | Bin 0 -> 92524 bytes Demo/Screens/Chat3.png | Bin 0 -> 121418 bytes Demo/Screens/FileUpload.png | Bin 0 -> 86241 bytes Demo/Screens/FileUpload2.png | Bin 0 -> 81660 bytes Demo/Screens/FileUpload3.png | Bin 0 -> 79642 bytes Demo/Screens/FileUpload4.png | Bin 0 -> 101329 bytes Demo/Screens/FileUpload5.png | Bin 0 -> 94449 bytes Demo/Screens/FileUpload6.png | Bin 0 -> 93815 bytes Demo/Screens/FileUploadFail.png | Bin 0 -> 107906 bytes Demo/Screens/Knowledge Graph.png | Bin 0 -> 427466 bytes Demo/Screens/Knowledge Graph2.png | Bin 0 -> 305500 bytes Demo/Screens/Login Screen.png | Bin 0 -> 36651 bytes Demo/Screens/Login.png | Bin 0 -> 40356 bytes Demo/backend/.gitignore | 179 + Demo/backend/PathRAG/PathRAG.py | 562 + Demo/backend/PathRAG/__init__.py | 3 + Demo/backend/PathRAG/base.py | 135 + Demo/backend/PathRAG/llm.py | 287 + Demo/backend/PathRAG/operate.py | 1239 + Demo/backend/PathRAG/prompt.py | 286 + Demo/backend/PathRAG/storage.py | 341 + Demo/backend/PathRAG/utils.py | 527 + Demo/backend/api/auth/jwt_handler.py | 75 + Demo/backend/api/auth/routes.py | 55 + Demo/backend/api/auth/schemas.py | 42 + Demo/backend/api/features/chats/routes.py | 197 + Demo/backend/api/features/chats/schemas.py | 63 + Demo/backend/api/features/documents/routes.py | 326 + .../backend/api/features/documents/schemas.py | 39 + .../api/features/knowledge_graph/routes.py | 91 + .../api/features/knowledge_graph/schemas.py | 21 + Demo/backend/api/features/rag_manager.py | 54 + Demo/backend/api/features/users/routes.py | 41 + Demo/backend/api/features/users/schemas.py | 22 + Demo/backend/main.py | 154 + Demo/backend/models/database.py | 92 + Demo/backend/pathrag.db | Bin 0 -> 57344 bytes Demo/backend/requirements.txt | 39 + Demo/backend/sample.env | 70 + Demo/backend/start-api.bat | 26 + Demo/backend/start-api.sh | 33 + Demo/frontend/package-lock.json | 22850 ++++++++++++++++ Demo/frontend/package.json | 63 + Demo/frontend/public/index.html | 20 + Demo/frontend/public/manifest.json | 25 + Demo/frontend/public/robots.txt | 3 + Demo/frontend/src/App.css | 192 + Demo/frontend/src/App.js | 63 + Demo/frontend/src/components/CustomNav.js | 76 + Demo/frontend/src/components/Layout.js | 467 + .../frontend/src/components/auth/LoginForm.js | 54 + .../src/components/auth/RegisterForm.js | 93 + .../frontend/src/components/chat/ChatInput.js | 117 + .../src/components/chat/ChatMessage.js | 137 + .../src/components/documents/DocumentList.js | 93 + .../components/documents/DocumentUploader.js | 291 + .../components/documents/UploadProgress.js | 123 + .../src/components/knowledge-graph/Graph.js | 276 + .../components/knowledge-graph/QueryForm.js | 39 + Demo/frontend/src/context/AuthContext.js | 131 + Demo/frontend/src/context/ThemeContext.js | 166 + Demo/frontend/src/index.css | 33 + Demo/frontend/src/index.js | 21 + Demo/frontend/src/pages/Chat.js | 233 + Demo/frontend/src/pages/ChatPage.js | 212 + Demo/frontend/src/pages/Dashboard.js | 89 + Demo/frontend/src/pages/DocumentsPage.js | 105 + Demo/frontend/src/pages/KnowledgeGraphPage.js | 76 + Demo/frontend/src/pages/Login.js | 37 + Demo/frontend/src/pages/Register.js | 37 + Demo/frontend/src/services/api.js | 122 + Demo/frontend/src/services/auth.js | 52 + Demo/frontend/src/styles/chat.css | 435 + Demo/frontend/src/styles/documents.css | 234 + Demo/frontend/src/styles/knowledge-graph.css | 113 + Demo/frontend/src/styles/theme.css | 596 + Demo/frontend/src/utils/threadStorage.js | 45 + Demo/frontend/start-ui.bat | 21 + Demo/frontend/start-ui.sh | 20 + Demo/package-lock.json | 6 + 85 files changed, 34123 insertions(+) create mode 100644 Demo/.gitignore create mode 100644 Demo/INSTALLATION.md create mode 100644 Demo/QUICKSTART.md create mode 100644 Demo/README.md create mode 100644 Demo/Screens/Chat.png create mode 100644 Demo/Screens/Chat2.png create mode 100644 Demo/Screens/Chat3.png create mode 100644 Demo/Screens/FileUpload.png create mode 100644 Demo/Screens/FileUpload2.png create mode 100644 Demo/Screens/FileUpload3.png create mode 100644 Demo/Screens/FileUpload4.png create mode 100644 Demo/Screens/FileUpload5.png create mode 100644 Demo/Screens/FileUpload6.png create mode 100644 Demo/Screens/FileUploadFail.png create mode 100644 Demo/Screens/Knowledge Graph.png create mode 100644 Demo/Screens/Knowledge Graph2.png create mode 100644 Demo/Screens/Login Screen.png create mode 100644 Demo/Screens/Login.png create mode 100644 Demo/backend/.gitignore create mode 100644 Demo/backend/PathRAG/PathRAG.py create mode 100644 Demo/backend/PathRAG/__init__.py create mode 100644 Demo/backend/PathRAG/base.py create mode 100644 Demo/backend/PathRAG/llm.py create mode 100644 Demo/backend/PathRAG/operate.py create mode 100644 Demo/backend/PathRAG/prompt.py create mode 100644 Demo/backend/PathRAG/storage.py create mode 100644 Demo/backend/PathRAG/utils.py create mode 100644 Demo/backend/api/auth/jwt_handler.py create mode 100644 Demo/backend/api/auth/routes.py create mode 100644 Demo/backend/api/auth/schemas.py create mode 100644 Demo/backend/api/features/chats/routes.py create mode 100644 Demo/backend/api/features/chats/schemas.py create mode 100644 Demo/backend/api/features/documents/routes.py create mode 100644 Demo/backend/api/features/documents/schemas.py create mode 100644 Demo/backend/api/features/knowledge_graph/routes.py create mode 100644 Demo/backend/api/features/knowledge_graph/schemas.py create mode 100644 Demo/backend/api/features/rag_manager.py create mode 100644 Demo/backend/api/features/users/routes.py create mode 100644 Demo/backend/api/features/users/schemas.py create mode 100644 Demo/backend/main.py create mode 100644 Demo/backend/models/database.py create mode 100644 Demo/backend/pathrag.db create mode 100644 Demo/backend/requirements.txt create mode 100644 Demo/backend/sample.env create mode 100644 Demo/backend/start-api.bat create mode 100644 Demo/backend/start-api.sh create mode 100644 Demo/frontend/package-lock.json create mode 100644 Demo/frontend/package.json create mode 100644 Demo/frontend/public/index.html create mode 100644 Demo/frontend/public/manifest.json create mode 100644 Demo/frontend/public/robots.txt create mode 100644 Demo/frontend/src/App.css create mode 100644 Demo/frontend/src/App.js create mode 100644 Demo/frontend/src/components/CustomNav.js create mode 100644 Demo/frontend/src/components/Layout.js create mode 100644 Demo/frontend/src/components/auth/LoginForm.js create mode 100644 Demo/frontend/src/components/auth/RegisterForm.js create mode 100644 Demo/frontend/src/components/chat/ChatInput.js create mode 100644 Demo/frontend/src/components/chat/ChatMessage.js create mode 100644 Demo/frontend/src/components/documents/DocumentList.js create mode 100644 Demo/frontend/src/components/documents/DocumentUploader.js create mode 100644 Demo/frontend/src/components/documents/UploadProgress.js create mode 100644 Demo/frontend/src/components/knowledge-graph/Graph.js create mode 100644 Demo/frontend/src/components/knowledge-graph/QueryForm.js create mode 100644 Demo/frontend/src/context/AuthContext.js create mode 100644 Demo/frontend/src/context/ThemeContext.js create mode 100644 Demo/frontend/src/index.css create mode 100644 Demo/frontend/src/index.js create mode 100644 Demo/frontend/src/pages/Chat.js create mode 100644 Demo/frontend/src/pages/ChatPage.js create mode 100644 Demo/frontend/src/pages/Dashboard.js create mode 100644 Demo/frontend/src/pages/DocumentsPage.js create mode 100644 Demo/frontend/src/pages/KnowledgeGraphPage.js create mode 100644 Demo/frontend/src/pages/Login.js create mode 100644 Demo/frontend/src/pages/Register.js create mode 100644 Demo/frontend/src/services/api.js create mode 100644 Demo/frontend/src/services/auth.js create mode 100644 Demo/frontend/src/styles/chat.css create mode 100644 Demo/frontend/src/styles/documents.css create mode 100644 Demo/frontend/src/styles/knowledge-graph.css create mode 100644 Demo/frontend/src/styles/theme.css create mode 100644 Demo/frontend/src/utils/threadStorage.js create mode 100644 Demo/frontend/start-ui.bat create mode 100644 Demo/frontend/start-ui.sh create mode 100644 Demo/package-lock.json diff --git a/Demo/.gitignore b/Demo/.gitignore new file mode 100644 index 0000000..f5f2b16 --- /dev/null +++ b/Demo/.gitignore @@ -0,0 +1,180 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ + +eggs/ +.eggs/ +.venv/ +venv/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ +node_modules/ +frontend/node_modules/ +data/ +uploads/ +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# UV +# Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +#uv.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/latest/usage/project/#working-with-version-control +.pdm.toml +.pdm-python +.pdm-build/ + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ + +# Ruff stuff: +.ruff_cache/ + +# PyPI configuration file +.pypirc \ No newline at end of file diff --git a/Demo/INSTALLATION.md b/Demo/INSTALLATION.md new file mode 100644 index 0000000..565bbb4 --- /dev/null +++ b/Demo/INSTALLATION.md @@ -0,0 +1,600 @@ +# Installation Guide + +This guide provides detailed instructions for setting up the PathRAG application for development and production environments. + +## Development Environment Setup + +### Backend Setup + +1. **Clone the repository** + ```bash + git clone + cd pathrag + ``` + +2. **Create a virtual environment** + ```bash + # Using venv + python -m venv .venv + + # Activate on Windows + .venv\Scripts\activate + + # Activate on macOS/Linux + source .venv/bin/activate + ``` + +3. **Install dependencies** + ```bash + pip install -r requirements.txt + ``` + +4. **Set up environment variables** + Create a `.env` file in the root directory with the following variables: + ``` + # JWT Settings (Required) + SECRET_KEY=your_secret_key_here # Use a strong random string, e.g., openssl rand -hex 32 + ACCESS_TOKEN_EXPIRE_MINUTES=30 # Token expiration time in minutes + + # Database Settings (Optional - defaults to SQLite) + DATABASE_URL=sqlite:///./pathrag.db # SQLite database path + + # Application Settings (Required) + WORKING_DIR=./data # Directory for storing PathRAG data + UPLOAD_DIR=./uploads # Directory for storing uploaded documents + + # Azure OpenAI Settings (Required if using Azure OpenAI) + AZURE_OPENAI_API_VERSION=2023-05-15 + AZURE_OPENAI_DEPLOYMENT=gpt-4o # Your Azure OpenAI deployment name + AZURE_OPENAI_API_KEY=your_azure_key # Your Azure OpenAI API key + AZURE_OPENAI_ENDPOINT=https://your-resource-name.openai.azure.com + + AZURE_EMBEDDING_DEPLOYMENT=text-embedding-3-large # Your Azure embedding model deployment + AZURE_EMBEDDING_API_VERSION=2023-05-15 + + # OpenAI Settings (Required if using OpenAI directly instead of Azure) + OPENAI_API_KEY=your_openai_key # Your OpenAI API key + OPENAI_API_BASE=https://api.openai.com/v1 + + # PathRAG Settings (Optional - advanced configuration) + CHUNK_SIZE=1200 # Size of text chunks for processing + CHUNK_OVERLAP=100 # Overlap between chunks + MAX_TOKENS=32768 # Maximum tokens for LLM context + TEMPERATURE=0.7 # LLM temperature setting + TOP_K=40 # Number of top results to retrieve + + # CORS Settings (Optional - for production) + CORS_ORIGINS=http://localhost:3000,https://your-domain.com # Allowed origins + ``` + + > **Important**: Never commit your `.env` file to version control. Add it to your `.gitignore` file. + +5. **Initialize the database** + The database will be automatically created when you start the application for the first time. + +6. **Run the development server** + + There are multiple ways to start the server: + + **Option 1: Using the start-api script (Recommended)** + ```bash + # On Unix/Linux/macOS + chmod +x start-api.sh + ./start-api.sh + + # On Windows + start-api.bat + ``` + + **Option 2: Using the main.py script** + ```bash + # Basic start with default settings + python main.py + + # With environment variables override + HOST=127.0.0.1 PORT=8080 DEBUG=true python main.py + ``` + + **Option 3: Using uvicorn directly** + ```bash + # Basic start + uvicorn main:app --host 0.0.0.0 --port 8000 + + # With reload for development (auto-restart on file changes) + uvicorn main:app --host 0.0.0.0 --port 8000 --reload + + # With log level configuration + uvicorn main:app --host 0.0.0.0 --port 8000 --log-level debug + + # With SSL/TLS for HTTPS (requires key and cert files) + uvicorn main:app --host 0.0.0.0 --port 8443 --ssl-keyfile ./key.pem --ssl-certfile ./cert.pem + ``` + + **Option 4: Using uvicorn with module syntax** + ```bash + # If your app is in a module structure + uvicorn pathrag.main:app --host 0.0.0.0 --port 8000 + ``` + + The API will be available at the configured host and port (default: http://localhost:8000) + +### Frontend Setup + +1. **Navigate to the frontend directory** + ```bash + cd pathrag-ui + ``` + +2. **Install dependencies** + ```bash + npm install + ``` + +3. **Configure API endpoint** + If your backend is running on a different URL, update the `baseURL` in `src/services/api.js`. + +4. **Run the development server** + ```bash + npm start + ``` + The application will be available at http://localhost:3000 + +5. **Build for production** + ```bash + npm run build + ``` + The build files will be in the `build` directory. + +## Production Deployment + +### Backend Deployment + +1. **Set up a production server** + - Install Python 3.8+ + - Install required dependencies + - Set up a reverse proxy (Nginx, Apache, etc.) + +2. **Deploy the application** + ```bash + # Clone the repository + git clone + cd pathrag + + # Create a virtual environment + python -m venv .venv + source .venv/bin/activate + + # Install dependencies + pip install -r requirements.txt + ``` + +3. **Set up environment variables** + Create a `.env` file with production settings. For production, consider these additional security measures: + + ``` + # Use a stronger secret key and longer expiration for production + SECRET_KEY=your_very_strong_production_secret_key # Use openssl rand -hex 32 + ACCESS_TOKEN_EXPIRE_MINUTES=60 + + # Database settings - consider using a more robust database for production + DATABASE_URL=sqlite:///./pathrag_prod.db + + # Set restrictive CORS settings + CORS_ORIGINS=https://your-production-domain.com + + # Set production-specific paths + WORKING_DIR=/var/lib/pathrag/data + UPLOAD_DIR=/var/lib/pathrag/uploads + + # Other settings as in development, but with production API keys + ``` + + For enhanced security in production: + - Consider using environment variables directly instead of a .env file + - Use a secrets management service if available (AWS Secrets Manager, HashiCorp Vault, etc.) + - Ensure file permissions are restricted for sensitive files + +4. **Run with a production ASGI server** + + For production deployments, you should use a production-grade ASGI server rather than the development server. + + **Option 1: Using Gunicorn with Uvicorn workers (Recommended for Unix/Linux)** + ```bash + # Install Gunicorn + pip install gunicorn + + # Basic run with 4 worker processes + gunicorn -w 4 -k uvicorn.workers.UvicornWorker main:app + + # With bind address configuration + gunicorn -w 4 -k uvicorn.workers.UvicornWorker -b 0.0.0.0:8000 main:app + + # With timeout and worker configuration + gunicorn -w 4 -k uvicorn.workers.UvicornWorker --timeout 120 --graceful-timeout 60 main:app + + # With SSL/TLS for HTTPS + gunicorn -w 4 -k uvicorn.workers.UvicornWorker --keyfile ./key.pem --certfile ./cert.pem main:app + ``` + + **Option 2: Using Uvicorn directly (Works on all platforms)** + ```bash + # Production mode (no auto-reload) + uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4 + + # With process manager like Supervisor or PM2 + # Example supervisor config: + # [program:pathrag] + # command=/path/to/venv/bin/uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4 + # directory=/path/to/pathrag + # user=www-data + # autostart=true + # autorestart=true + ``` + + **Option 3: Using Hypercorn (Alternative ASGI server)** + ```bash + # Install Hypercorn + pip install hypercorn + + # Run with Hypercorn + hypercorn main:app --bind 0.0.0.0:8000 --workers 4 + ``` + + **Number of workers calculation:** + - A common formula is `(2 x number_of_cores) + 1` + - For a 4-core server: 9 workers + - For a 2-core server: 5 workers + - Adjust based on your server's available memory and CPU resources + +5. **Set up a systemd service (optional)** + + For automatic startup and process management, create a systemd service. + + **Option 1: Using Gunicorn with Uvicorn workers** + + Create a file `/etc/systemd/system/pathrag.service`: + ```ini + [Unit] + Description=PathRAG API + After=network.target + + [Service] + User=your_user + Group=your_group + WorkingDirectory=/path/to/pathrag + Environment="PATH=/path/to/pathrag/.venv/bin" + EnvironmentFile=/path/to/pathrag/.env + ExecStart=/path/to/pathrag/.venv/bin/gunicorn -w 4 -k uvicorn.workers.UvicornWorker -b 0.0.0.0:8000 --timeout 120 main:app + Restart=always + RestartSec=5 + StartLimitIntervalSec=0 + + # Security options + PrivateTmp=true + ProtectSystem=full + NoNewPrivileges=true + + [Install] + WantedBy=multi-user.target + ``` + + **Option 2: Using Uvicorn directly** + + Create a file `/etc/systemd/system/pathrag.service`: + ```ini + [Unit] + Description=PathRAG API + After=network.target + + [Service] + User=your_user + Group=your_group + WorkingDirectory=/path/to/pathrag + Environment="PATH=/path/to/pathrag/.venv/bin" + EnvironmentFile=/path/to/pathrag/.env + ExecStart=/path/to/pathrag/.venv/bin/uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4 + Restart=always + RestartSec=5 + StartLimitIntervalSec=0 + + # Security options + PrivateTmp=true + ProtectSystem=full + NoNewPrivileges=true + + [Install] + WantedBy=multi-user.target + ``` + + **Enable and start the service:** + ```bash + # Reload systemd to recognize the new service + sudo systemctl daemon-reload + + # Enable the service to start on boot + sudo systemctl enable pathrag + + # Start the service + sudo systemctl start pathrag + + # Check the status + sudo systemctl status pathrag + + # View logs + sudo journalctl -u pathrag -f + ``` + +### Frontend Deployment + +1. **Build the frontend** + ```bash + cd pathrag-ui + npm install + npm run build + ``` + +2. **Deploy the build files** + - Copy the contents of the `build` directory to your web server + - Configure your web server to serve the static files + - Set up proper caching headers for static assets + +3. **Nginx configuration example** + ```nginx + server { + listen 80; + server_name your-domain.com; + + root /path/to/pathrag-ui/build; + index index.html; + + location / { + try_files $uri $uri/ /index.html; + } + + location /static/ { + expires 1y; + add_header Cache-Control "public, max-age=31536000"; + } + + location /api/ { + proxy_pass http://localhost:8000/; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + } + } + ``` + +## Docker Deployment (Optional) + +### Backend Dockerfile + +Create a `Dockerfile` in the root directory: +```dockerfile +FROM python:3.9-slim + +WORKDIR /app + +# Install system dependencies +RUN apt-get update && apt-get install -y --no-install-recommends \ + build-essential \ + && rm -rf /var/lib/apt/lists/* + +# Set environment variables +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + PORT=8000 + +# Install Python dependencies +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +# Copy application code +COPY . . + +# Create necessary directories +RUN mkdir -p data uploads + +# Expose port +EXPOSE 8000 + +# Run the application with uvicorn +CMD uvicorn main:app --host 0.0.0.0 --port ${PORT} --workers ${WORKERS:-1} --log-level ${LOG_LEVEL:-info} +``` + +For a more production-ready setup, you can use a multi-stage build: + +```dockerfile +# Build stage +FROM python:3.9-slim AS builder + +WORKDIR /app + +# Install build dependencies +RUN apt-get update && apt-get install -y --no-install-recommends \ + build-essential \ + && rm -rf /var/lib/apt/lists/* + +# Install Python dependencies +COPY requirements.txt . +RUN pip wheel --no-cache-dir --no-deps --wheel-dir /app/wheels -r requirements.txt + +# Final stage +FROM python:3.9-slim + +WORKDIR /app + +# Set environment variables +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + PORT=8000 + +# Install runtime dependencies +RUN apt-get update && apt-get install -y --no-install-recommends \ + libpq5 \ + && rm -rf /var/lib/apt/lists/* + +# Copy wheels from builder stage +COPY --from=builder /app/wheels /wheels +RUN pip install --no-cache /wheels/* + +# Copy application code +COPY . . + +# Create necessary directories +RUN mkdir -p data uploads + +# Create non-root user for security +RUN adduser --disabled-password --gecos "" appuser +RUN chown -R appuser:appuser /app +USER appuser + +# Expose port +EXPOSE 8000 + +# Run the application with uvicorn +CMD uvicorn main:app --host 0.0.0.0 --port ${PORT} --workers ${WORKERS:-1} --log-level ${LOG_LEVEL:-info} +``` + +### Frontend Dockerfile + +Create a `Dockerfile` in the `pathrag-ui` directory: +```dockerfile +FROM node:16-alpine as build + +WORKDIR /app + +COPY package*.json ./ +RUN npm install + +COPY . . +RUN npm run build + +FROM nginx:alpine +COPY --from=build /app/build /usr/share/nginx/html +COPY nginx.conf /etc/nginx/conf.d/default.conf + +EXPOSE 80 + +CMD ["nginx", "-g", "daemon off;"] +``` + +Create an `nginx.conf` file: +```nginx +server { + listen 80; + + location / { + root /usr/share/nginx/html; + index index.html index.htm; + try_files $uri $uri/ /index.html; + } + + location /api/ { + proxy_pass http://backend:8000/; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + } +} +``` + +### Docker Compose + +Create a `docker-compose.yml` file in the root directory: +```yaml +version: '3' + +services: + backend: + build: . + ports: + - "8000:8000" + volumes: + - ./data:/app/data + - ./uploads:/app/uploads + env_file: + - .env + environment: + # You can override .env file settings here + - SECRET_KEY=${SECRET_KEY} + - DATABASE_URL=sqlite:///./pathrag.db + - WORKING_DIR=/app/data + - UPLOAD_DIR=/app/uploads + # Add other environment variables as needed + restart: unless-stopped + + frontend: + build: ./pathrag-ui + ports: + - "80:80" + depends_on: + - backend + environment: + - NODE_ENV=production + restart: unless-stopped + +volumes: + data: + uploads: +``` + +For a more secure production setup, consider using Docker secrets: +```yaml +version: '3.8' + +services: + backend: + # ... other settings as above + secrets: + - jwt_secret + - openai_api_key + environment: + - SECRET_KEY_FILE=/run/secrets/jwt_secret + - OPENAI_API_KEY_FILE=/run/secrets/openai_api_key + # ... other environment variables + +secrets: + jwt_secret: + file: ./secrets/jwt_secret.txt + openai_api_key: + file: ./secrets/openai_api_key.txt +``` + +Run with Docker Compose: +```bash +# Basic run +docker-compose up -d + +# With environment variable overrides +SECRET_KEY=$(openssl rand -hex 32) docker-compose up -d +``` + +## Troubleshooting + +### Backend Issues + +1. **Database errors** + - Check if the SQLite database file has proper permissions + - Try deleting the database file and restarting the application + +2. **API connection errors** + - Verify that the backend server is running + - Check for CORS issues in the browser console + - Ensure the correct API URL is configured in the frontend + +3. **Authentication issues** + - Check if the JWT secret key is properly set + - Verify that tokens are being correctly stored and sent + +### Frontend Issues + +1. **Build errors** + - Clear the node_modules directory and reinstall dependencies + - Check for version conflicts in package.json + +2. **Runtime errors** + - Check the browser console for JavaScript errors + - Verify that all API endpoints are correctly configured + +3. **PWA issues** + - Ensure the service worker is properly registered + - Check for HTTPS requirements in production diff --git a/Demo/QUICKSTART.md b/Demo/QUICKSTART.md new file mode 100644 index 0000000..fade398 --- /dev/null +++ b/Demo/QUICKSTART.md @@ -0,0 +1,125 @@ +# Quick Start Guide + +This guide will help you get started with the PathRAG application quickly. + +## Getting Started + +### Login + +1. Open the application in your browser +2. Use one of the default accounts to log in: + - Username: `user1`, Password: `Pass@123` + - Username: `user2`, Password: `Pass@123` + - Username: `user3`, Password: `Pass@123` +3. Alternatively, you can register a new account by clicking "Register" on the login page + +### Dashboard + +After logging in, you'll see the dashboard with an overview of: +- Total chat conversations +- Uploaded documents +- Knowledge graph statistics + +## Using the Chat + +1. Click on "Chats" in the sidebar +2. Type your question or message in the input field at the bottom +3. Press Enter or click the send button +4. The AI will respond based on the knowledge in the system +5. You can scroll through your chat history + +### Chat Tips + +- Ask specific questions for more accurate responses +- Reference documents you've uploaded for context-specific answers +- Try multi-hop questions that require connecting information across documents +- The AI uses the knowledge graph to provide more comprehensive responses + +### Example Questions + +Simple questions: +- "What are the main features of PathRAG?" +- "How does PathRAG compare to traditional RAG systems?" + +Complex questions: +- "What techniques developed by researchers at Stanford have been applied to knowledge graph construction?" +- "How do the approaches used in PathRAG relate to earlier work on knowledge representation?" + +## Working with Documents + +1. Click on "Documents" in the sidebar +2. Click the "Upload Document" button +3. Drag and drop a file or click to select a file + - Supported formats: PDF, DOCX, MD +4. The document will upload and be processed automatically +5. You'll see the upload progress in real-time +6. Once processed, the document will appear in the list + +### Document Management Tips + +- Larger documents may take longer to process +- The system extracts entities and relationships from documents to build the knowledge graph +- After uploading documents, you can ask questions about them in the chat +- Upload related documents to create a richer knowledge graph with more connections + +## Exploring the Knowledge Graph + +1. Click on "Knowledge Graph" in the sidebar +2. You'll see a visualization of the knowledge graph + - Nodes represent entities (people, organizations, concepts, etc.) + - Edges represent relationships between entities +3. You can: + - Drag nodes to rearrange the graph + - Zoom in/out using the mouse wheel + - Hover over nodes to see details +4. Use the search box to query specific parts of the knowledge graph + +### Knowledge Graph Tips + +- Different colors represent different entity types +- The thickness of connections indicates the strength of relationships +- Try specific queries to focus on particular areas of knowledge + +## Mobile Usage + +The application is fully responsive and works on mobile devices: + +1. Access the same URL on your mobile browser +2. Log in with your credentials +3. Use the menu button to access the sidebar +4. All features work the same as on desktop + +## PWA Installation + +You can install the application as a Progressive Web App (PWA): + +### On Desktop (Chrome) + +1. Click the install icon in the address bar +2. Follow the prompts to install + +### On Mobile (Android) + +1. Tap the menu button in your browser +2. Select "Add to Home Screen" or "Install App" +3. Follow the prompts + +### On iOS + +1. Tap the share button +2. Select "Add to Home Screen" +3. Tap "Add" + +## Keyboard Shortcuts + +- `Enter`: Send a message in chat +- `Shift + Enter`: Add a new line in the chat input +- `Esc`: Close modals + +## Getting Help + +If you encounter any issues: + +1. Check the [README.md](README.md) file for detailed documentation +2. Refer to the [INSTALLATION.md](INSTALLATION.md) for setup troubleshooting +3. Contact the system administrator for account-related issues diff --git a/Demo/README.md b/Demo/README.md new file mode 100644 index 0000000..796bac4 --- /dev/null +++ b/Demo/README.md @@ -0,0 +1,453 @@ +# PathRAG - Knowledge Graph-based RAG System + +This PathRAG Demo App is a comprehensive knowledge graph-based Retrieval-Augmented Generation (RAG) system that combines document processing, chat functionality, and knowledge graph visualization in a single application. + +## What is PathRAG? + +PathRAG (Path-based Retrieval Augmented Generation) is an advanced approach to knowledge retrieval and generation that combines the power of knowledge graphs with large language models (LLMs). + +### Core Concepts + +#### Knowledge Graph Integration +PathRAG builds and maintains a knowledge graph from your documents, where: +- **Nodes** represent entities (people, organizations, concepts, locations, etc.) +- **Edges** represent relationships between these entities +- **Properties** store additional information about entities and relationships + +#### Path-based Retrieval +Unlike traditional RAG systems that rely solely on vector similarity: +1. PathRAG identifies relevant paths through the knowledge graph +2. These paths provide contextual connections between entities +3. The system can follow logical relationships to find information not directly mentioned + +#### Hybrid Search +PathRAG combines multiple search strategies: +- **Vector search** for semantic similarity +- **Graph traversal** for relationship-based connections +- **Entity-centric retrieval** for focused information about specific entities + +#### Advantages Over Traditional RAG +- **Relational understanding**: Captures relationships between concepts, not just similarity +- **Explainability**: Provides clear paths showing how information is connected +- **Reduced hallucinations**: Grounds responses in explicit knowledge connections +- **Complex reasoning**: Can answer multi-hop questions requiring several logical steps + +### How PathRAG Works + +1. **Document Processing**: + - Documents are chunked into manageable pieces + - Entities and relationships are extracted using NLP techniques + - A knowledge graph is constructed connecting these entities + +2. **Query Processing**: + - User queries are analyzed to identify key entities and intents + - The system identifies relevant paths in the knowledge graph + - Both vector similarity and graph structure are used to retrieve information + +3. **Response Generation**: + - Retrieved context from multiple paths is synthesized + - The LLM generates responses grounded in this structured knowledge + - Responses include information from across the knowledge graph + +## Features + +### Core Functionality +- **Document Management**: Upload, process, and manage documents (PDF, DOCX, MD, TXT, HTML, etc.) +- **Chat Interface**: Thread-based chat system with context-aware responses +- **Knowledge Graph**: Visualize and query the knowledge graph built from your documents +- **User Management**: User authentication and personalization + +### Technical Features +- **React Frontend**: Modern UI built with React and RSuite components +- **FastAPI Backend**: High-performance Python API with async support +- **SQLite Database**: Lightweight database for storing user data, chat threads, and document metadata +- **Thread-Based Chat**: Persistent chat threads with unique IDs +- **Document Processing**: Automatic extraction of text and entities from various document formats +- **Knowledge Graph Visualization**: Interactive visualization using D3.js +- **Theme Customization**: Customizable UI themes (blue, red, violet) +- **Automatic Document Reloading**: System checks document status every 15 seconds and automatically reloads when processing completes + +## Tech Stack + +### Backend +- **FastAPI**: Modern, fast web framework for building APIs +- **SQLite**: Lightweight database for storing users, chats, and documents +- **JWT**: JSON Web Tokens for authentication +- **PathRAG**: Path-based Retrieval Augmented Generation for knowledge graph and chat functionality +- **NetworkX**: Graph data structure and algorithms (for development/demo) +- **NanoVectorDB**: Local file-based vector storage (for development/demo) + +### Frontend +- **React**: JavaScript library for building user interfaces +- **RSuite**: UI component library with responsive design +- **D3.js**: Data visualization library for knowledge graph +- **React Router**: Navigation and routing +- **Axios**: HTTP client for API requests +- **React Dropzone**: Drag-and-drop file upload +- **Font Awesome**: Icon library + +## Project Structure + +### Backend +``` +/api + /auth - Authentication module + - jwt_handler.py - JWT token handling + - routes.py - Authentication endpoints + - schemas.py - Authentication data models + /features - Feature modules + /users - User management + /chats - Chat functionality + /documents - Document management + /knowledge_graph - Knowledge graph functionality +/models - Database models + - database.py - SQLite database setup and models +main.py - Main application entry point +``` + +### Frontend +``` +/pathrag-ui + /public - Static files + /src + /components - Reusable components + /auth - Authentication components + /chat - Chat components + /documents - Document components + /knowledge-graph - Knowledge graph components + /context - React context providers + /pages - Application pages + /services - API services + /utils - Utility functions + App.js - Main application component + index.js - Application entry point +``` + +## Setup Instructions + +### Prerequisites +- Python 3.8+ +- Node.js 14+ +- npm or yarn + +### Quick Start (Recommended) + +#### Starting the API + +Use our start script to set up and run the API: + +**For Unix/Linux/macOS:** +```bash +# Make the script executable (first time only) +chmod +x start-api.sh + +# Run the API +./start-api.sh +``` + +**For Windows:** +```bash +# Run the API +start-api.bat +``` + +These scripts will: +1. Create a Python virtual environment named `.venv` if it doesn't exist +2. Install all backend dependencies +3. Start the backend API on port 8000 + +The API will be available at: +- Backend API: http://localhost:8000 +- API Documentation: http://localhost:8000/docs + +#### Starting the UI + +Navigate to the UI directory and start the React application: + +```bash +# Navigate to the UI directory +cd ui + +# Install dependencies (first time only) +npm install + +# Start the UI +npm start +``` + +The UI will be available at: +- Frontend UI: http://localhost:3000 + +### Manual Setup + +If you prefer to set up and run the components separately, follow these instructions: + +#### Backend Setup +1. Create and activate a virtual environment: + ```bash + # Create virtual environment + python -m venv .venv + + # Activate on Windows + .venv\Scripts\activate + + # Activate on macOS/Linux + source .venv/bin/activate + ``` + +2. Install Python dependencies: + ```bash + pip install -r requirements.txt + ``` + +3. Configure environment variables: + Copy the sample environment file and modify it with your settings: + ```bash + cp sample.env .env + # Edit .env with your preferred text editor + ``` + + Key environment variables include: + ``` + # JWT Authentication + SECRET_KEY=your_secret_key_here # Generate with: openssl rand -hex 32 + ACCESS_TOKEN_EXPIRE_MINUTES=30 + + # Application Directories + WORKING_DIR=./data + UPLOAD_DIR=./uploads + + # Database Configuration + DATABASE_URL=sqlite:///./pathrag.db + + # Server Configuration + HOST=0.0.0.0 + PORT=8000 + DEBUG=False + LOG_LEVEL=info + CORS_ORIGINS=http://localhost:3000 + + # AI Model Settings (choose one option) + # Option 1: Azure OpenAI + AZURE_OPENAI_API_KEY=your_azure_key + AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com + AZURE_OPENAI_DEPLOYMENT=gpt-4o + AZURE_OPENAI_API_VERSION=2023-05-15 + AZURE_EMBEDDING_DEPLOYMENT=text-embedding-3-large + + # Option 2: OpenAI direct + OPENAI_API_KEY=your_openai_key + OPENAI_API_BASE=https://api.openai.com/v1 + + # PathRAG Configuration + CHUNK_SIZE=1200 + CHUNK_OVERLAP=100 + MAX_TOKENS=32768 + TEMPERATURE=0.7 + TOP_K=40 + ``` + + See [INSTALLATION.md](INSTALLATION.md) for detailed environment variable configuration and [sample.env](sample.env) for a complete example. + +4. Start the backend server: + ```bash + python main.py + ``` + + The API will be available at http://localhost:8000 + + For more advanced options, see [INSTALLATION.md](INSTALLATION.md). + +5. API Documentation: + - Swagger UI: http://localhost:8000/docs + - ReDoc: http://localhost:8000/redoc + +#### Frontend Setup +1. Navigate to the frontend directory: + ```bash + cd ui + ``` + +2. Install dependencies: + ```bash + npm install + ``` + +3. Start the development server: + ```bash + npm start + ``` + + The application will be available at http://localhost:3000 + +## Usage + +### Authentication +- Use the default credentials to log in: + - Username: user1, Password: Pass@123 + - Username: user2, Password: Pass@123 + - Username: user3, Password: Pass@123 +- Or register a new account using the registration form + +### Chat Threads +1. Navigate to the Chat page +2. Click "New Chat" to start a new thread +3. Type your message in the input field +4. Press Enter or click the send button +5. View the AI response +6. Your chat threads are saved and can be accessed from the sidebar +7. Each thread has a unique ID and maintains its own conversation history +8. Thread titles are automatically updated based on the first message + +### Knowledge Graph +1. Navigate to the Knowledge Graph page +2. Enter a query in the search field to filter the graph +3. Interact with the graph by dragging nodes +4. Zoom in/out using the mouse wheel +5. Click on nodes to see entity details + +### Document Management +1. Navigate to the Documents page +2. Click "Upload Document" button +3. Drag and drop a file or click to select a file +4. Monitor the upload progress +5. The system automatically checks document status every 15 seconds +6. When processing completes, the system automatically reloads the PathRAG instance +7. You can also manually reload the PathRAG instance by clicking the "Reload Documents" button +8. View the uploaded documents in the list with their processing status + +## Data Models + +### User +- `id`: Integer (Primary Key) +- `username`: String (Unique) +- `email`: String (Unique) +- `hashed_password`: String +- `created_at`: DateTime +- `theme`: String (Default: "blue") + +### Thread +- `id`: Integer (Primary Key) +- `uuid`: String (Unique) +- `user_id`: Integer (Foreign Key to User) +- `title`: String +- `created_at`: DateTime +- `updated_at`: DateTime +- `is_deleted`: Boolean (Default: False) + +### Chat +- `id`: Integer (Primary Key) +- `user_id`: Integer (Foreign Key to User) +- `thread_id`: Integer (Foreign Key to Thread) +- `role`: String ('user' or 'system') +- `message`: Text +- `created_at`: DateTime + +### Document +- `id`: Integer (Primary Key) +- `user_id`: Integer (Foreign Key to User) +- `filename`: String +- `content_type`: String +- `file_path`: String +- `file_size`: Integer +- `uploaded_at`: DateTime +- `status`: String +- `processed_at`: DateTime (Nullable) +- `error_message`: Text (Nullable) + +## API Endpoints + +### Authentication +- `POST /token`: Login and get access token +- `POST /register`: Register a new user +- `GET /users/me`: Get current user information + +### Users +- `GET /users/`: Get all users +- `POST /users/theme`: Update user theme + +### Chat Threads +- `GET /chats/threads`: Get all chat threads +- `POST /chats/threads`: Create a new chat thread +- `GET /chats/threads/{thread_uuid}`: Get a specific thread with all its chats +- `PUT /chats/threads/{thread_uuid}`: Update a thread's title +- `DELETE /chats/threads/{thread_uuid}`: Mark a thread as deleted + +### Chats +- `GET /chats/`: Get all chats +- `GET /chats/recent`: Get the 5 most recent chat threads +- `POST /chats/chat/{thread_uuid}`: Create a new chat message in a thread + +### Documents +- `GET /documents/`: Get all documents +- `POST /documents/upload`: Upload a document +- `GET /documents/{document_id}`: Get a specific document +- `GET /documents/{document_id}/status`: Get document processing status +- `POST /documents/reload`: Reload the PathRAG instance to recognize new documents + +### Knowledge Graph +- `GET /knowledge-graph/`: Get the knowledge graph +- `POST /knowledge-graph/query`: Query the knowledge graph + +## Storage Options + +### Demo/Development (Default) +- **Vector Storage**: NanoVectorDB (local file-based vector store) +- **Graph Storage**: NetworkX (local in-memory graph) +- **Key-Value Storage**: JsonKVStorage (local file-based storage) + +> **Note**: These storage options are suitable for demonstration and development purposes only. They are not recommended for production use with large datasets or high traffic. + +### Production Options +For production environments, consider using these alternatives: +- **Vector Databases**: PostgreSQL (pgvector), Pinecone, DataStax, Azure Cognitive Search, Azure SQL(Preview) +- **Graph Databases**: Neo4j, ArangoDB, Apache AGE (PostgreSQL extension), CosmosDB, Azure SQL +- **Document Databases**: MongoDB, Cassandra, CosmosDB + +## License +This project is licensed under the MIT License - see the LICENSE file for details. + +## Use Cases + +PathRAG is particularly effective for: + +### Knowledge-Intensive Applications +- **Research assistance**: Connecting findings across multiple papers and sources +- **Legal document analysis**: Identifying relationships between cases, statutes, and legal concepts +- **Medical knowledge systems**: Connecting symptoms, conditions, treatments, and research + +### Complex Information Retrieval +- **Multi-hop question answering**: "What treatments were developed based on research by scientists who studied under Marie Curie?" +- **Contextual understanding**: Understanding how different parts of a document relate to each other +- **Exploratory research**: Discovering unexpected connections between concepts + +### Enterprise Knowledge Management +- **Corporate knowledge bases**: Connecting information across departments and documents +- **Compliance and regulation**: Tracking relationships between policies, regulations, and procedures +- **Institutional memory**: Preserving and accessing organizational knowledge + +## Limitations and Considerations + +- **Knowledge graph quality**: The system's effectiveness depends on the quality of entity and relationship extraction +- **Computational complexity**: Graph operations can be more resource-intensive than simple vector searches +- **Domain specificity**: May require domain-specific entity extraction for specialized fields +- **Storage limitations**: The default storage options (NanoVectorDB, NetworkX) are not suitable for large-scale production use + +## Authors & Contributors + +### PathRAG Core Logic Research Team +- Boyu Chen¹, Zirui Guo¹,², Zidan Yang¹,³, Yuluo Chen¹, Junze Chen¹, Zhenghao Liu³, Chuan Shi¹, Cheng Yang¹ + 1. Beijing University of Posts and Telecommunications + 2. University of Hong Kong + 3. Northeastern University + + Contact: chenbys4@bupt.edu.cn, yangcheng@bupt.edu.cn + +### Demo Application Contributor +- Robert Dennyson, Solution Architect, UK +- Contact: robertdennyson@live.in + +## Acknowledgements +- PathRAG for the knowledge graph and retrieval augmented generation capabilities +- RSuite for the UI components +- D3.js for the knowledge graph visualization diff --git a/Demo/Screens/Chat.png b/Demo/Screens/Chat.png new file mode 100644 index 0000000000000000000000000000000000000000..838a9273587a99c602518e476adb6bb20f30bb81 GIT binary patch literal 67262 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 SNA;j@o=Ph{$$9kh@BaZ+G6UQI literal 0 HcmV?d00001 diff --git a/Demo/Screens/Chat3.png b/Demo/Screens/Chat3.png new file mode 100644 index 0000000000000000000000000000000000000000..94d28673212d577c07248746281d6f51a964cd9e GIT binary patch literal 121418 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ⅈY}Pq=qKCOMA;GL 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∈*32@hw;LAIs)j~iRKrsH9M9y$7HtnAWl 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 literal 0 HcmV?d00001 diff --git a/Demo/Screens/FileUpload2.png b/Demo/Screens/FileUpload2.png new file mode 100644 index 0000000000000000000000000000000000000000..94f69d8e57b36213838983057893d0ff44b0f7f5 GIT binary patch literal 81660 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 bordered> + + +
+

Don't have an account?

+ + + +
+ + + + + + ); +}; + +export default Login; diff --git a/Demo/frontend/src/pages/Register.js b/Demo/frontend/src/pages/Register.js new file mode 100644 index 0000000..9bebe1c --- /dev/null +++ b/Demo/frontend/src/pages/Register.js @@ -0,0 +1,37 @@ +import React from 'react'; +import { Container, Content, Panel, FlexboxGrid, Button } from 'rsuite'; +import { Link, Navigate } from 'react-router-dom'; +import RegisterForm from '../components/auth/RegisterForm'; +import { useAuth } from '../context/AuthContext'; + +const Register = () => { + const { isAuthenticated } = useAuth(); + + // Redirect if already authenticated + if (isAuthenticated) { + return ; + } + + return ( + + + + + PathRAG} bordered> + + +
+

Already have an account?

+ + + +
+ + + + + + ); +}; + +export default Register; diff --git a/Demo/frontend/src/services/api.js b/Demo/frontend/src/services/api.js new file mode 100644 index 0000000..e7e85bb --- /dev/null +++ b/Demo/frontend/src/services/api.js @@ -0,0 +1,122 @@ +import axios from 'axios'; + +// Get API URL from environment variable or use default +const API_URL = process.env.REACT_APP_API_URL || 'http://localhost:8000'; + +// Create axios instance with base URL +const api = axios.create({ + baseURL: API_URL, + headers: { + 'Content-Type': 'application/json', + }, +}); + +// Add request interceptor to add auth token to requests +api.interceptors.request.use( + (config) => { + const token = localStorage.getItem('token'); + if (token) { + config.headers.Authorization = `Bearer ${token}`; + } + return config; + }, + (error) => { + return Promise.reject(error); + } +); + +// Add response interceptor to handle errors +api.interceptors.response.use( + (response) => { + return response; + }, + (error) => { + // Handle 401 Unauthorized errors + if (error.response && error.response.status === 401) { + localStorage.removeItem('token'); + window.location.href = '/login'; + } + return Promise.reject(error); + } +); + +// Auth API +export const authAPI = { + login: (username, password) => { + const formData = new FormData(); + formData.append('username', username); + formData.append('password', password); + return api.post('/token', formData, { + headers: { + 'Content-Type': 'application/x-www-form-urlencoded', + }, + }); + }, + register: (userData) => api.post('/register', userData), + getCurrentUser: () => api.get('/users/me'), +}; + +// User API +export const userAPI = { + updateTheme: (theme) => api.post('/users/theme', { theme }), + getSettings: () => api.get('/users/settings'), + updateSettings: (settings) => api.put('/users/settings', settings), +}; + +// Chat API +export const chatAPI = { + // Thread endpoints + getThreads: () => api.get('/chats/threads'), + getRecentThreads: () => api.get('/chats/recent'), + createThread: (title) => api.post('/chats/threads', { title }), + getThread: (uuid) => api.get(`/chats/threads/${uuid}`), + updateThread: (uuid, title) => api.put(`/chats/threads/${uuid}`, { title }), + deleteThread: (uuid) => api.delete(`/chats/threads/${uuid}`), + + // Chat endpoints + getChats: () => api.get('/chats'), + createChat: (data) => { + // Handle both string and object formats + if (typeof data === 'string') { + return api.post('/chats', { message: data }); + } + return api.post('/chats', data); + }, + sendChatToThread: (threadUuid, searchContext, message) => { + return api.post(`/chats/chat/${threadUuid}`, { + message, + search_context: searchContext, + thread_uuid: threadUuid + }); + }, + getChat: (id) => api.get(`/chats/${id}`), +}; + +// Document API +export const documentAPI = { + getDocuments: () => api.get('/documents'), + uploadDocument: (formData, onUploadProgress) => { + // For backward compatibility, handle both the new /upload endpoint and the old endpoint + return api.post('/documents/upload', formData, { + headers: { + 'Content-Type': 'multipart/form-data', + }, + onUploadProgress, + }).catch(error => { + // If the old endpoint fails, try the new one + throw error; + }); + }, + getDocument: (id) => api.get(`/documents/${id}`), + getDocumentStatus: (id) => api.get(`/documents/${id}/status`), + deleteDocument: (id) => api.delete(`/documents/${id}`), + reloadDocuments: () => api.post('/documents/reload'), +}; + +// Knowledge Graph API +export const knowledgeGraphAPI = { + getGraph: () => api.get('/knowledge-graph'), + queryGraph: (query) => api.post('/knowledge-graph/query', { query }), +}; + +export default api; diff --git a/Demo/frontend/src/services/auth.js b/Demo/frontend/src/services/auth.js new file mode 100644 index 0000000..431fe5c --- /dev/null +++ b/Demo/frontend/src/services/auth.js @@ -0,0 +1,52 @@ +// Authentication service + +// Get the authentication token from localStorage +export const getToken = () => { + return localStorage.getItem('token'); +}; + +// Set the authentication token in localStorage +export const setToken = (token) => { + localStorage.setItem('token', token); +}; + +// Remove the authentication token from localStorage +export const removeToken = () => { + localStorage.removeItem('token'); +}; + +// Check if the user is authenticated +export const isAuthenticated = () => { + return !!getToken(); +}; + +// Parse JWT token to get user information +export const parseToken = (token) => { + if (!token) return null; + + try { + // JWT tokens are in the format: header.payload.signature + // We only need the payload part + const base64Url = token.split('.')[1]; + const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/'); + const jsonPayload = decodeURIComponent( + atob(base64) + .split('') + .map(c => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2)) + .join('') + ); + + return JSON.parse(jsonPayload); + } catch (error) { + console.error('Error parsing token:', error); + return null; + } +}; + +// Get user information from the token +export const getUserInfo = () => { + const token = getToken(); + if (!token) return null; + + return parseToken(token); +}; diff --git a/Demo/frontend/src/styles/chat.css b/Demo/frontend/src/styles/chat.css new file mode 100644 index 0000000..7833513 --- /dev/null +++ b/Demo/frontend/src/styles/chat.css @@ -0,0 +1,435 @@ +/* Chat Page Layout */ +.chat-page { + display: flex; + flex-direction: column; + height: calc(100vh - 120px); + position: relative; + overflow: hidden; +} + +.chat-header { + display: flex; + justify-content: space-between; + align-items: center; + padding: 16px 20px; + background-color: var(--contentBg); + border-bottom: 1px solid var(--border); + z-index: 10; + position: sticky; + top: 0; +} + +.search-mode-indicator { + display: flex; + align-items: center; + gap: 8px; + font-size: 0.9rem; +} + +.search-mode-label { + color: var(--textMuted); +} + +.search-mode-value { + font-weight: 600; + padding: 4px 10px; + border-radius: 12px; + background-color: rgba(0, 0, 0, 0.05); +} + +.search-mode-value.local { + color: #2e7d32; + background-color: rgba(46, 125, 50, 0.1); +} + +.search-mode-value.hybrid { + color: #1976d2; + background-color: rgba(25, 118, 210, 0.1); +} + +.search-mode-value.global { + color: #d32f2f; + background-color: rgba(211, 47, 47, 0.1); +} + +.chat-content { + flex: 1; + overflow: hidden; + position: relative; + padding: 0 20px; +} + +.context-selector { + width: 200px; +} + +/* Messages Container */ +.messages-container { + flex: 1; + overflow-y: auto; + padding: 20px 0; + display: flex; + flex-direction: column; + height: 100%; + max-height: calc(100vh - 220px); + position: relative; +} + +.conversation-thread { + display: flex; + flex-direction: column; + gap: 24px; +} + +.message-wrapper { + width: 100%; + display: flex; +} + +.user-message-wrapper { + justify-content: flex-end; +} + +.ai-message-wrapper { + justify-content: flex-start; +} + +.empty-chat { + display: flex; + justify-content: center; + align-items: center; + height: 100%; + color: var(--textMuted); + font-style: italic; +} + +.loading-message { + display: flex; + justify-content: center; + padding: 20px 0; +} + +/* Chat Messages */ +.chat-message { + display: flex; + animation: fadeIn 0.3s ease-in-out; + align-items: flex-start; + max-width: 85%; +} + +.user-message { + flex-direction: row-reverse; + margin-left: auto; +} + +.ai-message { + flex-direction: row; + margin-right: auto; +} + +.message-avatar { + margin: 0 12px; + align-self: flex-start; + flex-shrink: 0; +} + +.message-content { + display: flex; + flex-direction: column; + max-width: calc(100% - 60px); +} + +.message-header { + display: flex; + justify-content: space-between; + margin-bottom: 4px; + font-size: 0.85rem; +} + +.user-message .message-header { + flex-direction: row-reverse; +} + +.message-sender { + font-weight: 600; + color: var(--text); +} + +.message-time { + color: var(--textMuted); + font-size: 0.8rem; + margin: 0 8px; +} + +.message-bubble { + padding: 12px; + border-radius: 12px; + box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1); + overflow: hidden; + word-break: break-word; +} + +.user-message .message-bubble { + background-color: var(--primary); + color: white; + border-top-right-radius: 4px; + margin-left: auto; +} + +.ai-message .message-bubble { + background-color: var(--contentBg); + border-top-left-radius: 4px; + border: 1px solid var(--border); +} + +.message-actions { + display: flex; + justify-content: flex-end; + margin-top: 4px; + opacity: 0; + transition: opacity 0.2s ease; +} + +.chat-message:hover .message-actions { + opacity: 1; +} + +/* Chat Input */ +.chat-input-container { + padding: 16px 20px; + border-top: 1px solid var(--border); + position: sticky; + bottom: 0; + z-index: 10; +} + +.chat-input { + display: flex; + flex-direction: column; + gap: 12px; + background-color: var(--sidebar); + border-radius: 8px; + padding: 12px; +} + +.chat-input-controls { + display: flex; + justify-content: flex-start; + align-items: center; +} + +.chat-input-main { + display: flex; + position: relative; +} + +.input-with-dropdown { + display: flex; + flex-direction: row; + align-items: center; + gap: 12px; + width: 100%; +} + +.search-mode-dropdown { + width: 140px !important; + flex-shrink: 0; +} + +.search-mode-dropdown .rs-picker-toggle { + background-color: rgba(255, 255, 255, 0.15) !important; + color: white !important; + border: none !important; + font-weight: 500 !important; + padding: 8px 12px !important; + height: 44px !important; +} + +.search-mode-dropdown .rs-picker-toggle:hover { + background-color: rgba(255, 255, 255, 0.25) !important; +} + +.search-mode-dropdown .rs-picker-toggle-placeholder, +.search-mode-dropdown .rs-picker-toggle-value { + color: white !important; + font-weight: 500 !important; +} + +.search-mode-dropdown .rs-picker-toggle-caret { + color: white !important; +} + +.message-input-group { + background-color: var(--sidebar);; + flex: 1; + min-width: 0; + +} + +.rs-input { + padding: 10px 12px !important; + min-height: 44px !important; + resize: none; + +} + +.chat-text-input { + padding-left: 5px !important; + padding-right: 5px !important; + background-color: rgba(255, 255, 255, 0.3) !important; + color: rgb(0, 0, 0) !important; + border: none !important; + font-weight: 500 !important; +} + +.chat-text-input::placeholder { + color: rgba(255, 255, 255, 0.8) !important; +} + +.input-icon-button { + position: absolute !important; + top: 50% !important; + transform: translateY(-50%) !important; + z-index: 5 !important; + background: rgba(255, 255, 255, 0.2) !important; + color: white !important; + width: 30px !important; + height: 30px !important; + display: flex !important; + align-items: center !important; + justify-content: center !important; + border-radius: 50% !important; +} + +.input-icon-button:hover { + background: rgba(255, 255, 255, 0.3) !important; +} + +.input-icon-button:first-of-type { + left: 8px !important; +} + +.input-icon-button:nth-of-type(2) { + right: 44px !important; +} + +.send-button { + width: 44px !important; + height: 44px !important; + display: flex !important; + align-items: center !important; + justify-content: center !important; + background: rgba(255, 255, 255, 0.2) !important; + color: white !important; +} + +.send-button:hover:not(:disabled) { + background: rgba(255, 255, 255, 0.3) !important; +} + +.send-button:disabled { + opacity: 0.5 !important; +} + +/* Markdown Content */ +.markdown-content { + line-height: 1.6; +} + +.markdown-content h1 { + font-size: 1.8rem; + margin-top: 1.5rem; + margin-bottom: 1rem; +} + +.markdown-content h2 { + font-size: 1.5rem; + margin-top: 1.2rem; + margin-bottom: 0.8rem; +} + +.markdown-content h3 { + font-size: 1.3rem; + margin-top: 1rem; + margin-bottom: 0.6rem; +} + +.markdown-content p { + margin-bottom: 1rem; +} + +.markdown-content ul, +.markdown-content ol { + margin-left: 1.5rem; + margin-bottom: 1rem; +} + +.markdown-content li { + margin-bottom: 0.5rem; +} + +.markdown-content pre { + margin: 1rem 0; + border-radius: 6px; + overflow: auto; +} + +.markdown-content code { + font-family: monospace; + padding: 0.2rem 0.4rem; + border-radius: 3px; + background-color: rgba(0, 0, 0, 0.05); +} + +.markdown-content pre code { + padding: 0; + background-color: transparent; +} + +/* Mermaid Diagrams */ +.mermaid-diagram { + margin: 1.5rem 0; + padding: 1rem; + background-color: #f8f9fa; + border-radius: 6px; + overflow: auto; +} + +/* Animations */ +@keyframes fadeIn { + from { + opacity: 0; + transform: translateY(10px); + } + to { + opacity: 1; + transform: translateY(0); + } +} + +/* Responsive Design */ +@media (max-width: 768px) { + .message-content { + max-width: 85%; + } + + .chat-header { + flex-direction: column; + align-items: flex-start; + gap: 10px; + } + + .context-selector { + width: 100%; + } +} + +@media (max-width: 576px) { + .message-content { + max-width: 90%; + } + + .message-avatar { + margin: 0 8px; + } +} diff --git a/Demo/frontend/src/styles/documents.css b/Demo/frontend/src/styles/documents.css new file mode 100644 index 0000000..b829d7a --- /dev/null +++ b/Demo/frontend/src/styles/documents.css @@ -0,0 +1,234 @@ +/* Documents Page */ +.documents-header { + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 20px; +} + +/* Document Uploader */ +.document-uploader { + margin-bottom: 20px; +} + +.dropzone { + border: 2px dashed var(--border); + border-radius: 8px; + padding: 30px; + text-align: center; + cursor: pointer; + transition: all 0.3s ease; + margin-bottom: 15px; +} + +.dropzone.active { + border-color: var(--primary); + background-color: rgba(var(--primary-rgb), 0.05); +} + +.dropzone.disabled { + cursor: not-allowed; + opacity: 0.7; +} + +.upload-prompt { + padding: 20px; +} + +.upload-note { + font-size: 0.9rem; + color: var(--textMuted); + margin-top: 10px; +} + +.upload-progress { + padding: 15px; +} + +.upload-status-header { + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 15px; +} + +.status-label { + display: inline-block; + padding: 4px 8px; + border-radius: 4px; + font-weight: 500; + font-size: 0.9rem; +} + +.status-label.uploading { + background-color: #f5a623; + color: white; +} + +.status-label.processing { + background-color: #2196f3; + color: white; +} + +.status-label.completed { + background-color: #4caf50; + color: white; +} + +.status-label.failed { + background-color: #f44336; + color: white; +} + +.status-message { + margin-top: 15px; + font-size: 0.9rem; + color: var(--text); +} + +.upload-success { + margin-top: 20px; + display: flex; + flex-direction: column; + gap: 10px; +} + +.upload-reloading { + margin-top: 15px; + display: flex; + align-items: center; +} + +.upload-reloading .rs-message { + width: 100%; + display: flex; + align-items: center; +} + +/* Upload Progress Panel */ +.upload-progress-panel { + margin-bottom: 15px; +} + +.upload-progress-header { + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 15px; +} + +.upload-progress-bar { + display: flex; + align-items: center; + gap: 10px; + margin-bottom: 10px; +} + +.progress-percentage { + min-width: 40px; + text-align: right; + font-weight: 500; +} + +.upload-progress-message { + font-size: 0.9rem; + color: var(--textMuted); +} + +/* Document List */ +.document-list { + width: 100%; + margin-bottom: 20px; + display: block; +} + +.document-list .rs-panel-body { + width: 100%; + padding: 0; +} + +.document-list .rs-table { + width: 100% !important; +} + +.document-list .rs-table-body-row-wrapper, +.document-list .rs-table-header-row-wrapper, +.document-list .rs-table-row, +.document-list .rs-table-cell-group, +.document-list .rs-table-cell { + width: 100% !important; +} + +/* Fix for NaN width issue */ +.document-list [style*="NaN"] { + width: auto !important; +} + +.document-status-badge { + display: inline-block; + padding: 2px 8px; + border-radius: 12px; + font-size: 0.85rem; + font-weight: 500; + text-align: center; + color: white; +} + +.document-status-badge.processing { + background-color: #2196F3; +} + +.document-status-badge.completed { + background-color: #4CAF50; +} + +.document-status-badge.failed { + background-color: #F44336; +} + +.document-status-badge.uploading { + background-color: #FF9800; +} + +.document-card { + height: 100%; + display: flex; + flex-direction: column; +} + +.document-card-header { + display: flex; + justify-content: space-between; + align-items: center; +} + +.document-card-body { + flex: 1; +} + +.document-card-footer { + display: flex; + justify-content: space-between; + align-items: center; + margin-top: auto; +} + +.document-meta { + display: flex; + flex-direction: column; + gap: 5px; + font-size: 0.9rem; + color: var(--textMuted); +} + +.document-actions { + display: flex; + gap: 10px; +} + +/* Responsive Design */ +@media (max-width: 768px) { + .document-list { + grid-template-columns: 1fr; + } +} diff --git a/Demo/frontend/src/styles/knowledge-graph.css b/Demo/frontend/src/styles/knowledge-graph.css new file mode 100644 index 0000000..f74a9fc --- /dev/null +++ b/Demo/frontend/src/styles/knowledge-graph.css @@ -0,0 +1,113 @@ +.graph-container { + position: relative; + width: 100%; + height: 600px; + overflow: hidden; + background-color: var(--contentBg); + border-radius: 8px; + transition: all 0.3s ease; +} + +.graph-container.fullscreen { + width: 100vw; + height: 100vh; + border-radius: 0; + background-color: var(--bg); + z-index: 9999; +} + +.knowledge-graph { + width: 100%; + height: 100%; +} + +.graph-controls { + position: absolute; + top: 20px; + right: 20px; + z-index: 10; + display: flex; + align-items: center; + gap: 10px; + background-color: rgba(0, 0, 0, 0.6); + padding: 8px; + border-radius: 8px; + box-shadow: 0 2px 8px rgba(0, 0, 0, 0.2); + transition: opacity 0.3s ease; +} + +.fullscreen .graph-controls { + opacity: 0.6; +} + +.fullscreen .graph-controls:hover { + opacity: 1; +} + +.graph-controls .rs-btn-group { + background-color: transparent; +} + +.graph-controls .rs-btn { + color: white; + background-color: transparent; +} + +.graph-controls .rs-btn:hover:not(:disabled) { + background-color: rgba(255, 255, 255, 0.1); +} + +.graph-controls .rs-btn:disabled { + color: rgba(255, 255, 255, 0.4); +} + +.zoom-level { + color: white; + font-size: 0.9rem; + min-width: 50px; + text-align: center; +} + +.graph-panel { + padding: 0 !important; + overflow: hidden; + height: calc(100vh - 200px); +} + +.graph-loading, +.graph-empty { + display: flex; + justify-content: center; + align-items: center; + height: 100%; + color: var(--textMuted); +} + +/* Node and Edge Styles */ +.node circle { + cursor: pointer; + transition: r 0.2s ease; +} + +.node:hover circle { + r: 12; +} + +.node text { + font-size: 12px; + pointer-events: none; + text-shadow: 0 1px 2px rgba(0, 0, 0, 0.8); +} + +/* Responsive Design */ +@media (max-width: 768px) { + .graph-container { + height: 400px; + } + + .graph-controls { + top: 10px; + right: 10px; + padding: 5px; + } +} diff --git a/Demo/frontend/src/styles/theme.css b/Demo/frontend/src/styles/theme.css new file mode 100644 index 0000000..4cbfc55 --- /dev/null +++ b/Demo/frontend/src/styles/theme.css @@ -0,0 +1,596 @@ +/* Theme CSS Variables */ +:root { + /* Default theme variables will be overridden by ThemeContext */ + --primary: #1E88E5; + --primary-rgb: 30, 136, 229; /* RGB values for primary color */ + --secondary: #0D47A1; + --accent: #90CAF9; + --background: #F5F9FF; + --contentBg: #FFFFFF; + --sidebar: #0A1929; + --sidebarHover: #1A365D; + --navActive: #1E88E5; + --text: #2A3747; + --textLight: #FFFFFF; + --textMuted: #64748B; + --border: #E2E8F0; + --cardBg: #FFFFFF; + --success: #4CAF50; + --warning: #FF9800; + --error: #F44336; + --info: #2196F3; + --headerBg: #0A1929; + --headerText: #FFFFFF; + --panelBg: #FFFFFF; + --inputBg: #F8FAFC; + --dropdownBg: #FFFFFF; + --dropdownHover: #F0F7FF; + --shadow: rgba(0, 0, 0, 0.1); + + /* Spacing */ + --spacing-xs: 4px; + --spacing-sm: 8px; + --spacing-md: 16px; + --spacing-lg: 24px; + --spacing-xl: 32px; + + /* Border radius */ + --border-radius-sm: 4px; + --border-radius-md: 8px; + --border-radius-lg: 12px; + --border-radius-xl: 16px; + --border-radius-circle: 50%; + + /* Shadows */ + --shadow-sm: 0 1px 3px var(--shadow), 0 1px 2px var(--shadow); + --shadow-md: 0 3px 6px var(--shadow), 0 2px 4px var(--shadow); + --shadow-lg: 0 10px 20px var(--shadow), 0 3px 6px var(--shadow); + --shadow-xl: 0 14px 28px var(--shadow), 0 10px 10px var(--shadow); + + /* Transitions */ + --transition-fast: 0.15s ease; + --transition-normal: 0.3s ease; + --transition-slow: 0.5s ease; +} + +/* Apply theme to body */ +body { + background-color: var(--background); + color: var(--text); + transition: background-color var(--transition-normal); +} + +/* Theme-aware component styles */ + +/* App container */ +.app-container { + background-color: var(--background); +} + +/* Content area */ +.rs-content { + background-color: var(--contentBg); + border-radius: var(--border-radius-md); + box-shadow: var(--shadow-sm); + margin: var(--spacing-md); + padding: var(--spacing-lg) !important; +} + +/* Buttons */ +.rs-btn-primary { + background-color: var(--primary) !important; + color: var(--textLight) !important; + border: none !important; + box-shadow: var(--shadow-sm) !important; + transition: all var(--transition-fast) !important; +} + +.rs-btn-primary:hover, .rs-btn-primary:focus { + background-color: var(--secondary) !important; + box-shadow: var(--shadow-md) !important; + transform: translateY(-1px); +} + +.rs-btn-default { + background-color: var(--contentBg) !important; + color: var(--text) !important; + border-color: var(--border) !important; +} + +.rs-btn-default:hover { + background-color: var(--accent) !important; + color: var(--secondary) !important; +} + +/* Panels */ +.rs-panel { + border-color: var(--border) !important; + background-color: var(--panelBg) !important; + box-shadow: var(--shadow-sm) !important; + transition: all var(--transition-fast) !important; + border-radius: var(--border-radius-md) !important; + overflow: hidden; +} + +.rs-panel:hover { + box-shadow: var(--shadow-md) !important; +} + +.rs-panel-header { + background-color: var(--panelBg) !important; + color: var(--text) !important; + border-bottom-color: var(--border) !important; +} + +.rs-panel-body { + padding: var(--spacing-md) !important; +} + +/* Sidebar */ +.rs-sidenav { + background-color: var(--sidebar) !important; + transition: background-color var(--transition-normal) !important; + box-shadow: var(--shadow-md) !important; + color: white !important; +} + +/* Force all text in sidebar to be white */ +.rs-sidenav *, +.rs-sidenav .rs-nav-item, +.rs-sidenav .rs-nav-item-content, +.rs-sidenav .rs-nav-item-text { + color: white !important; +} + +/* Override hover and active states */ +.rs-sidenav .rs-nav-item:hover .rs-nav-item-text { + color: var(--primary) !important; + font-weight: bold !important; +} + +.rs-sidenav .rs-nav-item-active .rs-nav-item-text { + color: white !important; + font-weight: bold !important; +} + +.rs-sidenav-header { + padding: var(--spacing-md) !important; + background-color: var(--headerBg) !important; + border-bottom: 1px solid rgba(255, 255, 255, 0.1) !important; + text-align: center !important; +} + +.rs-sidenav-header span { + font-size: 1.8rem !important; + font-weight: bold !important; + letter-spacing: 0.5px !important; + color: white !important; + text-shadow: 0 1px 2px rgba(0, 0, 0, 0.3) !important; +} + +.rs-sidenav-body { + padding-top: var(--spacing-lg) !important; +} + +.rs-nav-item { + transition: all var(--transition-fast) !important; + margin: 8px var(--spacing-md) !important; + border-radius: var(--border-radius-sm) !important; + font-size: 1.1rem !important; + padding: 12px 16px !important; + border-left: 3px solid transparent !important; +} + +.rs-nav-item:hover { + background-color: var(--sidebarHover) !important; + transform: translateX(2px); + border-left-color: var(--primary) !important; +} + +.rs-nav-item-active { + background-color: var(--navActive) !important; + font-weight: bold !important; + border-left-color: var(--primary) !important; +} + +.rs-nav-item-icon { + color: var(--accent) !important; + font-size: 1.3rem !important; + margin-right: 12px !important; + width: 24px !important; + text-align: center !important; +} + +/* Icon color for hover and active states */ +.rs-nav-item:hover .rs-nav-item-icon, +.rs-sidenav .rs-nav-item:hover svg { + color: var(--primary) !important; +} + +.rs-nav-item-active .rs-nav-item-icon, +.rs-sidenav .rs-nav-item-active svg { + color: white !important; +} + +/* Improve sidebar text visibility */ +.rs-nav-item-text { + text-shadow: 0 1px 2px rgba(0, 0, 0, 0.3) !important; + letter-spacing: 0.5px !important; +} + +/* Hover state - theme color */ +.rs-nav-item:hover .rs-nav-item-text { + color: var(--primary) !important; + font-weight: bold !important; +} + +/* Active state - white and bold */ +.rs-nav-item-active .rs-nav-item-text { + color: white !important; + font-weight: bold !important; +} + +/* Headers */ +.rs-header { + background-color: var(--headerBg) !important; + color: var(--headerText) !important; + transition: background-color var(--transition-normal) !important; + box-shadow: var(--shadow-sm) !important; + z-index: 10; +} + +/* Inputs */ +.rs-input { + background-color: var(--inputBg) !important; + border-color: var(--border) !important; + border-radius: var(--border-radius-sm) !important; + padding: var(--spacing-sm) var(--spacing-md) !important; + transition: all var(--transition-fast) !important; +} + +.rs-input:focus { + border-color: var(--primary) !important; + box-shadow: 0 0 0 2px rgba(var(--primary-rgb), 0.25) !important; +} + +.rs-input-group { + border-radius: var(--border-radius-sm) !important; +} + +/* Dropdown */ +.rs-dropdown-menu { + background-color: var(--dropdownBg) !important; + box-shadow: var(--shadow-md) !important; + border-radius: var(--border-radius-sm) !important; + border: 1px solid var(--border) !important; + padding: var(--spacing-xs) 0 !important; +} + +.rs-dropdown-item { + padding: var(--spacing-sm) var(--spacing-md) !important; + color: var(--text) !important; + transition: all var(--transition-fast) !important; +} + +.rs-dropdown-item:hover { + background-color: var(--dropdownHover) !important; +} + +.rs-dropdown-item-active { + background-color: var(--accent) !important; + color: var(--secondary) !important; + font-weight: bold; +} + +/* Theme selector */ +.theme-selector { + margin-right: var(--spacing-md); +} + +.theme-option { + display: flex; + align-items: center; + padding: var(--spacing-sm) var(--spacing-md); +} + +.theme-color-preview { + width: 16px; + height: 16px; + border-radius: 50%; + margin-right: var(--spacing-sm); + border: 2px solid var(--border); +} + +/* Chat components */ +.chat-message { + background-color: var(--panelBg); + border-radius: var(--border-radius-md); + box-shadow: var(--shadow-sm); + transition: all var(--transition-fast); + margin-bottom: var(--spacing-md); + overflow: hidden; +} + +.chat-message:hover { + box-shadow: var(--shadow-md); +} + +.user-message .message-panel { + background-color: var(--accent) !important; + border-color: var(--accent) !important; +} + +.ai-message .message-panel { + background-color: var(--panelBg) !important; +} + +.message-header { + padding: var(--spacing-sm) var(--spacing-md) !important; + border-bottom: 1px solid var(--border) !important; +} + +.message-content { + padding: var(--spacing-md) !important; +} + +.message-footer { + padding: var(--spacing-sm) var(--spacing-md) !important; + border-top: 1px solid var(--border) !important; + display: flex; + justify-content: flex-end; +} + +/* Knowledge graph */ +.knowledge-graph-container { + background-color: var(--panelBg); + border-radius: var(--border-radius-md); + box-shadow: var(--shadow-sm); + padding: var(--spacing-md); + height: 600px; + overflow: hidden; +} + +/* Document list */ +.document-item { + transition: all var(--transition-fast); + border-radius: var(--border-radius-sm); + margin-bottom: var(--spacing-sm); + border: 1px solid var(--border); +} + +.document-item:hover { + background-color: var(--accent) !important; + transform: translateX(2px); +} + +.document-icon { + color: var(--primary); + margin-right: var(--spacing-sm); +} + +/* Dashboard panels */ +.dashboard-panel { + transition: all var(--transition-fast); + margin-bottom: var(--spacing-md); +} + +.dashboard-panel:hover { + transform: translateY(-2px); + box-shadow: var(--shadow-md) !important; +} + +.dashboard-panel-header { + display: flex; + align-items: center; + padding-bottom: var(--spacing-sm); + border-bottom: 1px solid var(--border); + margin-bottom: var(--spacing-md); +} + +.dashboard-panel-icon { + color: var(--primary); + margin-right: var(--spacing-sm); + font-size: 1.2em; +} + +.dashboard-panel-title { + font-weight: bold; + color: var(--text); +} + +/* Custom scrollbar */ +::-webkit-scrollbar { + width: 8px; +} + +::-webkit-scrollbar-track { + background: rgba(0, 0, 0, 0.05); + border-radius: 4px; +} + +::-webkit-scrollbar-thumb { + background-color: var(--primary); + border-radius: 4px; +} + +::-webkit-scrollbar-thumb:hover { + background-color: var(--secondary); +} + +/* Sidebar toggle button */ +.sidebar-toggle { + position: fixed; + z-index: 1000; + width: 40px; + height: 40px; + border-radius: 50%; + background-color: var(--primary); + color: white; + display: flex; + align-items: center; + justify-content: center; + cursor: pointer; + box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2); + transition: all 0.3s ease; +} + +.sidebar-toggle:hover { + transform: scale(1.1); + box-shadow: 0 3px 8px rgba(0, 0, 0, 0.3); +} + +/* Custom Nav Styling */ +.custom-nav .rs-nav-item { + color: white !important; + transition: all 0.2s ease !important; + margin: 8px 16px !important; + border-radius: 4px !important; + font-size: 1.1rem !important; + padding: 12px 16px !important; + border-left: 3px solid transparent !important; +} + +.custom-nav .rs-nav-item:hover { + background-color: rgba(var(--primary-rgb), 0.15) !important; + transform: translateX(2px); + border-left-color: var(--primary) !important; +} + +.custom-nav .rs-nav-item:hover .rs-nav-item-text { + color: var(--primary) !important; + font-weight: bold !important; +} + +.custom-nav .rs-nav-item-active { + background-color: rgba(var(--primary-rgb), 0.25) !important; + font-weight: bold !important; + border-left-color: var(--primary) !important; +} + +.custom-nav .rs-nav-item-active .rs-nav-item-text { + color: var(--primary) !important; + font-weight: bold !important; +} + +.custom-nav .nav-icon { + color: var(--accent) !important; + font-size: 1.3rem !important; + margin-right: 12px !important; + width: 24px !important; + text-align: center !important; +} + +.custom-nav .rs-nav-item:hover .nav-icon { + color: var(--primary) !important; +} + +.custom-nav .rs-nav-item-active .nav-icon { + color: var(--primary) !important; +} + +/* Recent Chats */ +.recent-chat-item { + padding: 10px 12px; + border-radius: 4px; + margin-bottom: 8px; + cursor: pointer; + transition: all 0.2s ease; + background-color: rgba(255, 255, 255, 0.05); + border: 1px solid rgba(255, 255, 255, 0.1); +} + +.recent-chat-item:hover { + background-color: var(--sidebarHover); + transform: translateX(2px); +} + +.recent-chat-title { + color: white; + font-weight: 500; + font-size: 0.9rem; + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} + +.recent-chat-date { + color: var(--textMuted); + font-size: 0.75rem; + margin-top: 2px; +} + +/* Panel Styles */ +.panel-title { + font-size: 1.25rem; + font-weight: 600; + color: var(--text); +} + +/* Responsive Design */ +@media (max-width: 992px) { + .rs-content { + padding: var(--spacing-md) !important; + } + + .rs-panel { + margin-bottom: var(--spacing-md) !important; + } + + .rs-header { + padding: 0 var(--spacing-sm) !important; + } +} + +@media (max-width: 768px) { + .rs-sidenav { + width: 220px !important; + } + + .rs-nav-item { + padding: 10px 12px !important; + font-size: 1rem !important; + } + + .rs-nav-item-icon { + margin-right: 8px !important; + } + + .rs-content { + padding: var(--spacing-sm) !important; + } + + .dashboard-panel { + margin-bottom: var(--spacing-sm) !important; + } +} + +@media (max-width: 576px) { + .rs-sidenav { + width: 200px !important; + } + + .rs-sidenav-header span { + font-size: 1.2rem !important; + } + + .rs-nav-item { + padding: 8px 10px !important; + font-size: 0.95rem !important; + } + + .rs-content { + padding: var(--spacing-xs) !important; + } + + .rs-panel { + margin-bottom: var(--spacing-sm) !important; + } + + .rs-panel-header { + padding: var(--spacing-sm) !important; + } + + .rs-panel-body { + padding: var(--spacing-sm) !important; + } +} diff --git a/Demo/frontend/src/utils/threadStorage.js b/Demo/frontend/src/utils/threadStorage.js new file mode 100644 index 0000000..1d13aa4 --- /dev/null +++ b/Demo/frontend/src/utils/threadStorage.js @@ -0,0 +1,45 @@ +/** + * Utility functions for managing chat thread UUIDs in localStorage + */ + +const THREAD_KEY = 'current_thread_uuid'; + +/** + * Save a thread UUID to localStorage + * @param {string} uuid - The thread UUID to save + */ +export const saveThreadUUID = (uuid) => { + if (uuid) { + localStorage.setItem(THREAD_KEY, uuid); + } +}; + +/** + * Get the current thread UUID from localStorage + * @returns {string|null} The thread UUID or null if not found + */ +export const getThreadUUID = () => { + return localStorage.getItem(THREAD_KEY); +}; + +/** + * Clear the current thread UUID from localStorage + */ +export const clearThreadUUID = () => { + localStorage.removeItem(THREAD_KEY); +}; + +/** + * Check if a thread UUID exists in localStorage + * @returns {boolean} True if a thread UUID exists, false otherwise + */ +export const hasThreadUUID = () => { + return !!getThreadUUID(); +}; + +export default { + saveThreadUUID, + getThreadUUID, + clearThreadUUID, + hasThreadUUID +}; diff --git a/Demo/frontend/start-ui.bat b/Demo/frontend/start-ui.bat new file mode 100644 index 0000000..2429cf7 --- /dev/null +++ b/Demo/frontend/start-ui.bat @@ -0,0 +1,21 @@ +@echo off +REM Script to start only the UI on port 3000 + +echo Starting PathRAG UI on port 3000... + +REM Install dependencies if needed +if not exist node_modules ( + echo Installing frontend dependencies... + call npm install + echo Frontend dependencies installed. +) + +REM Set environment variables +set PORT=3000 +set REACT_APP_API_URL=http://localhost:8000 + +REM Start the UI +echo Starting React application on port 3000... +npx cross-env PORT=3000 npm start + +echo UI server stopped. diff --git a/Demo/frontend/start-ui.sh b/Demo/frontend/start-ui.sh new file mode 100644 index 0000000..a8b7754 --- /dev/null +++ b/Demo/frontend/start-ui.sh @@ -0,0 +1,20 @@ +#!/bin/bash +# Script to start only the UI on port 3000 + +echo "Starting PathRAG UI on port 3000..." +# Install dependencies if needed +if [ ! -d "node_modules" ]; then + echo "Installing frontend dependencies..." + npm install + echo "Frontend dependencies installed." +fi + +# Set environment variables +export PORT=3000 +export REACT_APP_API_URL=http://localhost:8000 + +# Start the UI +echo "Starting React application on port 3000..." +npx cross-env PORT=3000 npm start + +echo "UI server stopped." diff --git a/Demo/package-lock.json b/Demo/package-lock.json new file mode 100644 index 0000000..a953ca9 --- /dev/null +++ b/Demo/package-lock.json @@ -0,0 +1,6 @@ +{ + "name": "Demo", + "lockfileVersion": 3, + "requires": true, + "packages": {} +}

F^qtJl-lVys)ufj*pk)g{4SnNZPeG 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 OyrO4xsYJ)|{@(%m#sVb( literal 0 HcmV?d00001 diff --git a/Demo/Screens/FileUpload3.png b/Demo/Screens/FileUpload3.png new file mode 100644 index 0000000000000000000000000000000000000000..303eefe7e95df8b303484eac2bf42ad7c5403ee1 GIT binary patch literal 79642 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 Sxn-}9BJuU{^RD?ZGUreD?0>BQ literal 0 HcmV?d00001 diff --git a/Demo/Screens/FileUpload4.png b/Demo/Screens/FileUpload4.png new file mode 100644 index 0000000000000000000000000000000000000000..104212f2d1061f3e0766b18a811aa6193fd059a2 GIT binary patch literal 101329 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%0Al7KyiQR?+G)hfR$N9Ha}Ahvuu=l*CfZmB^t1 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 Ru$fJl0lqu8l>1;Z{sNUm#%%xq literal 0 HcmV?d00001 diff --git a/Demo/Screens/FileUpload6.png b/Demo/Screens/FileUpload6.png new file mode 100644 index 0000000000000000000000000000000000000000..8190d861ab8b37e646b5e6721f59dd8718aa0290 GIT binary patch literal 93815 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%0DEC8MYw%k^mywnV`HoQs!kz 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 literal 0 HcmV?d00001 diff --git a/Demo/Screens/FileUploadFail.png b/Demo/Screens/FileUploadFail.png new file mode 100644 index 0000000000000000000000000000000000000000..bab42b2194d869b587c0634a31bf4d3a6c686038 GIT binary patch literal 107906 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 MI$UACK(-qbQSgVMb8EC*JPa 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 literal 0 HcmV?d00001 diff --git a/Demo/Screens/Knowledge Graph.png b/Demo/Screens/Knowledge Graph.png new file mode 100644 index 0000000000000000000000000000000000000000..57faab2cf783fde76a0614e4dd3a0fb2ac0675c1 GIT binary patch literal 427466 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

=>6k`|n+GRYin2f*H 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

GIh2%sBf2lyX43h^-_v%>xi!0;Ia%(& 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 KOdJ*&Uc~YX21DG#CV(Se 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ð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 z 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�&9y&-al`;~bn~>W97)vBldzcCF6k!;(n5 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

wuXwgy{U}8(qG8U4p&v}#QJBN8v0GvzZe7S{ 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%0Do>TAkhcVDf_ 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 z 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%0AjgeBe&%XiKs0oqa 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

je%&;Sq@b2|^(P@{nT_Z5YgCb`%qoDE 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 IlKuVv0rhWQg#Z8m literal 0 HcmV?d00001 diff --git a/Demo/backend/.gitignore b/Demo/backend/.gitignore new file mode 100644 index 0000000..6310c88 --- /dev/null +++ b/Demo/backend/.gitignore @@ -0,0 +1,179 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ + +eggs/ +.eggs/ +.venv/ +venv/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ +node_modules/ +data/ +uploads/ +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# UV +# Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +#uv.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/latest/usage/project/#working-with-version-control +.pdm.toml +.pdm-python +.pdm-build/ + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ + +# Ruff stuff: +.ruff_cache/ + +# PyPI configuration file +.pypirc \ No newline at end of file diff --git a/Demo/backend/PathRAG/PathRAG.py b/Demo/backend/PathRAG/PathRAG.py new file mode 100644 index 0000000..624697e --- /dev/null +++ b/Demo/backend/PathRAG/PathRAG.py @@ -0,0 +1,562 @@ +import asyncio +import os +from tqdm.asyncio import tqdm as tqdm_async +from dataclasses import asdict, dataclass, field +from datetime import datetime +from functools import partial +from typing import Type, cast + + +from .llm import ( + azure_openai_complete, + azure_openai_embedding, +) +from .operate import ( + chunking_by_token_size, + extract_entities, + kg_query, +) + +from .utils import ( + EmbeddingFunc, + compute_mdhash_id, + limit_async_func_call, + convert_response_to_json, + logger, + set_logger, +) +from .base import ( + BaseGraphStorage, + BaseKVStorage, + BaseVectorStorage, + StorageNameSpace, + QueryParam, +) + +from .storage import ( + JsonKVStorage, + NanoVectorDBStorage, + NetworkXStorage, +) + + + + +def lazy_external_import(module_name: str, class_name: str): + """Lazily import a class from an external module based on the package of the caller.""" + + + import inspect + + caller_frame = inspect.currentframe().f_back + module = inspect.getmodule(caller_frame) + package = module.__package__ if module else None + + def import_class(*args, **kwargs): + import importlib + + + module = importlib.import_module(module_name, package=package) + + + cls = getattr(module, class_name) + return cls(*args, **kwargs) + + return import_class + + +Neo4JStorage = lazy_external_import(".kg.neo4j_impl", "Neo4JStorage") +OracleKVStorage = lazy_external_import(".kg.oracle_impl", "OracleKVStorage") +OracleGraphStorage = lazy_external_import(".kg.oracle_impl", "OracleGraphStorage") +OracleVectorDBStorage = lazy_external_import(".kg.oracle_impl", "OracleVectorDBStorage") +MilvusVectorDBStorge = lazy_external_import(".kg.milvus_impl", "MilvusVectorDBStorge") +MongoKVStorage = lazy_external_import(".kg.mongo_impl", "MongoKVStorage") +ChromaVectorDBStorage = lazy_external_import(".kg.chroma_impl", "ChromaVectorDBStorage") +TiDBKVStorage = lazy_external_import(".kg.tidb_impl", "TiDBKVStorage") +TiDBVectorDBStorage = lazy_external_import(".kg.tidb_impl", "TiDBVectorDBStorage") +AGEStorage = lazy_external_import(".kg.age_impl", "AGEStorage") + + +def always_get_an_event_loop() -> asyncio.AbstractEventLoop: + """ + Ensure that there is always an event loop available. + + This function tries to get the current event loop. If the current event loop is closed or does not exist, + it creates a new event loop and sets it as the current event loop. + + Returns: + asyncio.AbstractEventLoop: The current or newly created event loop. + """ + try: + + current_loop = asyncio.get_event_loop() + if current_loop.is_closed(): + raise RuntimeError("Event loop is closed.") + return current_loop + + except RuntimeError: + + logger.info("Creating a new event loop in main thread.") + new_loop = asyncio.new_event_loop() + asyncio.set_event_loop(new_loop) + return new_loop + + +@dataclass +class PathRAG: + working_dir: str = field( + default_factory=lambda: f"./PathRAG_cache_{datetime.now().strftime('%Y-%m-%d-%H:%M:%S')}" + ) + + embedding_cache_config: dict = field( + default_factory=lambda: { + "enabled": False, + "similarity_threshold": 0.95, + "use_llm_check": False, + } + ) + kv_storage: str = field(default="JsonKVStorage") + vector_storage: str = field(default="NanoVectorDBStorage") + graph_storage: str = field(default="NetworkXStorage") + + current_log_level = logger.level + log_level: str = field(default=current_log_level) + + + chunk_token_size: int = 1200 + chunk_overlap_token_size: int = 100 + tiktoken_model_name: str = "gpt-4o-mini" + + + entity_extract_max_gleaning: int = 1 + entity_summary_to_max_tokens: int = 500 + + + node_embedding_algorithm: str = "node2vec" + node2vec_params: dict = field( + default_factory=lambda: { + "dimensions": 1536, + "num_walks": 10, + "walk_length": 40, + "window_size": 2, + "iterations": 3, + "random_seed": 3, + } + ) + + + embedding_func: EmbeddingFunc = field(default_factory=lambda: azure_openai_embedding) + embedding_batch_num: int = 32 + embedding_func_max_async: int = 16 + + + llm_model_func: callable = azure_openai_complete + llm_model_name: str = "gpt-4o" + llm_model_max_token_size: int = 32768 + llm_model_max_async: int = 16 + llm_model_kwargs: dict = field(default_factory=dict) + + + vector_db_storage_cls_kwargs: dict = field(default_factory=dict) + + enable_llm_cache: bool = True + + + addon_params: dict = field(default_factory=dict) + convert_response_to_json_func: callable = convert_response_to_json + + def __post_init__(self): + log_file = os.path.join("PathRAG.log") + set_logger(log_file) + logger.setLevel(self.log_level) + + logger.info(f"Logger initialized for working directory: {self.working_dir}") + + + self.key_string_value_json_storage_cls: Type[BaseKVStorage] = ( + self._get_storage_class()[self.kv_storage] + ) + self.vector_db_storage_cls: Type[BaseVectorStorage] = self._get_storage_class()[ + self.vector_storage + ] + self.graph_storage_cls: Type[BaseGraphStorage] = self._get_storage_class()[ + self.graph_storage + ] + + if not os.path.exists(self.working_dir): + logger.info(f"Creating working directory {self.working_dir}") + os.makedirs(self.working_dir) + + self.llm_response_cache = ( + self.key_string_value_json_storage_cls( + namespace="llm_response_cache", + global_config=asdict(self), + embedding_func=None, + ) + if self.enable_llm_cache + else None + ) + self.embedding_func = limit_async_func_call(self.embedding_func_max_async)( + self.embedding_func + ) + + + self.full_docs = self.key_string_value_json_storage_cls( + namespace="full_docs", + global_config=asdict(self), + embedding_func=self.embedding_func, + ) + self.text_chunks = self.key_string_value_json_storage_cls( + namespace="text_chunks", + global_config=asdict(self), + embedding_func=self.embedding_func, + ) + self.chunk_entity_relation_graph = self.graph_storage_cls( + namespace="chunk_entity_relation", + global_config=asdict(self), + embedding_func=self.embedding_func, + ) + + + self.entities_vdb = self.vector_db_storage_cls( + namespace="entities", + global_config=asdict(self), + embedding_func=self.embedding_func, + meta_fields={"entity_name"}, + ) + self.relationships_vdb = self.vector_db_storage_cls( + namespace="relationships", + global_config=asdict(self), + embedding_func=self.embedding_func, + meta_fields={"src_id", "tgt_id"}, + ) + self.chunks_vdb = self.vector_db_storage_cls( + namespace="chunks", + global_config=asdict(self), + embedding_func=self.embedding_func, + ) + + self.llm_model_func = limit_async_func_call(self.llm_model_max_async)( + partial( + self.llm_model_func, + hashing_kv=self.llm_response_cache + if self.llm_response_cache + and hasattr(self.llm_response_cache, "global_config") + else self.key_string_value_json_storage_cls( + global_config=asdict(self), + ), + **self.llm_model_kwargs, + ) + ) + + def _get_storage_class(self) -> Type[BaseGraphStorage]: + return { + + "JsonKVStorage": JsonKVStorage, + "OracleKVStorage": OracleKVStorage, + "MongoKVStorage": MongoKVStorage, + "TiDBKVStorage": TiDBKVStorage, + + "NanoVectorDBStorage": NanoVectorDBStorage, + "OracleVectorDBStorage": OracleVectorDBStorage, + "MilvusVectorDBStorge": MilvusVectorDBStorge, + "ChromaVectorDBStorage": ChromaVectorDBStorage, + "TiDBVectorDBStorage": TiDBVectorDBStorage, + + "NetworkXStorage": NetworkXStorage, + "Neo4JStorage": Neo4JStorage, + "OracleGraphStorage": OracleGraphStorage, + "AGEStorage": AGEStorage, + + } + + async def insert(self, string_or_strings): + + loop = always_get_an_event_loop() + return await loop.run_until_complete(await self.ainsert(string_or_strings)) + + async def ainsert(self, string_or_strings): + update_storage = False + try: + if isinstance(string_or_strings, str): + string_or_strings = [string_or_strings] + + new_docs = { + compute_mdhash_id(c.strip(), prefix="doc-"): {"content": c.strip()} + for c in string_or_strings + } + _add_doc_keys = await self.full_docs.filter_keys(list(new_docs.keys())) + new_docs = {k: v for k, v in new_docs.items() if k in _add_doc_keys} + if not len(new_docs): + logger.warning("All docs are already in the storage") + return + update_storage = True + logger.info(f"[New Docs] inserting {len(new_docs)} docs") + + inserting_chunks = {} + for doc_key, doc in tqdm_async( + new_docs.items(), desc="Chunking documents", unit="doc" + ): + chunks = { + compute_mdhash_id(dp["content"], prefix="chunk-"): { + **dp, + "full_doc_id": doc_key, + } + for dp in chunking_by_token_size( + doc["content"], + overlap_token_size=self.chunk_overlap_token_size, + max_token_size=self.chunk_token_size, + tiktoken_model=self.tiktoken_model_name, + ) + } + inserting_chunks.update(chunks) + _add_chunk_keys = await self.text_chunks.filter_keys( + list(inserting_chunks.keys()) + ) + inserting_chunks = { + k: v for k, v in inserting_chunks.items() if k in _add_chunk_keys + } + if not len(inserting_chunks): + logger.warning("All chunks are already in the storage") + return + logger.info(f"[New Chunks] inserting {len(inserting_chunks)} chunks") + + await self.chunks_vdb.upsert(inserting_chunks) + + logger.info("[Entity Extraction]...") + maybe_new_kg = await extract_entities( + inserting_chunks, + knowledge_graph_inst=self.chunk_entity_relation_graph, + entity_vdb=self.entities_vdb, + relationships_vdb=self.relationships_vdb, + global_config=asdict(self), + ) + if maybe_new_kg is None: + logger.warning("No new entities and relationships found") + return + self.chunk_entity_relation_graph = maybe_new_kg + + await self.full_docs.upsert(new_docs) + await self.text_chunks.upsert(inserting_chunks) + finally: + if update_storage: + await self._insert_done() + + async def _insert_done(self): + tasks = [] + for storage_inst in [ + self.full_docs, + self.text_chunks, + self.llm_response_cache, + self.entities_vdb, + self.relationships_vdb, + self.chunks_vdb, + self.chunk_entity_relation_graph, + ]: + if storage_inst is None: + continue + tasks.append(cast(StorageNameSpace, storage_inst).index_done_callback()) + await asyncio.gather(*tasks) + + def insert_custom_kg(self, custom_kg: dict): + loop = always_get_an_event_loop() + return loop.run_until_complete(self.ainsert_custom_kg(custom_kg)) + + async def ainsert_custom_kg(self, custom_kg: dict): + update_storage = False + try: + + all_chunks_data = {} + chunk_to_source_map = {} + for chunk_data in custom_kg.get("chunks", []): + chunk_content = chunk_data["content"] + source_id = chunk_data["source_id"] + chunk_id = compute_mdhash_id(chunk_content.strip(), prefix="chunk-") + + chunk_entry = {"content": chunk_content.strip(), "source_id": source_id} + all_chunks_data[chunk_id] = chunk_entry + chunk_to_source_map[source_id] = chunk_id + update_storage = True + + if self.chunks_vdb is not None and all_chunks_data: + await self.chunks_vdb.upsert(all_chunks_data) + if self.text_chunks is not None and all_chunks_data: + await self.text_chunks.upsert(all_chunks_data) + + + all_entities_data = [] + for entity_data in custom_kg.get("entities", []): + entity_name = f'"{entity_data["entity_name"].upper()}"' + entity_type = entity_data.get("entity_type", "UNKNOWN") + description = entity_data.get("description", "No description provided") + + source_chunk_id = entity_data.get("source_id", "UNKNOWN") + source_id = chunk_to_source_map.get(source_chunk_id, "UNKNOWN") + + + if source_id == "UNKNOWN": + logger.warning( + f"Entity '{entity_name}' has an UNKNOWN source_id. Please check the source mapping." + ) + + + node_data = { + "entity_type": entity_type, + "description": description, + "source_id": source_id, + } + + await self.chunk_entity_relation_graph.upsert_node( + entity_name, node_data=node_data + ) + node_data["entity_name"] = entity_name + all_entities_data.append(node_data) + update_storage = True + + + all_relationships_data = [] + for relationship_data in custom_kg.get("relationships", []): + src_id = f'"{relationship_data["src_id"].upper()}"' + tgt_id = f'"{relationship_data["tgt_id"].upper()}"' + description = relationship_data["description"] + keywords = relationship_data["keywords"] + weight = relationship_data.get("weight", 1.0) + + source_chunk_id = relationship_data.get("source_id", "UNKNOWN") + source_id = chunk_to_source_map.get(source_chunk_id, "UNKNOWN") + + + if source_id == "UNKNOWN": + logger.warning( + f"Relationship from '{src_id}' to '{tgt_id}' has an UNKNOWN source_id. Please check the source mapping." + ) + + + for need_insert_id in [src_id, tgt_id]: + if not ( + await self.chunk_entity_relation_graph.has_node(need_insert_id) + ): + await self.chunk_entity_relation_graph.upsert_node( + need_insert_id, + node_data={ + "source_id": source_id, + "description": "UNKNOWN", + "entity_type": "UNKNOWN", + }, + ) + + + await self.chunk_entity_relation_graph.upsert_edge( + src_id, + tgt_id, + edge_data={ + "weight": weight, + "description": description, + "keywords": keywords, + "source_id": source_id, + }, + ) + edge_data = { + "src_id": src_id, + "tgt_id": tgt_id, + "description": description, + "keywords": keywords, + } + all_relationships_data.append(edge_data) + update_storage = True + + + if self.entities_vdb is not None: + data_for_vdb = { + compute_mdhash_id(dp["entity_name"], prefix="ent-"): { + "content": dp["entity_name"] + dp["description"], + "entity_name": dp["entity_name"], + } + for dp in all_entities_data + } + await self.entities_vdb.upsert(data_for_vdb) + + + if self.relationships_vdb is not None: + data_for_vdb = { + compute_mdhash_id(dp["src_id"] + dp["tgt_id"], prefix="rel-"): { + "src_id": dp["src_id"], + "tgt_id": dp["tgt_id"], + "content": dp["keywords"] + + dp["src_id"] + + dp["tgt_id"] + + dp["description"], + } + for dp in all_relationships_data + } + await self.relationships_vdb.upsert(data_for_vdb) + finally: + if update_storage: + await self._insert_done() + + async def query(self, query: str, param: QueryParam = QueryParam()): + loop = always_get_an_event_loop() + return await loop.run_until_complete(await self.aquery(query, param)) + + async def aquery(self, query: str, param: QueryParam = QueryParam()): + if param.mode in ["hybrid"]: + response= await kg_query( + query, + self.chunk_entity_relation_graph, + self.entities_vdb, + self.relationships_vdb, + self.text_chunks, + param, + asdict(self), + hashing_kv=self.llm_response_cache + if self.llm_response_cache + and hasattr(self.llm_response_cache, "global_config") + else self.key_string_value_json_storage_cls( + global_config=asdict(self), + ), + ) + print("response all ready") + else: + raise ValueError(f"Unknown mode {param.mode}") + await self._query_done() + return response + + + async def _query_done(self): + tasks = [] + for storage_inst in [self.llm_response_cache]: + if storage_inst is None: + continue + tasks.append(cast(StorageNameSpace, storage_inst).index_done_callback()) + await asyncio.gather(*tasks) + + def delete_by_entity(self, entity_name: str): + loop = always_get_an_event_loop() + return loop.run_until_complete(self.adelete_by_entity(entity_name)) + + async def adelete_by_entity(self, entity_name: str): + entity_name = f'"{entity_name.upper()}"' + + try: + await self.entities_vdb.delete_entity(entity_name) + await self.relationships_vdb.delete_relation(entity_name) + await self.chunk_entity_relation_graph.delete_node(entity_name) + + logger.info( + f"Entity '{entity_name}' and its relationships have been deleted." + ) + await self._delete_by_entity_done() + except Exception as e: + logger.error(f"Error while deleting entity '{entity_name}': {e}") + + async def _delete_by_entity_done(self): + tasks = [] + for storage_inst in [ + self.entities_vdb, + self.relationships_vdb, + self.chunk_entity_relation_graph, + ]: + if storage_inst is None: + continue + tasks.append(cast(StorageNameSpace, storage_inst).index_done_callback()) + await asyncio.gather(*tasks) diff --git a/Demo/backend/PathRAG/__init__.py b/Demo/backend/PathRAG/__init__.py new file mode 100644 index 0000000..b06a4e4 --- /dev/null +++ b/Demo/backend/PathRAG/__init__.py @@ -0,0 +1,3 @@ +from .PathRAG import PathRAG as PathRAG, QueryParam as QueryParam + + diff --git a/Demo/backend/PathRAG/base.py b/Demo/backend/PathRAG/base.py new file mode 100644 index 0000000..ba6c988 --- /dev/null +++ b/Demo/backend/PathRAG/base.py @@ -0,0 +1,135 @@ +from dataclasses import dataclass, field +from typing import TypedDict, Union, Literal, Generic, TypeVar + +import numpy as np + +from .utils import EmbeddingFunc + +TextChunkSchema = TypedDict( + "TextChunkSchema", + {"tokens": int, "content": str, "full_doc_id": str, "chunk_order_index": int}, +) + +T = TypeVar("T") + + +@dataclass +class QueryParam: + mode: Literal["hybrid"] = "global" + only_need_context: bool = False + only_need_prompt: bool = False + response_type: str = "Multiple Paragraphs" + stream: bool = False + top_k: int =40 + max_token_for_text_unit: int = 4000 + max_token_for_global_context: int = 3000 + max_token_for_local_context: int = 5000 + + +@dataclass +class StorageNameSpace: + namespace: str + global_config: dict + + async def index_done_callback(self): + + pass + + async def query_done_callback(self): + + pass + + +@dataclass +class BaseVectorStorage(StorageNameSpace): + embedding_func: EmbeddingFunc + meta_fields: set = field(default_factory=set) + + async def query(self, query: str, top_k: int) -> list[dict]: + raise NotImplementedError + + async def upsert(self, data: dict[str, dict]): + + raise NotImplementedError + + +@dataclass +class BaseKVStorage(Generic[T], StorageNameSpace): + embedding_func: EmbeddingFunc + + async def all_keys(self) -> list[str]: + raise NotImplementedError + + async def get_by_id(self, id: str) -> Union[T, None]: + raise NotImplementedError + + async def get_by_ids( + self, ids: list[str], fields: Union[set[str], None] = None + ) -> list[Union[T, None]]: + raise NotImplementedError + + async def filter_keys(self, data: list[str]) -> set[str]: + + raise NotImplementedError + + async def upsert(self, data: dict[str, T]): + raise NotImplementedError + + async def drop(self): + raise NotImplementedError + + +@dataclass +class BaseGraphStorage(StorageNameSpace): + embedding_func: EmbeddingFunc = None + + async def has_node(self, node_id: str) -> bool: + raise NotImplementedError + + async def has_edge(self, source_node_id: str, target_node_id: str) -> bool: + raise NotImplementedError + + async def node_degree(self, node_id: str) -> int: + raise NotImplementedError + + async def edge_degree(self, src_id: str, tgt_id: str) -> int: + raise NotImplementedError + + async def get_pagerank(self,node_id:str) -> float: + raise NotImplementedError + + async def get_node(self, node_id: str) -> Union[dict, None]: + raise NotImplementedError + + async def get_edge( + self, source_node_id: str, target_node_id: str + ) -> Union[dict, None]: + raise NotImplementedError + + async def get_node_edges( + self, source_node_id: str + ) -> Union[list[tuple[str, str]], None]: + raise NotImplementedError + + async def get_node_in_edges( + self,source_node_id:str + ) -> Union[list[tuple[str,str]],None]: + raise NotImplementedError + async def get_node_out_edges( + self,source_node_id:str + ) -> Union[list[tuple[str,str]],None]: + raise NotImplementedError + + async def upsert_node(self, node_id: str, node_data: dict[str, str]): + raise NotImplementedError + + async def upsert_edge( + self, source_node_id: str, target_node_id: str, edge_data: dict[str, str] + ): + raise NotImplementedError + + async def delete_node(self, node_id: str): + raise NotImplementedError + + async def embed_nodes(self, algorithm: str) -> tuple[np.ndarray, list[str]]: + raise NotImplementedError("Node embedding is not used in PathRag.") diff --git a/Demo/backend/PathRAG/llm.py b/Demo/backend/PathRAG/llm.py new file mode 100644 index 0000000..865808e --- /dev/null +++ b/Demo/backend/PathRAG/llm.py @@ -0,0 +1,287 @@ + +import os +from typing import List, Dict, Callable, Any, Union, Optional +import aiohttp +import numpy as np + +from openai import ( + AsyncOpenAI, + APIConnectionError, + RateLimitError, + Timeout, + AsyncAzureOpenAI, +) +from pydantic import BaseModel, Field +from tenacity import ( + retry, + stop_after_attempt, + wait_exponential, + retry_if_exception_type, +) +from transformers import AutoTokenizer, AutoModelForCausalLM + +from .utils import ( + wrap_embedding_func_with_attrs, + locate_json_string_body_from_string, + safe_unicode_decode, + logger, +) + +import sys + +if sys.version_info < (3, 9): + from typing import AsyncIterator +else: + from collections.abc import AsyncIterator + +os.environ["TOKENIZERS_PARALLELISM"] = "false" + + +@retry( + stop=stop_after_attempt(3), + wait=wait_exponential(multiplier=1, min=4, max=10), + retry=retry_if_exception_type((RateLimitError, APIConnectionError, Timeout)), +) +async def azure_openai_complete_if_cache( + model, + prompt, + system_prompt=None, + history_messages=[], + base_url=None, + api_key=None, + api_version=None, + **kwargs, +): + if api_key: + os.environ["AZURE_OPENAI_API_KEY"] = api_key + if base_url: + os.environ["AZURE_OPENAI_ENDPOINT"] = base_url + if api_version: + os.environ["AZURE_OPENAI_API_VERSION"] = api_version + + openai_async_client = AsyncAzureOpenAI( + azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"), + api_key=os.getenv("AZURE_OPENAI_API_KEY"), + api_version=os.getenv("AZURE_OPENAI_API_VERSION"), + ) + kwargs.pop("hashing_kv", None) + messages = [] + if system_prompt: + messages.append({"role": "system", "content": system_prompt}) + messages.extend(history_messages) + if prompt is not None: + messages.append({"role": "user", "content": prompt}) + + response = await openai_async_client.chat.completions.create( + model=model, messages=messages, **kwargs + ) + content = response.choices[0].message.content + + return content + +class GPTKeywordExtractionFormat(BaseModel): + high_level_keywords: List[str] + low_level_keywords: List[str] + +async def azure_openai_complete( + prompt, system_prompt=None, history_messages=[], keyword_extraction=False, **kwargs +) -> str: + keyword_extraction = kwargs.pop("keyword_extraction", None) + result = await azure_openai_complete_if_cache( + "gpt-4o", + prompt, + system_prompt=system_prompt, + history_messages=history_messages, + **kwargs, + ) + if keyword_extraction: # TODO: use JSON API + return locate_json_string_body_from_string(result) + return result + +async def fetch_data(url, headers, data): + async with aiohttp.ClientSession() as session: + async with session.post(url, headers=headers, json=data) as response: + response_json = await response.json() + data_list = response_json.get("data", []) + return data_list + +@wrap_embedding_func_with_attrs(embedding_dim=1536, max_token_size=8191) +@retry( + stop=stop_after_attempt(3), + wait=wait_exponential(multiplier=1, min=4, max=10), + retry=retry_if_exception_type((RateLimitError, APIConnectionError, Timeout)), +) +async def azure_openai_embedding( + texts: list[str], + model: str = "text-embedding-3-small", + base_url: str = None, + api_key: str = None, + api_version: str = None, +) -> np.ndarray: + if api_key: + os.environ["AZURE_OPENAI_API_KEY"] = api_key + if base_url: + os.environ["AZURE_OPENAI_ENDPOINT"] = base_url + if api_version: + os.environ["AZURE_OPENAI_API_VERSION"] = api_version + + openai_async_client = AsyncAzureOpenAI( + azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"), + api_key=os.getenv("AZURE_OPENAI_API_KEY"), + api_version=os.getenv("AZURE_OPENAI_API_VERSION"), + ) + + response = await openai_async_client.embeddings.create( + model=model, input=texts, encoding_format="float" + ) + return np.array([dp.embedding for dp in response.data]) + +@retry( + stop=stop_after_attempt(3), + wait=wait_exponential(multiplier=1, min=4, max=10), + retry=retry_if_exception_type((RateLimitError, APIConnectionError, Timeout)), +) +async def azure_openai_complete_if_cache_stream( + model, + prompt, + system_prompt=None, + history_messages=[], + base_url=None, + api_key=None, + api_version=None, + **kwargs, +): + # Set environment variables if provided + if api_key: + os.environ["AZURE_OPENAI_API_KEY"] = api_key + if base_url: + os.environ["AZURE_OPENAI_ENDPOINT"] = base_url + if api_version: + os.environ["AZURE_OPENAI_API_VERSION"] = api_version + + openai_async_client = AsyncAzureOpenAI( + azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"), + api_key=os.getenv("AZURE_OPENAI_API_KEY"), + api_version=os.getenv("AZURE_OPENAI_API_VERSION"), + ) + kwargs.pop("hashing_kv", None) + messages = [] + if system_prompt: + messages.append({"role": "system", "content": system_prompt}) + messages.extend(history_messages) + if prompt is not None: + messages.append({"role": "user", "content": prompt}) + + # Enable streaming mode + kwargs["stream"] = True + + # Iterate over streamed responses + async for response in openai_async_client.chat.completions.create( + model=model, messages=messages, **kwargs + ): + # Each streamed response chunk may include a delta with content + delta = response.choices[0].delta + if "content" in delta: + yield delta["content"] + + +async def azure_openai_complete_stream( + prompt, system_prompt=None, history_messages=[], keyword_extraction=False, **kwargs +): + """ + A streamable version of your azure_openai_complete function. + Note: Keyword extraction while streaming may require accumulating the complete result. + """ + # This function currently streams tokens. If keyword_extraction is enabled, + # you might need to collect the full result and then process it. + async for token in azure_openai_complete_if_cache_stream( + "gpt-4o", + prompt, + system_prompt=system_prompt, + history_messages=history_messages, + **kwargs, + ): + yield token + + +class Model(BaseModel): + """ + This is a Pydantic model class named 'Model' that is used to define a custom language model. + + Attributes: + gen_func (Callable[[Any], str]): A callable function that generates the response from the language model. + The function should take any argument and return a string. + kwargs (Dict[str, Any]): A dictionary that contains the arguments to pass to the callable function. + This could include parameters such as the model name, API key, etc. + + Example usage: + Model(gen_func=openai_complete_if_cache, kwargs={"model": "gpt-4", "api_key": os.environ["OPENAI_API_KEY_1"]}) + + In this example, 'openai_complete_if_cache' is the callable function that generates the response from the OpenAI model. + The 'kwargs' dictionary contains the model name and API key to be passed to the function. + """ + + gen_func: Callable[[Any], str] = Field( + ..., + description="A function that generates the response from the llm. The response must be a string", + ) + kwargs: Dict[str, Any] = Field( + ..., + description="The arguments to pass to the callable function. Eg. the api key, model name, etc", + ) + + class Config: + arbitrary_types_allowed = True + + +class MultiModel: + """ + Distributes the load across multiple language models. Useful for circumventing low rate limits with certain api providers especially if you are on the free tier. + Could also be used for spliting across diffrent models or providers. + + Attributes: + models (List[Model]): A list of language models to be used. + + Usage example: + ```python + models = [ + Model(gen_func=openai_complete_if_cache, kwargs={"model": "gpt-4", "api_key": os.environ["OPENAI_API_KEY_1"]}), + Model(gen_func=openai_complete_if_cache, kwargs={"model": "gpt-4", "api_key": os.environ["OPENAI_API_KEY_2"]}), + Model(gen_func=openai_complete_if_cache, kwargs={"model": "gpt-4", "api_key": os.environ["OPENAI_API_KEY_3"]}), + Model(gen_func=openai_complete_if_cache, kwargs={"model": "gpt-4", "api_key": os.environ["OPENAI_API_KEY_4"]}), + Model(gen_func=openai_complete_if_cache, kwargs={"model": "gpt-4", "api_key": os.environ["OPENAI_API_KEY_5"]}), + ] + multi_model = MultiModel(models) + rag = LightRAG( + llm_model_func=multi_model.llm_model_func + / ..other args + ) + ``` + """ + + def __init__(self, models: List[Model]): + self._models = models + self._current_model = 0 + + def _next_model(self): + self._current_model = (self._current_model + 1) % len(self._models) + return self._models[self._current_model] + + async def llm_model_func( + self, prompt, system_prompt=None, history_messages=[], **kwargs + ) -> str: + kwargs.pop("model", None) + kwargs.pop("keyword_extraction", None) + kwargs.pop("mode", None) + next_model = self._next_model() + args = dict( + prompt=prompt, + system_prompt=system_prompt, + history_messages=history_messages, + **kwargs, + **next_model.kwargs, + ) + + return await next_model.gen_func(**args) + + diff --git a/Demo/backend/PathRAG/operate.py b/Demo/backend/PathRAG/operate.py new file mode 100644 index 0000000..ab35567 --- /dev/null +++ b/Demo/backend/PathRAG/operate.py @@ -0,0 +1,1239 @@ +import asyncio +import json +import re +from tqdm.asyncio import tqdm as tqdm_async +from typing import Union +from collections import Counter, defaultdict +import warnings +import tiktoken +import time +import csv +from .utils import ( + logger, + clean_str, + compute_mdhash_id, + decode_tokens_by_tiktoken, + encode_string_by_tiktoken, + is_float_regex, + list_of_list_to_csv, + pack_user_ass_to_openai_messages, + split_string_by_multi_markers, + truncate_list_by_token_size, + process_combine_contexts, + compute_args_hash, + handle_cache, + save_to_cache, + CacheData, +) +from .base import ( + BaseGraphStorage, + BaseKVStorage, + BaseVectorStorage, + TextChunkSchema, + QueryParam, +) +from .prompt import GRAPH_FIELD_SEP, PROMPTS + + +def chunking_by_token_size( + content: str, overlap_token_size=128, max_token_size=1024, tiktoken_model="gpt-4o" +): + tokens = encode_string_by_tiktoken(content, model_name=tiktoken_model) + results = [] + for index, start in enumerate( + range(0, len(tokens), max_token_size - overlap_token_size) + ): + chunk_content = decode_tokens_by_tiktoken( + tokens[start : start + max_token_size], model_name=tiktoken_model + ) + results.append( + { + "tokens": min(max_token_size, len(tokens) - start), + "content": chunk_content.strip(), + "chunk_order_index": index, + } + ) + return results + + +async def _handle_entity_relation_summary( + entity_or_relation_name: str, + description: str, + global_config: dict, +) -> str: + use_llm_func: callable = global_config["llm_model_func"] + llm_max_tokens = global_config["llm_model_max_token_size"] + tiktoken_model_name = global_config["tiktoken_model_name"] + summary_max_tokens = global_config["entity_summary_to_max_tokens"] + language = global_config["addon_params"].get( + "language", PROMPTS["DEFAULT_LANGUAGE"] + ) + + tokens = encode_string_by_tiktoken(description, model_name=tiktoken_model_name) + if len(tokens) < summary_max_tokens: + return description + prompt_template = PROMPTS["summarize_entity_descriptions"] + use_description = decode_tokens_by_tiktoken( + tokens[:llm_max_tokens], model_name=tiktoken_model_name + ) + context_base = dict( + entity_name=entity_or_relation_name, + description_list=use_description.split(GRAPH_FIELD_SEP), + language=language, + ) + use_prompt = prompt_template.format(**context_base) + logger.debug(f"Trigger summary: {entity_or_relation_name}") + summary = await use_llm_func(use_prompt, max_tokens=summary_max_tokens) + return summary + + +async def _handle_single_entity_extraction( + record_attributes: list[str], + chunk_key: str, +): + if len(record_attributes) < 4 or record_attributes[0] != '"entity"': + return None + + entity_name = clean_str(record_attributes[1].upper()) + if not entity_name.strip(): + return None + entity_type = clean_str(record_attributes[2].upper()) + entity_description = clean_str(record_attributes[3]) + entity_source_id = chunk_key + return dict( + entity_name=entity_name, + entity_type=entity_type, + description=entity_description, + source_id=entity_source_id, + ) + + +async def _handle_single_relationship_extraction( + record_attributes: list[str], + chunk_key: str, +): + if len(record_attributes) < 5 or record_attributes[0] != '"relationship"': + return None + + source = clean_str(record_attributes[1].upper()) + target = clean_str(record_attributes[2].upper()) + edge_description = clean_str(record_attributes[3]) + + edge_keywords = clean_str(record_attributes[4]) + edge_source_id = chunk_key + weight = ( + float(record_attributes[-1]) if is_float_regex(record_attributes[-1]) else 1.0 + ) + return dict( + src_id=source, + tgt_id=target, + weight=weight, + description=edge_description, + keywords=edge_keywords, + source_id=edge_source_id, + ) + + +async def _merge_nodes_then_upsert( + entity_name: str, + nodes_data: list[dict], + knowledge_graph_inst: BaseGraphStorage, + global_config: dict, +): + already_entity_types = [] + already_source_ids = [] + already_description = [] + + already_node = await knowledge_graph_inst.get_node(entity_name) + if already_node is not None: + already_entity_types.append(already_node["entity_type"]) + already_source_ids.extend( + split_string_by_multi_markers(already_node["source_id"], [GRAPH_FIELD_SEP]) + ) + already_description.append(already_node["description"]) + + entity_type = sorted( + Counter( + [dp["entity_type"] for dp in nodes_data] + already_entity_types + ).items(), + key=lambda x: x[1], + reverse=True, + )[0][0] + description = GRAPH_FIELD_SEP.join( + sorted(set([dp["description"] for dp in nodes_data] + already_description)) + ) + source_id = GRAPH_FIELD_SEP.join( + set([dp["source_id"] for dp in nodes_data] + already_source_ids) + ) + description = await _handle_entity_relation_summary( + entity_name, description, global_config + ) + node_data = dict( + entity_type=entity_type, + description=description, + source_id=source_id, + ) + await knowledge_graph_inst.upsert_node( + entity_name, + node_data=node_data, + ) + node_data["entity_name"] = entity_name + return node_data + + +async def _merge_edges_then_upsert( + src_id: str, + tgt_id: str, + edges_data: list[dict], + knowledge_graph_inst: BaseGraphStorage, + global_config: dict, +): + already_weights = [] + already_source_ids = [] + already_description = [] + already_keywords = [] + + if await knowledge_graph_inst.has_edge(src_id, tgt_id): + already_edge = await knowledge_graph_inst.get_edge(src_id, tgt_id) + already_weights.append(already_edge["weight"]) + already_source_ids.extend( + split_string_by_multi_markers(already_edge["source_id"], [GRAPH_FIELD_SEP]) + ) + already_description.append(already_edge["description"]) + already_keywords.extend( + split_string_by_multi_markers(already_edge["keywords"], [GRAPH_FIELD_SEP]) + ) + + weight = sum([dp["weight"] for dp in edges_data] + already_weights) + description = GRAPH_FIELD_SEP.join( + sorted(set([dp["description"] for dp in edges_data] + already_description)) + ) + keywords = GRAPH_FIELD_SEP.join( + sorted(set([dp["keywords"] for dp in edges_data] + already_keywords)) + ) + source_id = GRAPH_FIELD_SEP.join( + set([dp["source_id"] for dp in edges_data] + already_source_ids) + ) + for need_insert_id in [src_id, tgt_id]: + if not (await knowledge_graph_inst.has_node(need_insert_id)): + await knowledge_graph_inst.upsert_node( + need_insert_id, + node_data={ + "source_id": source_id, + "description": description, + "entity_type": '"UNKNOWN"', + }, + ) + description = await _handle_entity_relation_summary( + f"({src_id}, {tgt_id})", description, global_config + ) + await knowledge_graph_inst.upsert_edge( + src_id, + tgt_id, + edge_data=dict( + weight=weight, + description=description, + keywords=keywords, + source_id=source_id, + ), + ) + + edge_data = dict( + src_id=src_id, + tgt_id=tgt_id, + description=description, + keywords=keywords, + ) + + return edge_data + + +async def extract_entities( + chunks: dict[str, TextChunkSchema], + knowledge_graph_inst: BaseGraphStorage, + entity_vdb: BaseVectorStorage, + relationships_vdb: BaseVectorStorage, + global_config: dict, +) -> Union[BaseGraphStorage, None]: + time.sleep(20) + use_llm_func: callable = global_config["llm_model_func"] + entity_extract_max_gleaning = global_config["entity_extract_max_gleaning"] + + ordered_chunks = list(chunks.items()) + + language = global_config["addon_params"].get( + "language", PROMPTS["DEFAULT_LANGUAGE"] + ) + entity_types = global_config["addon_params"].get( + "entity_types", PROMPTS["DEFAULT_ENTITY_TYPES"] + ) + example_number = global_config["addon_params"].get("example_number", None) + if example_number and example_number < len(PROMPTS["entity_extraction_examples"]): + examples = "\n".join( + PROMPTS["entity_extraction_examples"][: int(example_number)] + ) + else: + examples = "\n".join(PROMPTS["entity_extraction_examples"]) + + example_context_base = dict( + tuple_delimiter=PROMPTS["DEFAULT_TUPLE_DELIMITER"], + record_delimiter=PROMPTS["DEFAULT_RECORD_DELIMITER"], + completion_delimiter=PROMPTS["DEFAULT_COMPLETION_DELIMITER"], + entity_types=",".join(entity_types), + language=language, + ) + + examples = examples.format(**example_context_base) + + entity_extract_prompt = PROMPTS["entity_extraction"] + context_base = dict( + tuple_delimiter=PROMPTS["DEFAULT_TUPLE_DELIMITER"], + record_delimiter=PROMPTS["DEFAULT_RECORD_DELIMITER"], + completion_delimiter=PROMPTS["DEFAULT_COMPLETION_DELIMITER"], + entity_types=",".join(entity_types), + examples=examples, + language=language, + ) + + continue_prompt = PROMPTS["entiti_continue_extraction"] + if_loop_prompt = PROMPTS["entiti_if_loop_extraction"] + + already_processed = 0 + already_entities = 0 + already_relations = 0 + + async def _process_single_content(chunk_key_dp: tuple[str, TextChunkSchema]): + nonlocal already_processed, already_entities, already_relations + chunk_key = chunk_key_dp[0] + chunk_dp = chunk_key_dp[1] + content = chunk_dp["content"] + hint_prompt = entity_extract_prompt.format( + **context_base, input_text="{input_text}" + ).format(**context_base, input_text=content) + + final_result = await use_llm_func(hint_prompt) + history = pack_user_ass_to_openai_messages(hint_prompt, final_result) + for now_glean_index in range(entity_extract_max_gleaning): + glean_result = await use_llm_func(continue_prompt, history_messages=history) + + history += pack_user_ass_to_openai_messages(continue_prompt, glean_result) + final_result += glean_result + if now_glean_index == entity_extract_max_gleaning - 1: + break + + if_loop_result: str = await use_llm_func( + if_loop_prompt, history_messages=history + ) + if_loop_result = if_loop_result.strip().strip('"').strip("'").lower() + if if_loop_result != "yes": + break + + records = split_string_by_multi_markers( + final_result, + [context_base["record_delimiter"], context_base["completion_delimiter"]], + ) + + maybe_nodes = defaultdict(list) + maybe_edges = defaultdict(list) + for record in records: + record = re.search(r"\((.*)\)", record) + if record is None: + continue + record = record.group(1) + record_attributes = split_string_by_multi_markers( + record, [context_base["tuple_delimiter"]] + ) + if_entities = await _handle_single_entity_extraction( + record_attributes, chunk_key + ) + if if_entities is not None: + maybe_nodes[if_entities["entity_name"]].append(if_entities) + continue + + if_relation = await _handle_single_relationship_extraction( + record_attributes, chunk_key + ) + if if_relation is not None: + maybe_edges[(if_relation["src_id"], if_relation["tgt_id"])].append( + if_relation + ) + already_processed += 1 + already_entities += len(maybe_nodes) + already_relations += len(maybe_edges) + now_ticks = PROMPTS["process_tickers"][ + already_processed % len(PROMPTS["process_tickers"]) + ] + print( + f"{now_ticks} Processed {already_processed} chunks, {already_entities} entities(duplicated), {already_relations} relations(duplicated)\r", + end="", + flush=True, + ) + return dict(maybe_nodes), dict(maybe_edges) + + results = [] + for result in tqdm_async( + asyncio.as_completed([_process_single_content(c) for c in ordered_chunks]), + total=len(ordered_chunks), + desc="Extracting entities from chunks", + unit="chunk", + ): + results.append(await result) + + maybe_nodes = defaultdict(list) + maybe_edges = defaultdict(list) + for m_nodes, m_edges in results: + for k, v in m_nodes.items(): + maybe_nodes[k].extend(v) + for k, v in m_edges.items(): + maybe_edges[k].extend(v) + logger.info("Inserting entities into storage...") + all_entities_data = [] + for result in tqdm_async( + asyncio.as_completed( + [ + _merge_nodes_then_upsert(k, v, knowledge_graph_inst, global_config) + for k, v in maybe_nodes.items() + ] + ), + total=len(maybe_nodes), + desc="Inserting entities", + unit="entity", + ): + all_entities_data.append(await result) + + logger.info("Inserting relationships into storage...") + all_relationships_data = [] + for result in tqdm_async( + asyncio.as_completed( + [ + _merge_edges_then_upsert( + k[0], k[1], v, knowledge_graph_inst, global_config + ) + for k, v in maybe_edges.items() + ] + ), + total=len(maybe_edges), + desc="Inserting relationships", + unit="relationship", + ): + all_relationships_data.append(await result) + + if not len(all_entities_data) and not len(all_relationships_data): + logger.warning( + "Didn't extract any entities and relationships, maybe your LLM is not working" + ) + return None + + if not len(all_entities_data): + logger.warning("Didn't extract any entities") + if not len(all_relationships_data): + logger.warning("Didn't extract any relationships") + + if entity_vdb is not None: + data_for_vdb = { + compute_mdhash_id(dp["entity_name"], prefix="ent-"): { + "content": dp["entity_name"] + dp["description"], + "entity_name": dp["entity_name"], + } + for dp in all_entities_data + } + await entity_vdb.upsert(data_for_vdb) + + if relationships_vdb is not None: + data_for_vdb = { + compute_mdhash_id(dp["src_id"] + dp["tgt_id"], prefix="rel-"): { + "src_id": dp["src_id"], + "tgt_id": dp["tgt_id"], + "content": dp["keywords"] + + dp["src_id"] + + dp["tgt_id"] + + dp["description"], + } + for dp in all_relationships_data + } + await relationships_vdb.upsert(data_for_vdb) + + return knowledge_graph_inst + + + +async def kg_query( + query, + knowledge_graph_inst: BaseGraphStorage, + entities_vdb: BaseVectorStorage, + relationships_vdb: BaseVectorStorage, + text_chunks_db: BaseKVStorage[TextChunkSchema], + query_param: QueryParam, + global_config: dict, + hashing_kv: BaseKVStorage = None, +) -> str: + + use_model_func = global_config["llm_model_func"] + args_hash = compute_args_hash(query_param.mode, query) + cached_response, quantized, min_val, max_val = await handle_cache( + hashing_kv, args_hash, query, query_param.mode + ) + if cached_response is not None: + return cached_response + + example_number = global_config["addon_params"].get("example_number", None) + if example_number and example_number < len(PROMPTS["keywords_extraction_examples"]): + examples = "\n".join( + PROMPTS["keywords_extraction_examples"][: int(example_number)] + ) + else: + examples = "\n".join(PROMPTS["keywords_extraction_examples"]) + language = global_config["addon_params"].get( + "language", PROMPTS["DEFAULT_LANGUAGE"] + ) + + if query_param.mode not in ["hybrid"]: + logger.error(f"Unknown mode {query_param.mode} in kg_query") + return PROMPTS["fail_response"] + + + kw_prompt_temp = PROMPTS["keywords_extraction"] + kw_prompt = kw_prompt_temp.format(query=query, examples=examples, language=language) + result = await use_model_func(kw_prompt, keyword_extraction=True) + logger.info("kw_prompt result:") + print(result) + try: + + match = re.search(r"\{.*\}", result, re.DOTALL) + if match: + result = match.group(0) + keywords_data = json.loads(result) + + hl_keywords = keywords_data.get("high_level_keywords", []) + ll_keywords = keywords_data.get("low_level_keywords", []) + else: + logger.error("No JSON-like structure found in the result.") + return PROMPTS["fail_response"] + + + except json.JSONDecodeError as e: + print(f"JSON parsing error: {e} {result}") + return PROMPTS["fail_response"] + + + if hl_keywords == [] and ll_keywords == []: + logger.warning("low_level_keywords and high_level_keywords is empty") + return PROMPTS["fail_response"] + if ll_keywords == [] and query_param.mode in ["hybrid"]: + logger.warning("low_level_keywords is empty") + return PROMPTS["fail_response"] + else: + ll_keywords = ", ".join(ll_keywords) + if hl_keywords == [] and query_param.mode in ["hybrid"]: + logger.warning("high_level_keywords is empty") + return PROMPTS["fail_response"] + else: + hl_keywords = ", ".join(hl_keywords) + + + keywords = [ll_keywords, hl_keywords] + context= await _build_query_context( + keywords, + knowledge_graph_inst, + entities_vdb, + relationships_vdb, + text_chunks_db, + query_param, + ) + + + + if query_param.only_need_context: + return context + if context is None: + return PROMPTS["fail_response"] + sys_prompt_temp = PROMPTS["rag_response"] + sys_prompt = sys_prompt_temp.format( + context_data=context, response_type=query_param.response_type + ) + if query_param.only_need_prompt: + return sys_prompt + response = await use_model_func( + query, + system_prompt=sys_prompt, + stream=query_param.stream, + ) + if isinstance(response, str) and len(response) > len(sys_prompt): + response = ( + response.replace(sys_prompt, "") + .replace("user", "") + .replace("model", "") + .replace(query, "") + .replace("", "") + .replace("", "") + .strip() + ) + + + await save_to_cache( + hashing_kv, + CacheData( + args_hash=args_hash, + content=response, + prompt=query, + quantized=quantized, + min_val=min_val, + max_val=max_val, + mode=query_param.mode, + ), + ) + return response + + +async def _build_query_context( + query: list, + knowledge_graph_inst: BaseGraphStorage, + entities_vdb: BaseVectorStorage, + relationships_vdb: BaseVectorStorage, + text_chunks_db: BaseKVStorage[TextChunkSchema], + query_param: QueryParam, +): + ll_entities_context, ll_relations_context, ll_text_units_context = "", "", "" + hl_entities_context, hl_relations_context, hl_text_units_context = "", "", "" + + ll_kewwords, hl_keywrds = query[0], query[1] + if query_param.mode in ["local", "hybrid"]: + if ll_kewwords == "": + ll_entities_context, ll_relations_context, ll_text_units_context = ( + "", + "", + "", + ) + warnings.warn( + "Low Level context is None. Return empty Low entity/relationship/source" + ) + query_param.mode = "global" + else: + ( + ll_entities_context, + ll_relations_context, + ll_text_units_context, + ) = await _get_node_data( + ll_kewwords, + knowledge_graph_inst, + entities_vdb, + text_chunks_db, + query_param, + ) + if query_param.mode in ["hybrid"]: + if hl_keywrds == "": + hl_entities_context, hl_relations_context, hl_text_units_context = ( + "", + "", + "", + ) + warnings.warn( + "High Level context is None. Return empty High entity/relationship/source" + ) + query_param.mode = "local" + else: + ( + hl_entities_context, + hl_relations_context, + hl_text_units_context, + ) = await _get_edge_data( + hl_keywrds, + knowledge_graph_inst, + relationships_vdb, + text_chunks_db, + query_param, + ) + if ( + hl_entities_context == "" + and hl_relations_context == "" + and hl_text_units_context == "" + ): + logger.warn("No high level context found. Switching to local mode.") + query_param.mode = "local" + if query_param.mode == "hybrid": + entities_context, relations_context, text_units_context = combine_contexts( + [hl_entities_context, hl_relations_context], + [ll_entities_context, ll_relations_context], + [hl_text_units_context, ll_text_units_context], + ) + + + return f""" +-----global-information----- +-----high-level entity information----- +```csv +{hl_entities_context} +``` +-----high-level relationship information----- +```csv +{hl_relations_context} +``` +-----Sources----- +```csv +{text_units_context} +``` +-----local-information----- +-----low-level entity information----- +```csv +{ll_entities_context} +``` +-----low-level relationship information----- +```csv +{ll_relations_context} +``` +""" + +async def _get_node_data( + query, + knowledge_graph_inst: BaseGraphStorage, + entities_vdb: BaseVectorStorage, + text_chunks_db: BaseKVStorage[TextChunkSchema], + query_param: QueryParam, +): + + results = await entities_vdb.query(query, top_k=query_param.top_k) + if not len(results): + return "", "", "" + + node_datas = await asyncio.gather( + *[knowledge_graph_inst.get_node(r["entity_name"]) for r in results] + ) + if not all([n is not None for n in node_datas]): + logger.warning("Some nodes are missing, maybe the storage is damaged") + + + node_degrees = await asyncio.gather( + *[knowledge_graph_inst.node_degree(r["entity_name"]) for r in results] + ) + node_datas = [ + {**n, "entity_name": k["entity_name"], "rank": d} + for k, n, d in zip(results, node_datas, node_degrees) + if n is not None + ] + use_text_units = await _find_most_related_text_unit_from_entities( + node_datas, query_param, text_chunks_db, knowledge_graph_inst + ) + + + use_relations= await _find_most_related_edges_from_entities3( + node_datas, query_param, knowledge_graph_inst + ) + + logger.info( + f"Local query uses {len(node_datas)} entites, {len(use_relations)} relations, {len(use_text_units)} text units" + ) + + + entites_section_list = [["id", "entity", "type", "description", "rank"]] + for i, n in enumerate(node_datas): + entites_section_list.append( + [ + i, + n["entity_name"], + n.get("entity_type", "UNKNOWN"), + n.get("description", "UNKNOWN"), + n["rank"], + ] + ) + entities_context = list_of_list_to_csv(entites_section_list) + + relations_section_list=[["id","context"]] + for i,e in enumerate(use_relations): + relations_section_list.append([i,e]) + relations_context=list_of_list_to_csv(relations_section_list) + + text_units_section_list = [["id", "content"]] + for i, t in enumerate(use_text_units): + text_units_section_list.append([i, t["content"]]) + text_units_context = list_of_list_to_csv(text_units_section_list) + + return entities_context,relations_context,text_units_context + + +async def _find_most_related_text_unit_from_entities( + node_datas: list[dict], + query_param: QueryParam, + text_chunks_db: BaseKVStorage[TextChunkSchema], + knowledge_graph_inst: BaseGraphStorage, +): + text_units = [ + split_string_by_multi_markers(dp["source_id"], [GRAPH_FIELD_SEP]) + for dp in node_datas + ] + edges = await asyncio.gather( + *[knowledge_graph_inst.get_node_edges(dp["entity_name"]) for dp in node_datas] + ) + all_one_hop_nodes = set() + for this_edges in edges: + if not this_edges: + continue + all_one_hop_nodes.update([e[1] for e in this_edges]) + + all_one_hop_nodes = list(all_one_hop_nodes) + all_one_hop_nodes_data = await asyncio.gather( + *[knowledge_graph_inst.get_node(e) for e in all_one_hop_nodes] + ) + + + all_one_hop_text_units_lookup = { + k: set(split_string_by_multi_markers(v["source_id"], [GRAPH_FIELD_SEP])) + for k, v in zip(all_one_hop_nodes, all_one_hop_nodes_data) + if v is not None and "source_id" in v + } + + all_text_units_lookup = {} + for index, (this_text_units, this_edges) in enumerate(zip(text_units, edges)): + for c_id in this_text_units: + if c_id not in all_text_units_lookup: + all_text_units_lookup[c_id] = { + "data": await text_chunks_db.get_by_id(c_id), + "order": index, + "relation_counts": 0, + } + + if this_edges: + for e in this_edges: + if ( + e[1] in all_one_hop_text_units_lookup + and c_id in all_one_hop_text_units_lookup[e[1]] + ): + all_text_units_lookup[c_id]["relation_counts"] += 1 + + + all_text_units = [ + {"id": k, **v} + for k, v in all_text_units_lookup.items() + if v is not None and v.get("data") is not None and "content" in v["data"] + ] + + if not all_text_units: + logger.warning("No valid text units found") + return [] + + all_text_units = sorted( + all_text_units, key=lambda x: (x["order"], -x["relation_counts"]) + ) + + all_text_units = truncate_list_by_token_size( + all_text_units, + key=lambda x: x["data"]["content"], + max_token_size=query_param.max_token_for_text_unit, + ) + + all_text_units = [t["data"] for t in all_text_units] + return all_text_units + +async def _get_edge_data( + keywords, + knowledge_graph_inst: BaseGraphStorage, + relationships_vdb: BaseVectorStorage, + text_chunks_db: BaseKVStorage[TextChunkSchema], + query_param: QueryParam, +): + results = await relationships_vdb.query(keywords, top_k=query_param.top_k) + + if not len(results): + return "", "", "" + + edge_datas = await asyncio.gather( + *[knowledge_graph_inst.get_edge(r["src_id"], r["tgt_id"]) for r in results] + ) + + if not all([n is not None for n in edge_datas]): + logger.warning("Some edges are missing, maybe the storage is damaged") + edge_degree = await asyncio.gather( + *[knowledge_graph_inst.edge_degree(r["src_id"], r["tgt_id"]) for r in results] + ) + edge_datas = [ + {"src_id": k["src_id"], "tgt_id": k["tgt_id"], "rank": d, **v} + for k, v, d in zip(results, edge_datas, edge_degree) + if v is not None + ] + edge_datas = sorted( + edge_datas, key=lambda x: (x["rank"], x["weight"]), reverse=True + ) + edge_datas = truncate_list_by_token_size( + edge_datas, + key=lambda x: x["description"], + max_token_size=query_param.max_token_for_global_context, + ) + + use_entities = await _find_most_related_entities_from_relationships( + edge_datas, query_param, knowledge_graph_inst + ) + use_text_units = await _find_related_text_unit_from_relationships( + edge_datas, query_param, text_chunks_db, knowledge_graph_inst + ) + logger.info( + f"Global query uses {len(use_entities)} entites, {len(edge_datas)} relations, {len(use_text_units)} text units" + ) + + relations_section_list = [ + ["id", "source", "target", "description", "keywords", "weight", "rank"] + ] + for i, e in enumerate(edge_datas): + relations_section_list.append( + [ + i, + e["src_id"], + e["tgt_id"], + e["description"], + e["keywords"], + e["weight"], + e["rank"], + ] + ) + relations_context = list_of_list_to_csv(relations_section_list) + + entites_section_list = [["id", "entity", "type", "description", "rank"]] + for i, n in enumerate(use_entities): + entites_section_list.append( + [ + i, + n["entity_name"], + n.get("entity_type", "UNKNOWN"), + n.get("description", "UNKNOWN"), + n["rank"], + ] + ) + entities_context = list_of_list_to_csv(entites_section_list) + + text_units_section_list = [["id", "content"]] + for i, t in enumerate(use_text_units): + text_units_section_list.append([i, t["content"]]) + text_units_context = list_of_list_to_csv(text_units_section_list) + return entities_context, relations_context, text_units_context + + +async def _find_most_related_entities_from_relationships( + edge_datas: list[dict], + query_param: QueryParam, + knowledge_graph_inst: BaseGraphStorage, +): + entity_names = [] + seen = set() + + for e in edge_datas: + if e["src_id"] not in seen: + entity_names.append(e["src_id"]) + seen.add(e["src_id"]) + if e["tgt_id"] not in seen: + entity_names.append(e["tgt_id"]) + seen.add(e["tgt_id"]) + + node_datas = await asyncio.gather( + *[knowledge_graph_inst.get_node(entity_name) for entity_name in entity_names] + ) + + node_degrees = await asyncio.gather( + *[knowledge_graph_inst.node_degree(entity_name) for entity_name in entity_names] + ) + node_datas = [ + {**n, "entity_name": k, "rank": d} + for k, n, d in zip(entity_names, node_datas, node_degrees) + ] + + node_datas = truncate_list_by_token_size( + node_datas, + key=lambda x: x["description"], + max_token_size=query_param.max_token_for_local_context, + ) + + return node_datas + + +async def _find_related_text_unit_from_relationships( + edge_datas: list[dict], + query_param: QueryParam, + text_chunks_db: BaseKVStorage[TextChunkSchema], + knowledge_graph_inst: BaseGraphStorage, +): + text_units = [ + split_string_by_multi_markers(dp["source_id"], [GRAPH_FIELD_SEP]) + for dp in edge_datas + ] + all_text_units_lookup = {} + + for index, unit_list in enumerate(text_units): + for c_id in unit_list: + if c_id not in all_text_units_lookup: + chunk_data = await text_chunks_db.get_by_id(c_id) + + if chunk_data is not None and "content" in chunk_data: + all_text_units_lookup[c_id] = { + "data": chunk_data, + "order": index, + } + + if not all_text_units_lookup: + logger.warning("No valid text chunks found") + return [] + + all_text_units = [{"id": k, **v} for k, v in all_text_units_lookup.items()] + all_text_units = sorted(all_text_units, key=lambda x: x["order"]) + + + valid_text_units = [ + t for t in all_text_units if t["data"] is not None and "content" in t["data"] + ] + + if not valid_text_units: + logger.warning("No valid text chunks after filtering") + return [] + + truncated_text_units = truncate_list_by_token_size( + valid_text_units, + key=lambda x: x["data"]["content"], + max_token_size=query_param.max_token_for_text_unit, + ) + + all_text_units: list[TextChunkSchema] = [t["data"] for t in truncated_text_units] + + return all_text_units + + +def combine_contexts(entities, relationships, sources): + + hl_entities, ll_entities = entities[0], entities[1] + hl_relationships, ll_relationships = relationships[0], relationships[1] + hl_sources, ll_sources = sources[0], sources[1] + + combined_entities = process_combine_contexts(hl_entities, ll_entities) + + combined_relationships = process_combine_contexts( + hl_relationships, ll_relationships + ) + + combined_sources = process_combine_contexts(hl_sources, ll_sources) + + return combined_entities, combined_relationships, combined_sources + + +import networkx as nx +from collections import defaultdict +async def find_paths_and_edges_with_stats(graph, target_nodes): + + result = defaultdict(lambda: {"paths": [], "edges": set()}) + path_stats = {"1-hop": 0, "2-hop": 0, "3-hop": 0} + one_hop_paths = [] + two_hop_paths = [] + three_hop_paths = [] + + async def dfs(current, target, path, depth): + + if depth > 3: + return + if current == target: + result[(path[0], target)]["paths"].append(list(path)) + for u, v in zip(path[:-1], path[1:]): + result[(path[0], target)]["edges"].add(tuple(sorted((u, v)))) + if depth == 1: + path_stats["1-hop"] += 1 + one_hop_paths.append(list(path)) + elif depth == 2: + path_stats["2-hop"] += 1 + two_hop_paths.append(list(path)) + elif depth == 3: + path_stats["3-hop"] += 1 + three_hop_paths.append(list(path)) + return + neighbors = graph.neighbors(current) + for neighbor in neighbors: + if neighbor not in path: + await dfs(neighbor, target, path + [neighbor], depth + 1) + + for node1 in target_nodes: + for node2 in target_nodes: + if node1 != node2: + await dfs(node1, node2, [node1], 0) + + for key in result: + result[key]["edges"] = list(result[key]["edges"]) + + return dict(result), path_stats , one_hop_paths, two_hop_paths, three_hop_paths +def bfs_weighted_paths(G, path, source, target, threshold, alpha): + results = [] + edge_weights = defaultdict(float) + node = source + follow_dict = {} + + for p in path: + for i in range(len(p) - 1): + current = p[i] + next_num = p[i + 1] + + if current in follow_dict: + follow_dict[current].add(next_num) + else: + follow_dict[current] = {next_num} + + for neighbor in follow_dict[node]: + edge_weights[(node, neighbor)] += 1/len(follow_dict[node]) + + if neighbor == target: + results.append(([node, neighbor])) + continue + + if edge_weights[(node, neighbor)] > threshold: + + for second_neighbor in follow_dict[neighbor]: + weight = edge_weights[(node, neighbor)] * alpha / len(follow_dict[neighbor]) + edge_weights[(neighbor, second_neighbor)] += weight + + if second_neighbor == target: + results.append(([node, neighbor, second_neighbor])) + continue + + if edge_weights[(neighbor, second_neighbor)] > threshold: + + for third_neighbor in follow_dict[second_neighbor]: + weight = edge_weights[(neighbor, second_neighbor)] * alpha / len(follow_dict[second_neighbor]) + edge_weights[(second_neighbor, third_neighbor)] += weight + + if third_neighbor == target : + results.append(([node, neighbor, second_neighbor, third_neighbor])) + continue + path_weights = [] + for p in path: + path_weight = 0 + for i in range(len(p) - 1): + edge = (p[i], p[i + 1]) + path_weight += edge_weights.get(edge, 0) + path_weights.append(path_weight/(len(p)-1)) + + combined = [(p, w) for p, w in zip(path, path_weights)] + + return combined +async def _find_most_related_edges_from_entities3( + node_datas: list[dict], + query_param: QueryParam, + knowledge_graph_inst: BaseGraphStorage, +): + + G = nx.Graph() + edges = await knowledge_graph_inst.edges() + nodes = await knowledge_graph_inst.nodes() + + for u, v in edges: + G.add_edge(u, v) + G.add_nodes_from(nodes) + source_nodes = [dp["entity_name"] for dp in node_datas] + result, path_stats, one_hop_paths, two_hop_paths, three_hop_paths = await find_paths_and_edges_with_stats(G, source_nodes) + + + threshold = 0.3 + alpha = 0.8 + all_results = [] + + for node1 in source_nodes: + for node2 in source_nodes: + if node1 != node2: + if (node1, node2) in result: + sub_G = nx.Graph() + paths = result[(node1,node2)]['paths'] + edges = result[(node1,node2)]['edges'] + sub_G.add_edges_from(edges) + results = bfs_weighted_paths(G, paths, node1, node2, threshold, alpha) + all_results+= results + all_results = sorted(all_results, key=lambda x: x[1], reverse=True) + seen = set() + result_edge = [] + for edge, weight in all_results: + sorted_edge = tuple(sorted(edge)) + if sorted_edge not in seen: + seen.add(sorted_edge) + result_edge.append((edge, weight)) + + + length_1 = int(len(one_hop_paths)/2) + length_2 = int(len(two_hop_paths)/2) + length_3 = int(len(three_hop_paths)/2) + results = [] + if one_hop_paths!=[]: + results = one_hop_paths[0:length_1] + if two_hop_paths!=[]: + results = results + two_hop_paths[0:length_2] + if three_hop_paths!=[]: + results =results + three_hop_paths[0:length_3] + + length = len(results) + total_edges = 15 + if length < total_edges: + total_edges = length + sort_result = [] + if result_edge: + if len(result_edge)>total_edges: + sort_result = result_edge[0:total_edges] + else : + sort_result = result_edge + final_result = [] + for edge, weight in sort_result: + final_result.append(edge) + + relationship = [] + + for path in final_result: + if len(path) == 4: + s_name,b1_name,b2_name,t_name = path[0],path[1],path[2],path[3] + edge0 = await knowledge_graph_inst.get_edge(path[0], path[1]) or await knowledge_graph_inst.get_edge(path[1], path[0]) + edge1 = await knowledge_graph_inst.get_edge(path[1],path[2]) or await knowledge_graph_inst.get_edge(path[2], path[1]) + edge2 = await knowledge_graph_inst.get_edge(path[2],path[3]) or await knowledge_graph_inst.get_edge(path[3], path[2]) + if edge0==None or edge1==None or edge2==None: + print(path,"边丢失") + if edge0==None: + print("edge0丢失") + if edge1==None: + print("edge1丢失") + if edge2==None: + print("edge2丢失") + continue + e1 = "through edge ("+edge0["keywords"]+") to connect to "+s_name+" and "+b1_name+"." + e2 = "through edge ("+edge1["keywords"]+") to connect to "+b1_name+" and "+b2_name+"." + e3 = "through edge ("+edge2["keywords"]+") to connect to "+b2_name+" and "+t_name+"." + s = await knowledge_graph_inst.get_node(s_name) + s = "The entity "+s_name+" is a "+s["entity_type"]+" with the description("+s["description"]+")" + b1 = await knowledge_graph_inst.get_node(b1_name) + b1 = "The entity "+b1_name+" is a "+b1["entity_type"]+" with the description("+b1["description"]+")" + b2 = await knowledge_graph_inst.get_node(b2_name) + b2 = "The entity "+b2_name+" is a "+b2["entity_type"]+" with the description("+b2["description"]+")" + t = await knowledge_graph_inst.get_node(t_name) + t = "The entity "+t_name+" is a "+t["entity_type"]+" with the description("+t["description"]+")" + relationship.append([s+e1+b1+"and"+b1+e2+b2+"and"+b2+e3+t]) + elif len(path) == 3: + s_name,b_name,t_name = path[0],path[1],path[2] + edge0 = await knowledge_graph_inst.get_edge(path[0], path[1]) or await knowledge_graph_inst.get_edge(path[1], path[0]) + edge1 = await knowledge_graph_inst.get_edge(path[1],path[2]) or await knowledge_graph_inst.get_edge(path[2], path[1]) + if edge0==None or edge1==None: + print(path,"边丢失") + continue + e1 = "through edge("+edge0["keywords"]+") to connect to "+s_name+" and "+b_name+"." + e2 = "through edge("+edge1["keywords"]+") to connect to "+b_name+" and "+t_name+"." + s = await knowledge_graph_inst.get_node(s_name) + s = "The entity "+s_name+" is a "+s["entity_type"]+" with the description("+s["description"]+")" + b = await knowledge_graph_inst.get_node(b_name) + b = "The entity "+b_name+" is a "+b["entity_type"]+" with the description("+b["description"]+")" + t = await knowledge_graph_inst.get_node(t_name) + t = "The entity "+t_name+" is a "+t["entity_type"]+" with the description("+t["description"]+")" + relationship.append([s+e1+b+"and"+b+e2+t]) + elif len(path) == 2: + s_name,t_name = path[0],path[1] + edge0 = await knowledge_graph_inst.get_edge(path[0], path[1]) or await knowledge_graph_inst.get_edge(path[1], path[0]) + if edge0==None: + print(path,"边丢失") + continue + e = "through edge("+edge0["keywords"]+") to connect to "+s_name+" and "+t_name+"." + s = await knowledge_graph_inst.get_node(s_name) + s = "The entity "+s_name+" is a "+s["entity_type"]+" with the description("+s["description"]+")" + t = await knowledge_graph_inst.get_node(t_name) + t = "The entity "+t_name+" is a "+t["entity_type"]+" with the description("+t["description"]+")" + relationship.append([s+e+t]) + + + relationship = truncate_list_by_token_size( + relationship, + key=lambda x: x[0], + max_token_size=query_param.max_token_for_local_context, + ) + + reversed_relationship = relationship[::-1] + return reversed_relationship \ No newline at end of file diff --git a/Demo/backend/PathRAG/prompt.py b/Demo/backend/PathRAG/prompt.py new file mode 100644 index 0000000..9d9e603 --- /dev/null +++ b/Demo/backend/PathRAG/prompt.py @@ -0,0 +1,286 @@ +GRAPH_FIELD_SEP = "" + +PROMPTS = {} + +PROMPTS["DEFAULT_LANGUAGE"] = "English" +PROMPTS["DEFAULT_TUPLE_DELIMITER"] = "<|>" +PROMPTS["DEFAULT_RECORD_DELIMITER"] = "##" +PROMPTS["DEFAULT_COMPLETION_DELIMITER"] = "<|COMPLETE|>" +PROMPTS["process_tickers"] = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] + +PROMPTS["DEFAULT_ENTITY_TYPES"] = ["organization", "person", "geo", "event", "category"] + +PROMPTS["entity_extraction"] = """-Goal- +Given a text document that is potentially relevant to this activity and a list of entity types, identify all entities of those types from the text and all relationships among the identified entities. +Use {language} as output language. + +-Steps- +1. Identify all entities. For each identified entity, extract the following information: +- entity_name: Name of the entity, use same language as input text. If English, capitalized the name. +- entity_type: One of the following types: [{entity_types}] +- entity_description: Comprehensive description of the entity's attributes and activities +Format each entity as ("entity"{tuple_delimiter}{tuple_delimiter}{tuple_delimiter}) + +2. From the entities identified in step 1, identify all pairs of (source_entity, target_entity) that are *clearly related* to each other. +For each pair of related entities, extract the following information: +- source_entity: name of the source entity, as identified in step 1 +- target_entity: name of the target entity, as identified in step 1 +- relationship_description: explanation as to why you think the source entity and the target entity are related to each other +- relationship_strength: a numeric score indicating strength of the relationship between the source entity and target entity +- relationship_keywords: one or more high-level key words that summarize the overarching nature of the relationship, focusing on concepts or themes rather than specific details +Format each relationship as ("relationship"{tuple_delimiter}{tuple_delimiter}{tuple_delimiter}{tuple_delimiter}{tuple_delimiter}) + +3. Identify high-level key words that summarize the main concepts, themes, or topics of the entire text. These should capture the overarching ideas present in the document. +Format the content-level key words as ("content_keywords"{tuple_delimiter}) + +4. Return output in {language} as a single list of all the entities and relationships identified in steps 1 and 2. Use **{record_delimiter}** as the list delimiter. + +5. When finished, output {completion_delimiter} + +###################### +-Examples- +###################### +{examples} + +############################# +-Real Data- +###################### +Entity_types: {entity_types} +Text: {input_text} +###################### +Output: +""" + +PROMPTS["entity_extraction_examples"] = [ + """Example 1: + +Entity_types: [person, technology, mission, organization, location] +Text: +while Alex clenched his jaw, the buzz of frustration dull against the backdrop of Taylor's authoritarian certainty. It was this competitive undercurrent that kept him alert, the sense that his and Jordan's shared commitment to discovery was an unspoken rebellion against Cruz's narrowing vision of control and order. + +Then Taylor did something unexpected. They paused beside Jordan and, for a moment, observed the device with something akin to reverence. “If this tech can be understood..." Taylor said, their voice quieter, "It could change the game for us. For all of us.” + +The underlying dismissal earlier seemed to falter, replaced by a glimpse of reluctant respect for the gravity of what lay in their hands. Jordan looked up, and for a fleeting heartbeat, their eyes locked with Taylor's, a wordless clash of wills softening into an uneasy truce. + +It was a small transformation, barely perceptible, but one that Alex noted with an inward nod. They had all been brought here by different paths +################ +Output: +("entity"{tuple_delimiter}"Alex"{tuple_delimiter}"person"{tuple_delimiter}"Alex is a character who experiences frustration and is observant of the dynamics among other characters."){record_delimiter} +("entity"{tuple_delimiter}"Taylor"{tuple_delimiter}"person"{tuple_delimiter}"Taylor is portrayed with authoritarian certainty and shows a moment of reverence towards a device, indicating a change in perspective."){record_delimiter} +("entity"{tuple_delimiter}"Jordan"{tuple_delimiter}"person"{tuple_delimiter}"Jordan shares a commitment to discovery and has a significant interaction with Taylor regarding a device."){record_delimiter} +("entity"{tuple_delimiter}"Cruz"{tuple_delimiter}"person"{tuple_delimiter}"Cruz is associated with a vision of control and order, influencing the dynamics among other characters."){record_delimiter} +("entity"{tuple_delimiter}"The Device"{tuple_delimiter}"technology"{tuple_delimiter}"The Device is central to the story, with potential game-changing implications, and is revered by Taylor."){record_delimiter} +("relationship"{tuple_delimiter}"Alex"{tuple_delimiter}"Taylor"{tuple_delimiter}"Alex is affected by Taylor's authoritarian certainty and observes changes in Taylor's attitude towards the device."{tuple_delimiter}"power dynamics, perspective shift"{tuple_delimiter}7){record_delimiter} +("relationship"{tuple_delimiter}"Alex"{tuple_delimiter}"Jordan"{tuple_delimiter}"Alex and Jordan share a commitment to discovery, which contrasts with Cruz's vision."{tuple_delimiter}"shared goals, rebellion"{tuple_delimiter}6){record_delimiter} +("relationship"{tuple_delimiter}"Taylor"{tuple_delimiter}"Jordan"{tuple_delimiter}"Taylor and Jordan interact directly regarding the device, leading to a moment of mutual respect and an uneasy truce."{tuple_delimiter}"conflict resolution, mutual respect"{tuple_delimiter}8){record_delimiter} +("relationship"{tuple_delimiter}"Jordan"{tuple_delimiter}"Cruz"{tuple_delimiter}"Jordan's commitment to discovery is in rebellion against Cruz's vision of control and order."{tuple_delimiter}"ideological conflict, rebellion"{tuple_delimiter}5){record_delimiter} +("relationship"{tuple_delimiter}"Taylor"{tuple_delimiter}"The Device"{tuple_delimiter}"Taylor shows reverence towards the device, indicating its importance and potential impact."{tuple_delimiter}"reverence, technological significance"{tuple_delimiter}9){record_delimiter} +("content_keywords"{tuple_delimiter}"power dynamics, ideological conflict, discovery, rebellion"){completion_delimiter} +#############################""", + """Example 2: + +Entity_types: [person, technology, mission, organization, location] +Text: +They were no longer mere operatives; they had become guardians of a threshold, keepers of a message from a realm beyond stars and stripes. This elevation in their mission could not be shackled by regulations and established protocols—it demanded a new perspective, a new resolve. + +Tension threaded through the dialogue of beeps and static as communications with Washington buzzed in the background. The team stood, a portentous air enveloping them. It was clear that the decisions they made in the ensuing hours could redefine humanity's place in the cosmos or condemn them to ignorance and potential peril. + +Their connection to the stars solidified, the group moved to address the crystallizing warning, shifting from passive recipients to active participants. Mercer's latter instincts gained precedence— the team's mandate had evolved, no longer solely to observe and report but to interact and prepare. A metamorphosis had begun, and Operation: Dulce hummed with the newfound frequency of their daring, a tone set not by the earthly +############# +Output: +("entity"{tuple_delimiter}"Washington"{tuple_delimiter}"location"{tuple_delimiter}"Washington is a location where communications are being received, indicating its importance in the decision-making process."){record_delimiter} +("entity"{tuple_delimiter}"Operation: Dulce"{tuple_delimiter}"mission"{tuple_delimiter}"Operation: Dulce is described as a mission that has evolved to interact and prepare, indicating a significant shift in objectives and activities."){record_delimiter} +("entity"{tuple_delimiter}"The team"{tuple_delimiter}"organization"{tuple_delimiter}"The team is portrayed as a group of individuals who have transitioned from passive observers to active participants in a mission, showing a dynamic change in their role."){record_delimiter} +("relationship"{tuple_delimiter}"The team"{tuple_delimiter}"Washington"{tuple_delimiter}"The team receives communications from Washington, which influences their decision-making process."{tuple_delimiter}"decision-making, external influence"{tuple_delimiter}7){record_delimiter} +("relationship"{tuple_delimiter}"The team"{tuple_delimiter}"Operation: Dulce"{tuple_delimiter}"The team is directly involved in Operation: Dulce, executing its evolved objectives and activities."{tuple_delimiter}"mission evolution, active participation"{tuple_delimiter}9){completion_delimiter} +("content_keywords"{tuple_delimiter}"mission evolution, decision-making, active participation, cosmic significance"){completion_delimiter} +#############################""", + """Example 3: + +Entity_types: [person, role, technology, organization, event, location, concept] +Text: +their voice slicing through the buzz of activity. "Control may be an illusion when facing an intelligence that literally writes its own rules," they stated stoically, casting a watchful eye over the flurry of data. + +"It's like it's learning to communicate," offered Sam Rivera from a nearby interface, their youthful energy boding a mix of awe and anxiety. "This gives talking to strangers' a whole new meaning." + +Alex surveyed his team—each face a study in concentration, determination, and not a small measure of trepidation. "This might well be our first contact," he acknowledged, "And we need to be ready for whatever answers back." + +Together, they stood on the edge of the unknown, forging humanity's response to a message from the heavens. The ensuing silence was palpable—a collective introspection about their role in this grand cosmic play, one that could rewrite human history. + +The encrypted dialogue continued to unfold, its intricate patterns showing an almost uncanny anticipation +############# +Output: +("entity"{tuple_delimiter}"Sam Rivera"{tuple_delimiter}"person"{tuple_delimiter}"Sam Rivera is a member of a team working on communicating with an unknown intelligence, showing a mix of awe and anxiety."){record_delimiter} +("entity"{tuple_delimiter}"Alex"{tuple_delimiter}"person"{tuple_delimiter}"Alex is the leader of a team attempting first contact with an unknown intelligence, acknowledging the significance of their task."){record_delimiter} +("entity"{tuple_delimiter}"Control"{tuple_delimiter}"concept"{tuple_delimiter}"Control refers to the ability to manage or govern, which is challenged by an intelligence that writes its own rules."){record_delimiter} +("entity"{tuple_delimiter}"Intelligence"{tuple_delimiter}"concept"{tuple_delimiter}"Intelligence here refers to an unknown entity capable of writing its own rules and learning to communicate."){record_delimiter} +("entity"{tuple_delimiter}"First Contact"{tuple_delimiter}"event"{tuple_delimiter}"First Contact is the potential initial communication between humanity and an unknown intelligence."){record_delimiter} +("entity"{tuple_delimiter}"Humanity's Response"{tuple_delimiter}"event"{tuple_delimiter}"Humanity's Response is the collective action taken by Alex's team in response to a message from an unknown intelligence."){record_delimiter} +("relationship"{tuple_delimiter}"Sam Rivera"{tuple_delimiter}"Intelligence"{tuple_delimiter}"Sam Rivera is directly involved in the process of learning to communicate with the unknown intelligence."{tuple_delimiter}"communication, learning process"{tuple_delimiter}9){record_delimiter} +("relationship"{tuple_delimiter}"Alex"{tuple_delimiter}"First Contact"{tuple_delimiter}"Alex leads the team that might be making the First Contact with the unknown intelligence."{tuple_delimiter}"leadership, exploration"{tuple_delimiter}10){record_delimiter} +("relationship"{tuple_delimiter}"Alex"{tuple_delimiter}"Humanity's Response"{tuple_delimiter}"Alex and his team are the key figures in Humanity's Response to the unknown intelligence."{tuple_delimiter}"collective action, cosmic significance"{tuple_delimiter}8){record_delimiter} +("relationship"{tuple_delimiter}"Control"{tuple_delimiter}"Intelligence"{tuple_delimiter}"The concept of Control is challenged by the Intelligence that writes its own rules."{tuple_delimiter}"power dynamics, autonomy"{tuple_delimiter}7){record_delimiter} +("content_keywords"{tuple_delimiter}"first contact, control, communication, cosmic significance"){completion_delimiter} +#############################""", +] + +PROMPTS[ + "summarize_entity_descriptions" +] = """You are a helpful assistant responsible for generating a comprehensive summary of the data provided below. +Given one or two entities, and a list of descriptions, all related to the same entity or group of entities. +Please concatenate all of these into a single, comprehensive description. Make sure to include information collected from all the descriptions. +If the provided descriptions are contradictory, please resolve the contradictions and provide a single, coherent summary. +Make sure it is written in third person, and include the entity names so we the have full context. +Use {language} as output language. + +####### +-Data- +Entities: {entity_name} +Description List: {description_list} +####### +Output: +""" + +PROMPTS[ + "entiti_continue_extraction" +] = """MANY entities were missed in the last extraction. Add them below using the same format: +""" + +PROMPTS[ + "entiti_if_loop_extraction" +] = """It appears some entities may have still been missed. Answer YES | NO if there are still entities that need to be added. +""" + +PROMPTS["fail_response"] = "Sorry, I'm not able to provide an answer to that question." + +PROMPTS["rag_response"] = """---Role--- + +You are a helpful assistant responding to questions about data in the tables provided. + + +---Goal--- + +Generate a response of the target length and format that responds to the user's question, summarizing all information in the input data tables appropriate for the response length and format, and incorporating any relevant general knowledge. +If you don't know the answer, just say so. Do not make anything up. +Do not include information where the supporting evidence for it is not provided. + +---Target response length and format--- + +{response_type} + +---Data tables--- + +{context_data} + +Add sections and commentary to the response as appropriate for the length and format. Style the response in markdown. +""" + +PROMPTS["keywords_extraction"] = """---Role--- + +You are a helpful assistant tasked with identifying both high-level and low-level keywords in the user's query. + +---Goal--- + +Given the query, list both high-level and low-level keywords. High-level keywords focus on overarching concepts or themes, while low-level keywords focus on specific entities, details, or concrete terms. + +---Instructions--- + +- Output the keywords in JSON format. +- The JSON should have two keys: + - "high_level_keywords" for overarching concepts or themes. + - "low_level_keywords" for specific entities or details. + +###################### +-Examples- +###################### +{examples} + +############################# +-Real Data- +###################### +Query: {query} +###################### +The `Output` should be human text, not unicode characters. Keep the same language as `Query`. +Output: + +""" + +PROMPTS["keywords_extraction_examples"] = [ + """Example 1: + +Query: "How does international trade influence global economic stability?" +################ +Output: +{{ + "high_level_keywords": ["International trade", "Global economic stability", "Economic impact"], + "low_level_keywords": ["Trade agreements", "Tariffs", "Currency exchange", "Imports", "Exports"] +}} +#############################""", + """Example 2: + +Query: "What are the environmental consequences of deforestation on biodiversity?" +################ +Output: +{{ + "high_level_keywords": ["Environmental consequences", "Deforestation", "Biodiversity loss"], + "low_level_keywords": ["Species extinction", "Habitat destruction", "Carbon emissions", "Rainforest", "Ecosystem"] +}} +#############################""", + """Example 3: + +Query: "What is the role of education in reducing poverty?" +################ +Output: +{{ + "high_level_keywords": ["Education", "Poverty reduction", "Socioeconomic development"], + "low_level_keywords": ["School access", "Literacy rates", "Job training", "Income inequality"] +}} +#############################""", +] + + +PROMPTS["naive_rag_response"] = """---Role--- + +You are a helpful assistant responding to questions about documents provided. + + +---Goal--- + +Generate a response of the target length and format that responds to the user's question, summarizing all information in the input data tables appropriate for the response length and format, and incorporating any relevant general knowledge. +If you don't know the answer, just say so. Do not make anything up. +Do not include information where the supporting evidence for it is not provided. + +---Target response length and format--- + +{response_type} + +---Documents--- + +{content_data} + +Add sections and commentary to the response as appropriate for the length and format. Style the response in markdown. +""" + +PROMPTS[ + "similarity_check" +] = """Please analyze the similarity between these two questions: + +Question 1: {original_prompt} +Question 2: {cached_prompt} + +Please evaluate the following two points and provide a similarity score between 0 and 1 directly: +1. Whether these two questions are semantically similar +2. Whether the answer to Question 2 can be used to answer Question 1 +Similarity score criteria: +0: Completely unrelated or answer cannot be reused, including but not limited to: + - The questions have different topics + - The locations mentioned in the questions are different + - The times mentioned in the questions are different + - The specific individuals mentioned in the questions are different + - The specific events mentioned in the questions are different + - The background information in the questions is different + - The key conditions in the questions are different +1: Identical and answer can be directly reused +0.5: Partially related and answer needs modification to be used +Return only a number between 0-1, without any additional content. +""" diff --git a/Demo/backend/PathRAG/storage.py b/Demo/backend/PathRAG/storage.py new file mode 100644 index 0000000..1e02042 --- /dev/null +++ b/Demo/backend/PathRAG/storage.py @@ -0,0 +1,341 @@ +import asyncio +import html +import os +from tqdm.asyncio import tqdm as tqdm_async +from dataclasses import dataclass +from typing import Any, Union, cast +import networkx as nx +import numpy as np +from nano_vectordb import NanoVectorDB + +from .utils import ( + logger, + load_json, + write_json, + compute_mdhash_id, +) + +from .base import ( + BaseGraphStorage, + BaseKVStorage, + BaseVectorStorage, +) + + +@dataclass +class JsonKVStorage(BaseKVStorage): + def __post_init__(self): + working_dir = self.global_config["working_dir"] + self._file_name = os.path.join(working_dir, f"kv_store_{self.namespace}.json") + self._data = load_json(self._file_name) or {} + logger.info(f"Load KV {self.namespace} with {len(self._data)} data") + + async def all_keys(self) -> list[str]: + return list(self._data.keys()) + + async def index_done_callback(self): + write_json(self._data, self._file_name) + + async def get_by_id(self, id): + return self._data.get(id, None) + + async def get_by_ids(self, ids, fields=None): + if fields is None: + return [self._data.get(id, None) for id in ids] + return [ + ( + {k: v for k, v in self._data[id].items() if k in fields} + if self._data.get(id, None) + else None + ) + for id in ids + ] + + async def filter_keys(self, data: list[str]) -> set[str]: + return set([s for s in data if s not in self._data]) + + async def upsert(self, data: dict[str, dict]): + left_data = {k: v for k, v in data.items() if k not in self._data} + self._data.update(left_data) + return left_data + + async def drop(self): + self._data = {} + + +@dataclass +class NanoVectorDBStorage(BaseVectorStorage): + cosine_better_than_threshold: float = 0.2 + + def __post_init__(self): + self._client_file_name = os.path.join( + self.global_config["working_dir"], f"vdb_{self.namespace}.json" + ) + self._max_batch_size = self.global_config["embedding_batch_num"] + self._client = NanoVectorDB( + self.embedding_func.embedding_dim, storage_file=self._client_file_name + ) + self.cosine_better_than_threshold = self.global_config.get( + "cosine_better_than_threshold", self.cosine_better_than_threshold + ) + + async def upsert(self, data: dict[str, dict]): + logger.info(f"Inserting {len(data)} vectors to {self.namespace}") + if not len(data): + logger.warning("You insert an empty data to vector DB") + return [] + list_data = [ + { + "__id__": k, + **{k1: v1 for k1, v1 in v.items() if k1 in self.meta_fields}, + } + for k, v in data.items() + ] + contents = [v["content"] for v in data.values()] + batches = [ + contents[i : i + self._max_batch_size] + for i in range(0, len(contents), self._max_batch_size) + ] + + async def wrapped_task(batch): + result = await self.embedding_func(batch) + pbar.update(1) + return result + + embedding_tasks = [wrapped_task(batch) for batch in batches] + pbar = tqdm_async( + total=len(embedding_tasks), desc="Generating embeddings", unit="batch" + ) + embeddings_list = await asyncio.gather(*embedding_tasks) + + embeddings = np.concatenate(embeddings_list) + if len(embeddings) == len(list_data): + for i, d in enumerate(list_data): + d["__vector__"] = embeddings[i] + results = self._client.upsert(datas=list_data) + return results + else: + # sometimes the embedding is not returned correctly. just log it. + logger.error( + f"embedding is not 1-1 with data, {len(embeddings)} != {len(list_data)}" + ) + + async def query(self, query: str, top_k=5): + embedding = await self.embedding_func([query]) + embedding = embedding[0] + results = self._client.query( + query=embedding, + top_k=top_k, + better_than_threshold=self.cosine_better_than_threshold, + ) + results = [ + {**dp, "id": dp["__id__"], "distance": dp["__metrics__"]} for dp in results + ] + return results + + @property + def client_storage(self): + return getattr(self._client, "_NanoVectorDB__storage") + + async def delete_entity(self, entity_name: str): + try: + entity_id = [compute_mdhash_id(entity_name, prefix="ent-")] + + if self._client.get(entity_id): + self._client.delete(entity_id) + logger.info(f"Entity {entity_name} have been deleted.") + else: + logger.info(f"No entity found with name {entity_name}.") + except Exception as e: + logger.error(f"Error while deleting entity {entity_name}: {e}") + + async def delete_relation(self, entity_name: str): + try: + relations = [ + dp + for dp in self.client_storage["data"] + if dp["src_id"] == entity_name or dp["tgt_id"] == entity_name + ] + ids_to_delete = [relation["__id__"] for relation in relations] + + if ids_to_delete: + self._client.delete(ids_to_delete) + logger.info( + f"All relations related to entity {entity_name} have been deleted." + ) + else: + logger.info(f"No relations found for entity {entity_name}.") + except Exception as e: + logger.error( + f"Error while deleting relations for entity {entity_name}: {e}" + ) + + async def index_done_callback(self): + self._client.save() + + +@dataclass +class NetworkXStorage(BaseGraphStorage): + @staticmethod + def load_nx_graph(file_name) -> nx.DiGraph: + if os.path.exists(file_name): + return nx.read_graphml(file_name) + return None + # def load_nx_graph(file_name) -> nx.Graph: + # if os.path.exists(file_name): + # return nx.read_graphml(file_name) + # return None + + @staticmethod + def write_nx_graph(graph: nx.DiGraph, file_name): + logger.info( + f"Writing graph with {graph.number_of_nodes()} nodes, {graph.number_of_edges()} edges" + ) + nx.write_graphml(graph, file_name) + + @staticmethod + def stable_largest_connected_component(graph: nx.Graph) -> nx.Graph: + """Refer to https://github.com/microsoft/graphrag/index/graph/utils/stable_lcc.py + Return the largest connected component of the graph, with nodes and edges sorted in a stable way. + """ + from graspologic.utils import largest_connected_component + + graph = graph.copy() + graph = cast(nx.Graph, largest_connected_component(graph)) + node_mapping = { + node: html.unescape(node.upper().strip()) for node in graph.nodes() + } # type: ignore + graph = nx.relabel_nodes(graph, node_mapping) + return NetworkXStorage._stabilize_graph(graph) + + @staticmethod + def _stabilize_graph(graph: nx.Graph) -> nx.Graph: + """Refer to https://github.com/microsoft/graphrag/index/graph/utils/stable_lcc.py + Ensure an undirected graph with the same relationships will always be read the same way. + """ + fixed_graph = nx.DiGraph() if graph.is_directed() else nx.Graph() + + sorted_nodes = graph.nodes(data=True) + sorted_nodes = sorted(sorted_nodes, key=lambda x: x[0]) + + fixed_graph.add_nodes_from(sorted_nodes) + edges = list(graph.edges(data=True)) + + if not graph.is_directed(): + + def _sort_source_target(edge): + source, target, edge_data = edge + if source > target: + temp = source + source = target + target = temp + return source, target, edge_data + + edges = [_sort_source_target(edge) for edge in edges] + + def _get_edge_key(source: Any, target: Any) -> str: + return f"{source} -> {target}" + + edges = sorted(edges, key=lambda x: _get_edge_key(x[0], x[1])) + + fixed_graph.add_edges_from(edges) + return fixed_graph + + def __post_init__(self): + self._graphml_xml_file = os.path.join( + self.global_config["working_dir"], f"graph_{self.namespace}.graphml" + ) + preloaded_graph = NetworkXStorage.load_nx_graph(self._graphml_xml_file) + if preloaded_graph is not None: + logger.info( + f"Loaded graph from {self._graphml_xml_file} with {preloaded_graph.number_of_nodes()} nodes, {preloaded_graph.number_of_edges()} edges" + ) + self._graph = preloaded_graph or nx.DiGraph() + self._node_embed_algorithms = { + "node2vec": self._node2vec_embed, + } + + async def index_done_callback(self): + NetworkXStorage.write_nx_graph(self._graph, self._graphml_xml_file) + + async def has_node(self, node_id: str) -> bool: + return self._graph.has_node(node_id) + + async def has_edge(self, source_node_id: str, target_node_id: str) -> bool: + return self._graph.has_edge(source_node_id, target_node_id) + + async def get_node(self, node_id: str) -> Union[dict, None]: + return self._graph.nodes.get(node_id) + + async def node_degree(self, node_id: str) -> int: + return self._graph.degree(node_id) + + async def edge_degree(self, src_id: str, tgt_id: str) -> int: + return self._graph.degree(src_id) + self._graph.degree(tgt_id) + + async def get_edge( + self, source_node_id: str, target_node_id: str + ) -> Union[dict, None]: + return self._graph.edges.get((source_node_id, target_node_id)) + + async def get_node_edges(self, source_node_id: str): + if self._graph.has_node(source_node_id): + return list(self._graph.edges(source_node_id)) + return None + async def get_node_in_edges(self, source_node_id: str): + if self._graph.has_node(source_node_id): + return list(self._graph.in_edges(source_node_id)) + return None + async def get_node_out_edges(self, source_node_id: str): + if self._graph.has_node(source_node_id): + return list(self._graph.out_edges(source_node_id)) + return None + + async def get_pagerank(self,source_node_id:str): + pagerank_list=nx.pagerank(self._graph) + if source_node_id in pagerank_list: + return pagerank_list[source_node_id] + else: + print("pagerank failed") + + async def upsert_node(self, node_id: str, node_data: dict[str, str]): + self._graph.add_node(node_id, **node_data) + + async def upsert_edge( + self, source_node_id: str, target_node_id: str, edge_data: dict[str, str] + ): + self._graph.add_edge(source_node_id, target_node_id, **edge_data) + + async def delete_node(self, node_id: str): + """ + Delete a node from the graph based on the specified node_id. + + :param node_id: The node_id to delete + """ + if self._graph.has_node(node_id): + self._graph.remove_node(node_id) + logger.info(f"Node {node_id} deleted from the graph.") + else: + logger.warning(f"Node {node_id} not found in the graph for deletion.") + + async def embed_nodes(self, algorithm: str) -> tuple[np.ndarray, list[str]]: + if algorithm not in self._node_embed_algorithms: + raise ValueError(f"Node embedding algorithm {algorithm} not supported") + return await self._node_embed_algorithms[algorithm]() + + # @TODO: NOT USED + async def _node2vec_embed(self): + from graspologic import embed + + embeddings, nodes = embed.node2vec_embed( + self._graph, + **self.global_config["node2vec_params"], + ) + + nodes_ids = [self._graph.nodes[node_id]["id"] for node_id in nodes] + return embeddings, nodes_ids + + async def edges(self): + return self._graph.edges() + async def nodes(self): + return self._graph.nodes() diff --git a/Demo/backend/PathRAG/utils.py b/Demo/backend/PathRAG/utils.py new file mode 100644 index 0000000..622cd32 --- /dev/null +++ b/Demo/backend/PathRAG/utils.py @@ -0,0 +1,527 @@ +import asyncio +import html +import io +import csv +import json +import logging +import os +import re +from dataclasses import dataclass +from functools import wraps +from hashlib import md5 +from typing import Any, Union, List, Optional +import xml.etree.ElementTree as ET + +import numpy as np +import tiktoken + +from PathRAG.prompt import PROMPTS + + +class UnlimitedSemaphore: + + + async def __aenter__(self): + pass + + async def __aexit__(self, exc_type, exc, tb): + pass + + +ENCODER = None + +logger = logging.getLogger("PathRAG") + + +def set_logger(log_file: str): + logger.setLevel(logging.DEBUG) + + file_handler = logging.FileHandler(log_file) + file_handler.setLevel(logging.DEBUG) + + formatter = logging.Formatter( + "%(asctime)s - %(name)s - %(levelname)s - %(message)s" + ) + file_handler.setFormatter(formatter) + + if not logger.handlers: + logger.addHandler(file_handler) + + +@dataclass +class EmbeddingFunc: + embedding_dim: int + max_token_size: int + func: callable + concurrent_limit: int = 16 + + def __post_init__(self): + if self.concurrent_limit != 0: + self._semaphore = asyncio.Semaphore(self.concurrent_limit) + else: + self._semaphore = UnlimitedSemaphore() + + async def __call__(self, *args, **kwargs) -> np.ndarray: + async with self._semaphore: + return await self.func(*args, **kwargs) + + +def locate_json_string_body_from_string(content: str) -> Union[str, None]: + + try: + maybe_json_str = re.search(r"{.*}", content, re.DOTALL) + if maybe_json_str is not None: + maybe_json_str = maybe_json_str.group(0) + maybe_json_str = maybe_json_str.replace("\\n", "") + maybe_json_str = maybe_json_str.replace("\n", "") + maybe_json_str = maybe_json_str.replace("'", '"') + + return maybe_json_str + except Exception: + pass + + + return None + + +def convert_response_to_json(response: str) -> dict: + json_str = locate_json_string_body_from_string(response) + assert json_str is not None, f"Unable to parse JSON from response: {response}" + try: + data = json.loads(json_str) + return data + except json.JSONDecodeError as e: + logger.error(f"Failed to parse JSON: {json_str}") + raise e from None + + +def compute_args_hash(*args): + return md5(str(args).encode()).hexdigest() + + +def compute_mdhash_id(content, prefix: str = ""): + return prefix + md5(content.encode()).hexdigest() + + +def limit_async_func_call(max_size: int, waitting_time: float = 0.0001): + + + def final_decro(func): + + __current_size = 0 + + @wraps(func) + async def wait_func(*args, **kwargs): + nonlocal __current_size + while __current_size >= max_size: + await asyncio.sleep(waitting_time) + __current_size += 1 + result = await func(*args, **kwargs) + __current_size -= 1 + return result + + return wait_func + + return final_decro + + +def wrap_embedding_func_with_attrs(**kwargs): + + + def final_decro(func) -> EmbeddingFunc: + new_func = EmbeddingFunc(**kwargs, func=func) + return new_func + + return final_decro + + +def load_json(file_name): + if not os.path.exists(file_name): + return None + with open(file_name, encoding="utf-8") as f: + return json.load(f) + + +def write_json(json_obj, file_name): + with open(file_name, "w", encoding="utf-8") as f: + json.dump(json_obj, f, indent=2, ensure_ascii=False) + + +def encode_string_by_tiktoken(content: str, model_name: str = "gpt-4o-mini"): + global ENCODER + if ENCODER is None: + ENCODER = tiktoken.encoding_for_model(model_name) + tokens = ENCODER.encode(content) + return tokens + + +def decode_tokens_by_tiktoken(tokens: list[int], model_name: str = "gpt-4o-mini"): + global ENCODER + if ENCODER is None: + ENCODER = tiktoken.encoding_for_model(model_name) + content = ENCODER.decode(tokens) + return content + + +def pack_user_ass_to_openai_messages(*args: str): + roles = ["user", "assistant"] + return [ + {"role": roles[i % 2], "content": content} for i, content in enumerate(args) + ] + + +def split_string_by_multi_markers(content: str, markers: list[str]) -> list[str]: + + if not markers: + return [content] + results = re.split("|".join(re.escape(marker) for marker in markers), content) + return [r.strip() for r in results if r.strip()] + + + +def clean_str(input: Any) -> str: + + + if not isinstance(input, str): + return input + + result = html.unescape(input.strip()) + + return re.sub(r"[\x00-\x1f\x7f-\x9f]", "", result) + + +def is_float_regex(value): + return bool(re.match(r"^[-+]?[0-9]*\.?[0-9]+$", value)) + + +def truncate_list_by_token_size(list_data: list, key: callable, max_token_size: int): + + if max_token_size <= 0: + return [] + tokens = 0 + for i, data in enumerate(list_data): + tokens += len(encode_string_by_tiktoken(key(data))) + if tokens > max_token_size: + return list_data[:i] + return list_data + + +def list_of_list_to_csv(data: List[List[str]]) -> str: + output = io.StringIO() + writer = csv.writer(output) + writer.writerows(data) + return output.getvalue() + + +def csv_string_to_list(csv_string: str) -> List[List[str]]: + output = io.StringIO(csv_string) + reader = csv.reader(output) + return [row for row in reader] + + +def save_data_to_file(data, file_name): + with open(file_name, "w", encoding="utf-8") as f: + json.dump(data, f, ensure_ascii=False, indent=4) + + +def xml_to_json(xml_file): + try: + tree = ET.parse(xml_file) + root = tree.getroot() + + print(f"Root element: {root.tag}") + print(f"Root attributes: {root.attrib}") + + data = {"nodes": [], "edges": []} + namespace = {"": "http://graphml.graphdrawing.org/xmlns"} + + for node in root.findall(".//node", namespace): + node_data = { + "id": node.get("id").strip('"'), + "entity_type": node.find("./data[@key='d0']", namespace).text.strip('"') + if node.find("./data[@key='d0']", namespace) is not None + else "", + "description": node.find("./data[@key='d1']", namespace).text + if node.find("./data[@key='d1']", namespace) is not None + else "", + "source_id": node.find("./data[@key='d2']", namespace).text + if node.find("./data[@key='d2']", namespace) is not None + else "", + } + data["nodes"].append(node_data) + + for edge in root.findall(".//edge", namespace): + edge_data = { + "source": edge.get("source").strip('"'), + "target": edge.get("target").strip('"'), + "weight": float(edge.find("./data[@key='d3']", namespace).text) + if edge.find("./data[@key='d3']", namespace) is not None + else 0.0, + "description": edge.find("./data[@key='d4']", namespace).text + if edge.find("./data[@key='d4']", namespace) is not None + else "", + "keywords": edge.find("./data[@key='d5']", namespace).text + if edge.find("./data[@key='d5']", namespace) is not None + else "", + "source_id": edge.find("./data[@key='d6']", namespace).text + if edge.find("./data[@key='d6']", namespace) is not None + else "", + } + data["edges"].append(edge_data) + + print(f"Found {len(data['nodes'])} nodes and {len(data['edges'])} edges") + + return data + except ET.ParseError as e: + print(f"Error parsing XML file: {e}") + return None + except Exception as e: + print(f"An error occurred: {e}") + return None + + +def process_combine_contexts(hl, ll): + header = None + list_hl = csv_string_to_list(hl.strip()) + list_ll = csv_string_to_list(ll.strip()) + + if list_hl: + header = list_hl[0] + list_hl = list_hl[1:] + if list_ll: + header = list_ll[0] + list_ll = list_ll[1:] + if header is None: + return "" + + if list_hl: + list_hl = [",".join(item[1:]) for item in list_hl if item] + if list_ll: + list_ll = [",".join(item[1:]) for item in list_ll if item] + + combined_sources = [] + seen = set() + + for item in list_hl + list_ll: + if item and item not in seen: + combined_sources.append(item) + seen.add(item) + + combined_sources_result = [",\t".join(header)] + + for i, item in enumerate(combined_sources, start=1): + combined_sources_result.append(f"{i},\t{item}") + + combined_sources_result = "\n".join(combined_sources_result) + + return combined_sources_result + + +async def get_best_cached_response( + hashing_kv, + current_embedding, + similarity_threshold=0.95, + mode="default", + use_llm_check=False, + llm_func=None, + original_prompt=None, +) -> Union[str, None]: + + mode_cache = await hashing_kv.get_by_id(mode) + if not mode_cache: + return None + + best_similarity = -1 + best_response = None + best_prompt = None + best_cache_id = None + + + for cache_id, cache_data in mode_cache.items(): + if cache_data["embedding"] is None: + continue + + + cached_quantized = np.frombuffer( + bytes.fromhex(cache_data["embedding"]), dtype=np.uint8 + ).reshape(cache_data["embedding_shape"]) + cached_embedding = dequantize_embedding( + cached_quantized, + cache_data["embedding_min"], + cache_data["embedding_max"], + ) + + similarity = cosine_similarity(current_embedding, cached_embedding) + if similarity > best_similarity: + best_similarity = similarity + best_response = cache_data["return"] + best_prompt = cache_data["original_prompt"] + best_cache_id = cache_id + + if best_similarity > similarity_threshold: + + if use_llm_check and llm_func and original_prompt and best_prompt: + compare_prompt = PROMPTS["similarity_check"].format( + original_prompt=original_prompt, cached_prompt=best_prompt + ) + + try: + llm_result = await llm_func(compare_prompt) + llm_result = llm_result.strip() + llm_similarity = float(llm_result) + + + best_similarity = llm_similarity + if best_similarity < similarity_threshold: + log_data = { + "event": "llm_check_cache_rejected", + "original_question": original_prompt[:100] + "..." + if len(original_prompt) > 100 + else original_prompt, + "cached_question": best_prompt[:100] + "..." + if len(best_prompt) > 100 + else best_prompt, + "similarity_score": round(best_similarity, 4), + "threshold": similarity_threshold, + } + logger.info(json.dumps(log_data, ensure_ascii=False)) + return None + except Exception as e: + logger.warning(f"LLM similarity check failed: {e}") + return None + + prompt_display = ( + best_prompt[:50] + "..." if len(best_prompt) > 50 else best_prompt + ) + log_data = { + "event": "cache_hit", + "mode": mode, + "similarity": round(best_similarity, 4), + "cache_id": best_cache_id, + "original_prompt": prompt_display, + } + logger.info(json.dumps(log_data, ensure_ascii=False)) + return best_response + return None + + +def cosine_similarity(v1, v2): + + dot_product = np.dot(v1, v2) + norm1 = np.linalg.norm(v1) + norm2 = np.linalg.norm(v2) + return dot_product / (norm1 * norm2) + + +def quantize_embedding(embedding: np.ndarray, bits=8) -> tuple: + + + min_val = embedding.min() + max_val = embedding.max() + + + scale = (2**bits - 1) / (max_val - min_val) + quantized = np.round((embedding - min_val) * scale).astype(np.uint8) + + return quantized, min_val, max_val + + +def dequantize_embedding( + quantized: np.ndarray, min_val: float, max_val: float, bits=8 +) -> np.ndarray: + + scale = (max_val - min_val) / (2**bits - 1) + return (quantized * scale + min_val).astype(np.float32) + + +async def handle_cache(hashing_kv, args_hash, prompt, mode="default"): + + if hashing_kv is None: + return None, None, None, None + + + if mode == "naive": + mode_cache = await hashing_kv.get_by_id(mode) or {} + if args_hash in mode_cache: + return mode_cache[args_hash]["return"], None, None, None + return None, None, None, None + + + embedding_cache_config = hashing_kv.global_config.get( + "embedding_cache_config", + {"enabled": False, "similarity_threshold": 0.95, "use_llm_check": False}, + ) + is_embedding_cache_enabled = embedding_cache_config["enabled"] + use_llm_check = embedding_cache_config.get("use_llm_check", False) + + quantized = min_val = max_val = None + if is_embedding_cache_enabled: + + embedding_model_func = hashing_kv.global_config["embedding_func"]["func"] + llm_model_func = hashing_kv.global_config.get("llm_model_func") + + current_embedding = await embedding_model_func([prompt]) + quantized, min_val, max_val = quantize_embedding(current_embedding[0]) + best_cached_response = await get_best_cached_response( + hashing_kv, + current_embedding[0], + similarity_threshold=embedding_cache_config["similarity_threshold"], + mode=mode, + use_llm_check=use_llm_check, + llm_func=llm_model_func if use_llm_check else None, + original_prompt=prompt if use_llm_check else None, + ) + if best_cached_response is not None: + return best_cached_response, None, None, None + else: + + mode_cache = await hashing_kv.get_by_id(mode) or {} + if args_hash in mode_cache: + return mode_cache[args_hash]["return"], None, None, None + + return None, quantized, min_val, max_val + + +@dataclass +class CacheData: + args_hash: str + content: str + prompt: str + quantized: Optional[np.ndarray] = None + min_val: Optional[float] = None + max_val: Optional[float] = None + mode: str = "default" + + +async def save_to_cache(hashing_kv, cache_data: CacheData): + if hashing_kv is None or hasattr(cache_data.content, "__aiter__"): + return + + mode_cache = await hashing_kv.get_by_id(cache_data.mode) or {} + + mode_cache[cache_data.args_hash] = { + "return": cache_data.content, + "embedding": cache_data.quantized.tobytes().hex() + if cache_data.quantized is not None + else None, + "embedding_shape": cache_data.quantized.shape + if cache_data.quantized is not None + else None, + "embedding_min": cache_data.min_val, + "embedding_max": cache_data.max_val, + "original_prompt": cache_data.prompt, + } + + await hashing_kv.upsert({cache_data.mode: mode_cache}) + + +def safe_unicode_decode(content): + unicode_escape_pattern = re.compile(r"\\u([0-9a-fA-F]{4})") + def replace_unicode_escape(match): + return chr(int(match.group(1), 16)) + + decoded_content = unicode_escape_pattern.sub( + replace_unicode_escape, content.decode("utf-8") + ) + + return decoded_content diff --git a/Demo/backend/api/auth/jwt_handler.py b/Demo/backend/api/auth/jwt_handler.py new file mode 100644 index 0000000..86e10fa --- /dev/null +++ b/Demo/backend/api/auth/jwt_handler.py @@ -0,0 +1,75 @@ +from datetime import datetime, timedelta +from typing import Optional +import jwt +from fastapi import Depends, HTTPException, status +from fastapi.security import OAuth2PasswordBearer +from passlib.context import CryptContext +from sqlalchemy.orm import Session + +from models.database import User, get_db + +# JWT settings +SECRET_KEY = "YOUR_SECRET_KEY_HERE" # In production, use a secure key and store in environment variables +ALGORITHM = "HS256" +ACCESS_TOKEN_EXPIRE_MINUTES = 30 + +# Password hashing +pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto") + +# OAuth2 scheme +oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token") + +# Verify password +def verify_password(plain_password, hashed_password): + return pwd_context.verify(plain_password, hashed_password) + +# Hash password +def get_password_hash(password): + return pwd_context.hash(password) + +# Get user by username +def get_user(db: Session, username: str): + return db.query(User).filter(User.username == username).first() + +# Authenticate user +def authenticate_user(db: Session, username: str, password: str): + user = get_user(db, username) + if not user: + return False + if not verify_password(password, user.hashed_password): + return False + return user + +# Create access token +def create_access_token(data: dict, expires_delta: Optional[timedelta] = None): + to_encode = data.copy() + if expires_delta: + expire = datetime.utcnow() + expires_delta + else: + expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES) + to_encode.update({"exp": expire}) + encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM) + return encoded_jwt + +# Get current user +async def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)): + credentials_exception = HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Could not validate credentials", + headers={"WWW-Authenticate": "Bearer"}, + ) + try: + payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM]) + username: str = payload.get("sub") + if username is None: + raise credentials_exception + except jwt.PyJWTError: + raise credentials_exception + user = get_user(db, username=username) + if user is None: + raise credentials_exception + return user + +# Get current active user +async def get_current_active_user(current_user: User = Depends(get_current_user)): + return current_user diff --git a/Demo/backend/api/auth/routes.py b/Demo/backend/api/auth/routes.py new file mode 100644 index 0000000..7939d60 --- /dev/null +++ b/Demo/backend/api/auth/routes.py @@ -0,0 +1,55 @@ +from fastapi import APIRouter, Depends, HTTPException, status +from fastapi.security import OAuth2PasswordRequestForm +from sqlalchemy.orm import Session +from datetime import timedelta + +from models.database import get_db, User +from .jwt_handler import ( + authenticate_user, + create_access_token, + get_password_hash, + ACCESS_TOKEN_EXPIRE_MINUTES, + get_current_active_user +) +from .schemas import Token, UserCreate, User as UserSchema + +router = APIRouter(tags=["Authentication"]) + +@router.post("/token", response_model=Token) +async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_db)): + user = authenticate_user(db, form_data.username, form_data.password) + if not user: + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Incorrect username or password", + headers={"WWW-Authenticate": "Bearer"}, + ) + access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES) + access_token = create_access_token( + data={"sub": user.username}, expires_delta=access_token_expires + ) + return {"access_token": access_token, "token_type": "bearer"} + +@router.post("/register", response_model=UserSchema) +async def register_user(user: UserCreate, db: Session = Depends(get_db)): + # Check if username already exists + db_user = db.query(User).filter(User.username == user.username).first() + if db_user: + raise HTTPException(status_code=400, detail="Username already registered") + + # Check if email already exists + db_user = db.query(User).filter(User.email == user.email).first() + if db_user: + raise HTTPException(status_code=400, detail="Email already registered") + + # Create new user + hashed_password = get_password_hash(user.password) + db_user = User(username=user.username, email=user.email, hashed_password=hashed_password) + db.add(db_user) + db.commit() + db.refresh(db_user) + return db_user + +@router.get("/users/me", response_model=UserSchema) +async def read_users_me(current_user: User = Depends(get_current_active_user)): + return current_user diff --git a/Demo/backend/api/auth/schemas.py b/Demo/backend/api/auth/schemas.py new file mode 100644 index 0000000..3c497ee --- /dev/null +++ b/Demo/backend/api/auth/schemas.py @@ -0,0 +1,42 @@ +from pydantic import BaseModel, EmailStr +from typing import Optional, List +from datetime import datetime + +# Token schema +class Token(BaseModel): + access_token: str + token_type: str + +# Token data schema +class TokenData(BaseModel): + username: Optional[str] = None + +# User base schema +class UserBase(BaseModel): + username: str + email: EmailStr + +# User creation schema +class UserCreate(UserBase): + password: str + +# User schema +class User(UserBase): + id: int + created_at: datetime + theme: Optional[str] = None + + class Config: + orm_mode = True + +# User in DB schema +class UserInDB(User): + hashed_password: str + + class Config: + orm_mode = True + +# Login schema +class Login(BaseModel): + username: str + password: str diff --git a/Demo/backend/api/features/chats/routes.py b/Demo/backend/api/features/chats/routes.py new file mode 100644 index 0000000..9156439 --- /dev/null +++ b/Demo/backend/api/features/chats/routes.py @@ -0,0 +1,197 @@ +from fastapi import APIRouter, Depends, HTTPException +from sqlalchemy.orm import Session +import uuid as uuid_pkg +import datetime +from typing import List, Optional + +from models.database import get_db, Chat, User, Thread +from api.auth.jwt_handler import get_current_active_user +from .schemas import ChatCreate, ChatResponse, ChatList, ThreadCreate, ThreadResponse, ThreadList, ThreadWithChats +from PathRAG import QueryParam +from api.features.rag_manager import get_rag_instance + +# Get the PathRAG instance from the manager +rag = get_rag_instance() + +router = APIRouter( + prefix="/chats", + tags=["Chats"], + dependencies=[Depends(get_current_active_user)] +) + +# Thread endpoints +@router.get("/threads", response_model=ThreadList) +async def get_threads(db: Session = Depends(get_db), current_user: User = Depends(get_current_active_user)): + """Get all chat threads for the current user""" + threads = db.query(Thread).filter( + Thread.user_id == current_user.id, + Thread.is_deleted == False + ).order_by(Thread.updated_at.desc()).all() + return {"threads": threads} + +@router.post("/threads", response_model=ThreadResponse) +async def create_thread( + thread: ThreadCreate = None, + db: Session = Depends(get_db), + current_user: User = Depends(get_current_active_user) +): + """Create a new chat thread""" + # Generate a unique UUID for the thread + thread_uuid = str(uuid_pkg.uuid4()) + + # Create thread record + db_thread = Thread( + uuid=thread_uuid, + user_id=current_user.id, + title=thread.title if thread and thread.title else "New Chat" + ) + db.add(db_thread) + db.commit() + db.refresh(db_thread) + return db_thread + +@router.get("/threads/{thread_uuid}", response_model=ThreadWithChats) +async def get_thread( + thread_uuid: str, + db: Session = Depends(get_db), + current_user: User = Depends(get_current_active_user) +): + """Get a specific thread with all its chats""" + thread = db.query(Thread).filter( + Thread.uuid == thread_uuid, + Thread.user_id == current_user.id, + Thread.is_deleted == False + ).first() + + if thread is None: + raise HTTPException(status_code=404, detail="Thread not found") + + # Get all chats for this thread + chats = db.query(Chat).filter( + Chat.thread_id == thread.id + ).order_by(Chat.created_at.asc()).all() + + # Create response with thread and chats + result = ThreadWithChats.model_validate(thread) + result.chats = chats + + return result + +@router.delete("/threads/{thread_uuid}", response_model=dict) +async def delete_thread( + thread_uuid: str, + db: Session = Depends(get_db), + current_user: User = Depends(get_current_active_user) +): + """Mark a thread as deleted""" + thread = db.query(Thread).filter( + Thread.uuid == thread_uuid, + Thread.user_id == current_user.id + ).first() + + if thread is None: + raise HTTPException(status_code=404, detail="Thread not found") + + # Mark as deleted instead of actually deleting + thread.is_deleted = True + db.commit() + + return {"success": True, "message": "Thread deleted successfully"} + +@router.put("/threads/{thread_uuid}", response_model=ThreadResponse) +async def update_thread( + thread_uuid: str, + thread_data: ThreadCreate, + db: Session = Depends(get_db), + current_user: User = Depends(get_current_active_user) +): + """Update a thread's title""" + thread = db.query(Thread).filter( + Thread.uuid == thread_uuid, + Thread.user_id == current_user.id, + Thread.is_deleted == False + ).first() + + if thread is None: + raise HTTPException(status_code=404, detail="Thread not found") + + # Update title + if thread_data.title is not None: + thread.title = thread_data.title + + db.commit() + db.refresh(thread) + + return thread + +# Chat endpoints +@router.get("/", response_model=ChatList) +async def get_chats(db: Session = Depends(get_db), current_user: User = Depends(get_current_active_user)): + """Get all chats for the current user""" + chats = db.query(Chat).filter(Chat.user_id == current_user.id).all() + return {"chats": chats} + +@router.get("/recent", response_model=ThreadList) +async def get_recent_threads(db: Session = Depends(get_db), current_user: User = Depends(get_current_active_user)): + """Get the 5 most recent chat threads for the current user""" + recent_threads = db.query(Thread).filter( + Thread.user_id == current_user.id, + Thread.is_deleted == False + ).order_by(Thread.updated_at.desc()).limit(5).all() + + return {"threads": recent_threads} + +@router.post("/chat/{thread_uuid}", response_model=ChatResponse) +async def create_chat( + thread_uuid: str, + chat: ChatCreate, + db: Session = Depends(get_db), + current_user: User = Depends(get_current_active_user) +): + """Create a new chat message and get a response""" + # Find or create thread + thread_id = None + if thread_uuid: + # Use existing thread ID + thread = db.query(Thread).filter( + Thread.uuid == thread_uuid, + Thread.user_id == current_user.id, + Thread.is_deleted == False + ).first() + + if thread is None: + raise HTTPException(status_code=404, detail="Thread not found") + + thread_id = thread.id + + # Query PathRAG + response_text = await rag.aquery(chat.message, param=QueryParam(mode=chat.search_context)) + + # Create user message record + user_chat = Chat( + user_id=current_user.id, + thread_id=thread_id, + role="user", + message=chat.message + ) + db.add(user_chat) + + # Create system response record + system_chat = Chat( + user_id=current_user.id, + thread_id=thread_id, + role="system", + message=response_text + ) + db.add(system_chat) + + # Update thread title and timestamp + thread.title = chat.message[:50] if len(chat.message) > 50 else chat.message + thread.updated_at = datetime.datetime.now(datetime.timezone.utc) + + db.commit() + db.refresh(user_chat) + + # Return the user message + return user_chat + diff --git a/Demo/backend/api/features/chats/schemas.py b/Demo/backend/api/features/chats/schemas.py new file mode 100644 index 0000000..245bf8f --- /dev/null +++ b/Demo/backend/api/features/chats/schemas.py @@ -0,0 +1,63 @@ +from pydantic import BaseModel +from typing import List, Optional +from datetime import datetime + +# Thread schemas +class ThreadBase(BaseModel): + title: Optional[str] = None + +class ThreadCreate(ThreadBase): + pass + +class ThreadResponse(ThreadBase): + id: int + uuid: str + user_id: int + title: Optional[str] = None + created_at: datetime + updated_at: datetime + + model_config = { + "from_attributes": True + } + +class ThreadList(BaseModel): + threads: List[ThreadResponse] + + model_config = { + "from_attributes": True + } + +# Chat schemas +class ChatBase(BaseModel): + message: str + role: str = "user" + +class ChatCreate(ChatBase): + thread_id: Optional[int] = None + search_context: Optional[str] = None + thread_uuid: Optional[str] = None + +class ChatResponse(ChatBase): + id: int + user_id: int + thread_id: int + created_at: datetime + + model_config = { + "from_attributes": True + } + +class ChatList(BaseModel): + chats: List[ChatResponse] + + model_config = { + "from_attributes": True + } + +class ThreadWithChats(ThreadResponse): + chats: List[ChatResponse] = [] + + model_config = { + "from_attributes": True + } diff --git a/Demo/backend/api/features/documents/routes.py b/Demo/backend/api/features/documents/routes.py new file mode 100644 index 0000000..acf90d6 --- /dev/null +++ b/Demo/backend/api/features/documents/routes.py @@ -0,0 +1,326 @@ +import logging +from fastapi import APIRouter, Depends, HTTPException, UploadFile, File +from sqlalchemy.orm import Session +import os +import shutil +import asyncio +import tempfile +from datetime import datetime + +from models.database import get_db, Document, User +from api.auth.jwt_handler import get_current_active_user +from .schemas import DocumentResponse, DocumentList +from api.features.rag_manager import get_rag_instance, reload_rag_instance +# Additional libraries for file processing +import PyPDF2 +import docx2txt +from pptx import Presentation +import openpyxl +from striprtf.striprtf import rtf_to_text +from odf.opendocument import load as load_odf +from odf import teletype +from ebooklib import epub +from bs4 import BeautifulSoup +logger = logging.getLogger("PathRAG") +# Create uploads directory if it doesn't exist +UPLOAD_DIR = "./uploads" +os.makedirs(UPLOAD_DIR, exist_ok=True) + +router = APIRouter( + prefix="/documents", + tags=["Documents"], + dependencies=[Depends(get_current_active_user)] +) + +# No WebSocket or upload status tracking needed + +# Setup a working directory for PathRAG. +WORKING_DIR = os.path.join(os.getcwd(), 'data') +if not os.path.exists(WORKING_DIR): + os.mkdir(WORKING_DIR) + +# Get the RAG instance from the manager +rag = get_rag_instance() + +def extract_text_from_file(file: UploadFile) -> str: + """ + Extract text from an uploaded file. + Supports many file types including: + .txt, .md, .pdf, .docx, .pptx, .xlsx, .rtf, .odt, .tex, .epub, + .html, .htm, .csv, .json, .xml, .yaml, .yml, .log, .conf, .ini, + .properties, .sql, .bat, .sh, .c, .cpp, .py, .java, .js, .ts, + .swift, .go, .rb, .php, .css, .scss, .less. + """ + filename = file.filename + extension = os.path.splitext(filename)[1].lower() + file.file.seek(0) + + # Define plain text file extensions. + plain_text_ext = [ + ".txt", ".md", ".tex", ".csv", ".json", ".xml", ".yaml", ".yml", + ".log", ".conf", ".ini", ".properties", ".sql", ".bat", ".sh", + ".c", ".cpp", ".py", ".java", ".js", ".ts", ".swift", ".go", + ".rb", ".php", ".css", ".scss", ".less" + ] + + if extension in plain_text_ext: + try: + return file.file.read().decode('utf-8', errors='ignore') + except Exception as e: + raise HTTPException(status_code=400, detail=f"Error reading {extension} file: {str(e)}") + elif extension == ".pdf": + try: + file.file.seek(0) + pdf_reader = PyPDF2.PdfReader(file.file) + text = "" + for page in pdf_reader.pages: + text += page.extract_text() or "" + return text + except Exception as e: + raise HTTPException(status_code=400, detail=f"Error processing PDF file: {str(e)}") + elif extension == ".docx": + try: + file.file.seek(0) + with tempfile.NamedTemporaryFile(delete=False, suffix=".docx") as tmp: + tmp.write(file.file.read()) + tmp_path = tmp.name + text = docx2txt.process(tmp_path) + os.remove(tmp_path) + return text + except Exception as e: + raise HTTPException(status_code=400, detail=f"Error processing DOCX file: {str(e)}") + elif extension == ".pptx": + try: + file.file.seek(0) + with tempfile.NamedTemporaryFile(delete=False, suffix=".pptx") as tmp: + tmp.write(file.file.read()) + tmp_path = tmp.name + prs = Presentation(tmp_path) + text = "" + for slide in prs.slides: + for shape in slide.shapes: + if hasattr(shape, "text"): + text += shape.text + "\n" + os.remove(tmp_path) + return text + except Exception as e: + raise HTTPException(status_code=400, detail=f"Error processing PPTX file: {str(e)}") + elif extension == ".xlsx": + try: + file.file.seek(0) + with tempfile.NamedTemporaryFile(delete=False, suffix=".xlsx") as tmp: + tmp.write(file.file.read()) + tmp_path = tmp.name + wb = openpyxl.load_workbook(tmp_path, data_only=True) + text = "" + for sheet in wb.worksheets: + for row in sheet.iter_rows(values_only=True): + row_text = " ".join([str(cell) for cell in row if cell is not None]) + text += row_text + "\n" + os.remove(tmp_path) + return text + except Exception as e: + raise HTTPException(status_code=400, detail=f"Error processing XLSX file: {str(e)}") + elif extension == ".rtf": + try: + file.file.seek(0) + content = file.file.read().decode('utf-8', errors='ignore') + return rtf_to_text(content) + except Exception as e: + raise HTTPException(status_code=400, detail=f"Error processing RTF file: {str(e)}") + elif extension == ".odt": + try: + file.file.seek(0) + with tempfile.NamedTemporaryFile(delete=False, suffix=".odt") as tmp: + tmp.write(file.file.read()) + tmp_path = tmp.name + doc = load_odf(tmp_path) + text_content = teletype.extractText(doc) + os.remove(tmp_path) + return text_content + except Exception as e: + raise HTTPException(status_code=400, detail=f"Error processing ODT file: {str(e)}") + elif extension == ".epub": + try: + file.file.seek(0) + with tempfile.NamedTemporaryFile(delete=False, suffix=".epub") as tmp: + tmp.write(file.file.read()) + tmp_path = tmp.name + book = epub.read_epub(tmp_path) + text = "" + for item in book.get_items(): + if item.get_type() == epub.ITEM_DOCUMENT: + soup = BeautifulSoup(item.get_content(), "html.parser") + text += soup.get_text() + "\n" + os.remove(tmp_path) + return text + except Exception as e: + raise HTTPException(status_code=400, detail=f"Error processing EPUB file: {str(e)}") + elif extension in [".html", ".htm"]: + try: + file.file.seek(0) + content = file.file.read().decode('utf-8', errors='ignore') + soup = BeautifulSoup(content, "html.parser") + return soup.get_text() + except Exception as e: + raise HTTPException(status_code=400, detail=f"Error processing HTML file: {str(e)}") + else: + raise HTTPException(status_code=400, detail="Unsupported file type.") + +@router.post("/upload", response_model=DocumentResponse, summary="Upload a file", description="Upload a file to insert its content into the RAG system.") +async def upload_file( + file: UploadFile = File(...), + db: Session = Depends(get_db), + current_user: User = Depends(get_current_active_user) +): + try: + # Validate file type + filename = file.filename + file_extension = os.path.splitext(filename)[1].lower() + + # Map file extensions to content types + content_type_map = { + '.pdf': 'application/pdf', + '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', + '.md': 'text/markdown', + '.txt': 'text/plain', + '.html': 'text/html', + '.htm': 'text/html', + '.rtf': 'application/rtf', + '.odt': 'application/vnd.oasis.opendocument.text', + '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation', + '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', + '.epub': 'application/epub+zip' + } + + content_type = content_type_map.get(file_extension, file.content_type) + + # Create file path + timestamp = datetime.now().strftime("%Y%m%d%H%M%S") + file_path = os.path.join(UPLOAD_DIR, f"{current_user.id}_{timestamp}_{filename}") + + # Save file + with open(file_path, "wb") as buffer: + shutil.copyfileobj(file.file, buffer) + + # Get file size + file_size = os.path.getsize(file_path) + + # Create document record + db_document = Document( + user_id=current_user.id, + filename=filename, + content_type=content_type, + file_path=file_path, + file_size=file_size, + status="processing" + ) + db.add(db_document) + db.commit() + db.refresh(db_document) + + # Extract text and process with PathRAG in background + async def process_document_task(): + # Declare global rag at the beginning of the function + global rag + + try: + # Extract text from file + with open(file_path, "rb") as f: + # Create a temporary UploadFile-like object + class TempUploadFile: + def __init__(self, file_path): + self.filename = os.path.basename(file_path) + self.file = open(file_path, "rb") + + temp_file = TempUploadFile(file_path) + content = extract_text_from_file(temp_file) + temp_file.file.close() + + # Process with PathRAG + await rag.ainsert(content) + + # Reload the PathRAG instance to make the new document available + reload_rag_instance() + + # Update the local reference + rag = get_rag_instance() + + # Update document status + document = db.query(Document).filter(Document.id == db_document.id).first() + if document: + document.status = "completed" + document.processed_at = datetime.now() + db.commit() + + logger.info(f"Document processed and PathRAG reloaded successfully.") + except Exception as e: + # Update document status on error + document = db.query(Document).filter(Document.id == db_document.id).first() + if document: + document.status = "failed" + document.error_message = str(e) + db.commit() + + # Start processing task + task = asyncio.create_task(process_document_task()) + + # Add task to a global set to prevent garbage collection + if not hasattr(upload_file, 'tasks'): + upload_file.tasks = set() + upload_file.tasks.add(task) + task.add_done_callback(lambda t: upload_file.tasks.remove(t)) + logger.info(f"Document upload completed.") + return db_document + except Exception as e: + raise HTTPException(status_code=500, detail=str(e)) + +@router.get("/", response_model=DocumentList) +async def get_documents(db: Session = Depends(get_db), current_user: User = Depends(get_current_active_user)): + documents = db.query(Document).filter(Document.user_id == current_user.id).all() + return {"documents": documents} + +@router.get("/{document_id}", response_model=DocumentResponse) +async def get_document(document_id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_active_user)): + document = db.query(Document).filter(Document.id == document_id, Document.user_id == current_user.id).first() + if document is None: + raise HTTPException(status_code=404, detail="Document not found") + return document + +@router.get("/{document_id}/status", response_model=DocumentResponse) +async def get_document_status(document_id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_active_user)): + # Check if document exists and belongs to user + document = db.query(Document).filter(Document.id == document_id, Document.user_id == current_user.id).first() + if document is None: + raise HTTPException(status_code=404, detail="Document not found") + + # Return the document with its current status + return document + +@router.post("/reload", response_model=dict) +async def reload_documents(current_user: User = Depends(get_current_active_user)): + """ + Reload the PathRAG instance to recognize newly uploaded documents. + This is useful after uploading documents to make them available for querying + without restarting the server. + """ + # Declare global rag at the beginning of the function + global rag + + try: + # Reload the PathRAG instance + reload_rag_instance() + + # Update the local reference + rag = get_rag_instance() + + return { + "success": True, + "message": "PathRAG instance reloaded successfully. New documents are now available for querying." + } + except Exception as e: + raise HTTPException( + status_code=500, + detail=f"Failed to reload PathRAG instance: {str(e)}" + ) + diff --git a/Demo/backend/api/features/documents/schemas.py b/Demo/backend/api/features/documents/schemas.py new file mode 100644 index 0000000..a042072 --- /dev/null +++ b/Demo/backend/api/features/documents/schemas.py @@ -0,0 +1,39 @@ +from pydantic import BaseModel +from typing import List, Optional, Dict, Any +from datetime import datetime + +class DocumentBase(BaseModel): + filename: str + content_type: str + +class DocumentCreate(DocumentBase): + file_size: int + file_path: str + +class DocumentResponse(DocumentBase): + id: int + user_id: int + file_size: int + uploaded_at: datetime + status: Optional[str] = None + processed_at: Optional[datetime] = None + error_message: Optional[str] = None + + model_config = { + "from_attributes": True + } + +class DocumentList(BaseModel): + documents: List[DocumentResponse] + + model_config = { + "from_attributes": True + } + +class UploadStatus(BaseModel): + filename: str + content_type: str + progress: float # 0-100 percentage + status: str # "processing", "completed", "failed" + message: Optional[str] = None + document_id: Optional[int] = None diff --git a/Demo/backend/api/features/knowledge_graph/routes.py b/Demo/backend/api/features/knowledge_graph/routes.py new file mode 100644 index 0000000..63abbb8 --- /dev/null +++ b/Demo/backend/api/features/knowledge_graph/routes.py @@ -0,0 +1,91 @@ +from fastapi import APIRouter, Depends, HTTPException +from api.features.rag_manager import get_rag_instance +from models.database import User +from api.auth.jwt_handler import get_current_active_user +from .schemas import Graph, GraphQuery, Node, Edge +from PathRAG.PathRAG import PathRAG + +# Initialize PathRAG +rag = PathRAG(working_dir="./data") + +router = APIRouter( + prefix="/knowledge-graph", + tags=["Knowledge Graph"], + dependencies=[Depends(get_current_active_user)] +) + +@router.post("/query", response_model=Graph) +async def query_knowledge_graph(query: GraphQuery, current_user: User = Depends(get_current_active_user)): + try: + rag = get_rag_instance() + # Get the knowledge graph from PathRAG + knowledge_graph = rag.chunk_entity_relation_graph + + # Convert NetworkX graph to our schema + nodes = [] + edges = [] + + # Get all nodes and edges + for node_id in knowledge_graph._graph.nodes(): + node_data = knowledge_graph._graph.nodes[node_id] + nodes.append( + Node( + id=node_id, + label=node_id, + type=node_data.get("entity_type", "Unknown"), + description=node_data.get("description", "") + ) + ) + + for source, target, data in knowledge_graph._graph.edges(data=True): + edges.append( + Edge( + source=source, + target=target, + label=data.get("description", ""), + weight=data.get("weight", 1.0) + ) + ) + + return Graph(nodes=nodes, edges=edges) + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error querying knowledge graph: {str(e)}") + +@router.get("/", response_model=Graph) +async def get_knowledge_graph(current_user: User = Depends(get_current_active_user)): + try: + rag = get_rag_instance() + # Get the knowledge graph from PathRAG + knowledge_graph = rag.chunk_entity_relation_graph + + # Convert NetworkX graph to our schema + nodes = [] + edges = [] + + # Get all nodes and edges + for node_id in knowledge_graph._graph.nodes(): + node_data = knowledge_graph._graph.nodes[node_id] + nodes.append( + Node( + id=node_id, + label=node_id, + type=node_data.get("entity_type", "Unknown"), + description=node_data.get("description", "") + ) + ) + + for source, target, data in knowledge_graph._graph.edges(data=True): + edges.append( + Edge( + source=source, + target=target, + label=data.get("description", ""), + weight=data.get("weight", 1.0) + ) + ) + + return Graph(nodes=nodes, edges=edges) + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error getting knowledge graph: {str(e)}") diff --git a/Demo/backend/api/features/knowledge_graph/schemas.py b/Demo/backend/api/features/knowledge_graph/schemas.py new file mode 100644 index 0000000..79d4e9a --- /dev/null +++ b/Demo/backend/api/features/knowledge_graph/schemas.py @@ -0,0 +1,21 @@ +from pydantic import BaseModel +from typing import List, Dict, Any, Optional + +class Node(BaseModel): + id: str + label: str + type: str + description: Optional[str] = None + +class Edge(BaseModel): + source: str + target: str + label: Optional[str] = None + weight: Optional[float] = None + +class Graph(BaseModel): + nodes: List[Node] + edges: List[Edge] + +class GraphQuery(BaseModel): + query: str diff --git a/Demo/backend/api/features/rag_manager.py b/Demo/backend/api/features/rag_manager.py new file mode 100644 index 0000000..a8bf8ad --- /dev/null +++ b/Demo/backend/api/features/rag_manager.py @@ -0,0 +1,54 @@ +""" +PathRAG Manager - Centralized management of PathRAG instances +""" + +import os +import logging +from PathRAG import PathRAG +from PathRAG.llm import azure_openai_complete + +logger = logging.getLogger("PathRAG") + +# Setup a working directory for PathRAG. +WORKING_DIR = os.path.join(os.getcwd(), 'data') +if not os.path.exists(WORKING_DIR): + os.mkdir(WORKING_DIR) + +# Global PathRAG instance +_rag_instance = None + +def get_rag_instance(): + """ + Get the current PathRAG instance, initializing it if necessary. + """ + global _rag_instance + + if _rag_instance is None: + logger.info("Initializing PathRAG instance...") + _rag_instance = PathRAG( + working_dir=WORKING_DIR, + llm_model_func=azure_openai_complete, + ) + logger.info("PathRAG instance initialized successfully") + + return _rag_instance + +def reload_rag_instance(): + """ + Reload the PathRAG instance to recognize new data files. + """ + global _rag_instance + + logger.info("Reloading PathRAG instance...") + + # Create a new instance + _rag_instance = PathRAG( + working_dir=WORKING_DIR, + llm_model_func=azure_openai_complete, + ) + + logger.info("PathRAG instance reloaded successfully") + return _rag_instance + +# Initialize the instance on module import +rag = get_rag_instance() diff --git a/Demo/backend/api/features/users/routes.py b/Demo/backend/api/features/users/routes.py new file mode 100644 index 0000000..d789543 --- /dev/null +++ b/Demo/backend/api/features/users/routes.py @@ -0,0 +1,41 @@ +from fastapi import APIRouter, Depends, HTTPException +from sqlalchemy.orm import Session +from typing import List + +from models.database import get_db, User +from api.auth.jwt_handler import get_current_active_user +from .schemas import UserProfile, UserList, ThemeUpdate + +router = APIRouter( + prefix="/users", + tags=["Users"], + dependencies=[Depends(get_current_active_user)] +) + +@router.get("/", response_model=UserList) +async def get_users(db: Session = Depends(get_db), current_user: User = Depends(get_current_active_user)): + users = db.query(User).all() + return {"users": users} + +@router.get("/{user_id}", response_model=UserProfile) +async def get_user(user_id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_active_user)): + user = db.query(User).filter(User.id == user_id).first() + if user is None: + raise HTTPException(status_code=404, detail="User not found") + return user + +@router.post("/theme", response_model=UserProfile) +async def update_theme(theme_data: ThemeUpdate, db: Session = Depends(get_db), current_user: User = Depends(get_current_active_user)): + """Update the user's theme preference""" + # Validate theme + allowed_themes = ["blue", "red", "violet"] + if theme_data.theme not in allowed_themes: + raise HTTPException(status_code=400, detail=f"Invalid theme. Allowed themes: {', '.join(allowed_themes)}") + + # Update user theme + user = db.query(User).filter(User.id == current_user.id).first() + user.theme = theme_data.theme + db.commit() + db.refresh(user) + + return user diff --git a/Demo/backend/api/features/users/schemas.py b/Demo/backend/api/features/users/schemas.py new file mode 100644 index 0000000..9560878 --- /dev/null +++ b/Demo/backend/api/features/users/schemas.py @@ -0,0 +1,22 @@ +from pydantic import BaseModel +from typing import List, Optional +from datetime import datetime + +class UserProfile(BaseModel): + id: int + username: str + email: str + created_at: datetime + theme: Optional[str] = None + + class Config: + orm_mode = True + +class UserList(BaseModel): + users: List[UserProfile] + + class Config: + orm_mode = True + +class ThemeUpdate(BaseModel): + theme: str diff --git a/Demo/backend/main.py b/Demo/backend/main.py new file mode 100644 index 0000000..33ffe8a --- /dev/null +++ b/Demo/backend/main.py @@ -0,0 +1,154 @@ +import os +import logging +import uvicorn +from contextlib import asynccontextmanager +from fastapi import FastAPI +from fastapi.middleware.cors import CORSMiddleware +from dotenv import load_dotenv + +# Configure logging +logging.basicConfig( + level=logging.INFO, + format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", +) +logger = logging.getLogger("pathrag") + +# Load environment variables from .env file +env_path = os.path.join(os.path.dirname(__file__), '.env') +if os.path.exists(env_path): + logger.info(f"Loading environment variables from {env_path}") + load_dotenv(env_path) +else: + logger.warning("No .env file found. Using environment variables from the system.") + +# Check for required environment variables +required_vars = ['SECRET_KEY'] +missing_vars = [var for var in required_vars if not os.getenv(var)] +if missing_vars: + logger.warning(f"Missing required environment variables: {', '.join(missing_vars)}") + logger.warning("Please set these variables in your .env file or environment.") + logger.info("See sample.env for an example configuration.") + +# Import models and routes +from models.database import create_tables, User, SessionLocal +from api.auth.jwt_handler import get_password_hash +from api.auth.routes import router as auth_router +from api.features.users.routes import router as users_router +from api.features.chats.routes import router as chats_router +from api.features.documents.routes import router as documents_router +from api.features.knowledge_graph.routes import router as knowledge_graph_router + +# Create default users +def create_default_users(): + db = SessionLocal() + try: + # Check if users already exist + if db.query(User).count() == 0: + # Create 3 default users + default_users = [ + {"username": "user1", "email": "user1@example.com", "password": "Pass@123"}, + {"username": "user2", "email": "user2@example.com", "password": "Pass@123"}, + {"username": "user3", "email": "user3@example.com", "password": "Pass@123"} + ] + + for user_data in default_users: + hashed_password = get_password_hash(user_data["password"]) + user = User( + username=user_data["username"], + email=user_data["email"], + hashed_password=hashed_password + ) + db.add(user) + + db.commit() + logger.info("Default users created successfully") + finally: + db.close() + +# Already imported at the top + +@asynccontextmanager +async def lifespan(_: FastAPI): + # Startup: Run before the application starts + logger.info("Starting PathRAG API...") + + # Create tables + create_tables() + logger.info("Database tables created") + + # Create default users + create_default_users() + + # Create directories + upload_dir = os.getenv("UPLOAD_DIR", "./uploads") + working_dir = os.getenv("WORKING_DIR", "./data") + + os.makedirs(upload_dir, exist_ok=True) + os.makedirs(working_dir, exist_ok=True) + logger.info(f"Directories created: {upload_dir}, {working_dir}") + + # Yield control to the application + yield + + # Shutdown: Run when the application is shutting down + logger.info("Shutting down PathRAG API...") + +# Create FastAPI app with lifespan +app = FastAPI( + title="PathRAG API", + description="API for PathRAG application with authentication, chat, document management, and knowledge graph features", + version="1.0.0", + lifespan=lifespan +) + +# Configure CORS middleware +cors_origins = os.getenv("CORS_ORIGINS", "*") +if cors_origins == "*": + # Allow all origins in development + origins = ["*"] + logger.warning("CORS is configured to allow all origins. This is not recommended for production.") +else: + # Use specific origins from environment variable in production + origins = [origin.strip() for origin in cors_origins.split(",")] + logger.info(f"CORS is configured to allow specific origins: {origins}") + +app.add_middleware( + CORSMiddleware, + allow_origins=origins, + allow_credentials=True, + allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"], + allow_headers=["Authorization", "Content-Type"], +) + +# Include routers +app.include_router(auth_router) +app.include_router(users_router) +app.include_router(chats_router) +app.include_router(documents_router) +app.include_router(knowledge_graph_router) + +@app.get("/") +async def root(): + return { + "message": "Welcome to PathRAG API", + "docs": "/docs", + "version": "1.0.0" + } + +if __name__ == "__main__": + # Get configuration from environment variables + host = os.getenv("HOST", "0.0.0.0") + port = int(os.getenv("PORT", "8000")) + reload = os.getenv("DEBUG", "False").lower() in ("true", "1", "t") + + # Log startup configuration + logger.info(f"Starting server on {host}:{port} (reload={reload})") + + # Run the server + uvicorn.run( + "main:app", + host=host, + port=port, + reload=reload, + log_level=os.getenv("LOG_LEVEL", "info").lower() + ) diff --git a/Demo/backend/models/database.py b/Demo/backend/models/database.py new file mode 100644 index 0000000..2827058 --- /dev/null +++ b/Demo/backend/models/database.py @@ -0,0 +1,92 @@ +from sqlalchemy import create_engine, Column, Integer, String, Text, ForeignKey, DateTime, Boolean +from sqlalchemy.ext.declarative import declarative_base +from sqlalchemy.orm import sessionmaker, relationship +import datetime +import uuid + +# Create SQLite database engine +DATABASE_URL = "sqlite:///./pathrag.db" +engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False}) + +# Create session +SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) + +# Create base class for models +Base = declarative_base() + +# Define User model +class User(Base): + __tablename__ = "users" + + id = Column(Integer, primary_key=True, index=True) + username = Column(String, unique=True, index=True) + email = Column(String, unique=True, index=True) + hashed_password = Column(String) + created_at = Column(DateTime, default=datetime.datetime.utcnow) + theme = Column(String, nullable=True, default="blue") + + # Relationships + threads = relationship("Thread", back_populates="user") + chats = relationship("Chat", back_populates="user") + documents = relationship("Document", back_populates="user") + +# Define Thread model +class Thread(Base): + __tablename__ = "threads" + + id = Column(Integer, primary_key=True, index=True) + uuid = Column(String, unique=True, index=True) + user_id = Column(Integer, ForeignKey("users.id")) + title = Column(String, nullable=True) + created_at = Column(DateTime, default=datetime.datetime.utcnow) + updated_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow) + is_deleted = Column(Boolean, default=False) + + # Relationships + user = relationship("User", back_populates="threads") + chats = relationship("Chat", back_populates="thread", cascade="all, delete-orphan") + +# Define Chat model +class Chat(Base): + __tablename__ = "chats" + + id = Column(Integer, primary_key=True, index=True) + user_id = Column(Integer, ForeignKey("users.id")) + thread_id = Column(Integer, ForeignKey("threads.id")) + role = Column(String) # 'user' or 'system' + message = Column(Text) + created_at = Column(DateTime, default=datetime.datetime.utcnow) + + # Relationships + user = relationship("User", back_populates="chats") + thread = relationship("Thread", back_populates="chats") + +# Define Document model +class Document(Base): + __tablename__ = "documents" + + id = Column(Integer, primary_key=True, index=True) + user_id = Column(Integer, ForeignKey("users.id")) + filename = Column(String) + content_type = Column(String) + file_path = Column(String) + file_size = Column(Integer) + uploaded_at = Column(DateTime, default=datetime.datetime.utcnow) + status = Column(String, nullable=True) + processed_at = Column(DateTime, nullable=True) + error_message = Column(Text, nullable=True) + + # Relationships + user = relationship("User", back_populates="documents") + +# Create tables +def create_tables(): + Base.metadata.create_all(bind=engine) + +# Get database session +def get_db(): + db = SessionLocal() + try: + yield db + finally: + db.close() diff --git a/Demo/backend/pathrag.db b/Demo/backend/pathrag.db new file mode 100644 index 0000000000000000000000000000000000000000..eeb7b302c6a1b2de240d51081124753f99585a86 GIT binary patch literal 57344 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 literal 0 HcmV?d00001 diff --git a/Demo/backend/requirements.txt b/Demo/backend/requirements.txt new file mode 100644 index 0000000..43b86d0 --- /dev/null +++ b/Demo/backend/requirements.txt @@ -0,0 +1,39 @@ +accelerate +aioboto3 +aiohttp +python-dotenv +python-multipart +fastapi +uvicorn[standard] +websockets +PyPDF2 +pydantic[email] +python-docx +docx2txt +python-pptx +openpyxl +striprtf +odfpy +ebooklib +beautifulsoup4 +# database packages +graspologic +openai +nano-vectordb +psycopg[binary,pool] +sqlalchemy +tenacity +networkx +python-jose +passlib +bcrypt +pyjwt +aiosqlite +matplotlib + +# LLM packages +tiktoken +torch +transformers +xxhash +ollama \ No newline at end of file diff --git a/Demo/backend/sample.env b/Demo/backend/sample.env new file mode 100644 index 0000000..53e658d --- /dev/null +++ b/Demo/backend/sample.env @@ -0,0 +1,70 @@ +# PathRAG Application Environment Variables +# Copy this file to .env and modify as needed + +# ============================================================================= +# REQUIRED SETTINGS +# ============================================================================= + +# JWT Authentication +SECRET_KEY=replace_with_your_secret_key # Generate with: openssl rand -hex 32 +ACCESS_TOKEN_EXPIRE_MINUTES=30 + +# Application Directories +WORKING_DIR=./data # Directory for PathRAG data +UPLOAD_DIR=./uploads # Directory for uploaded documents + +# ============================================================================= +# AI MODEL SETTINGS (Choose ONE option) +# ============================================================================= + +# OPTION 1: Azure OpenAI (Recommended for production) +AZURE_OPENAI_API_KEY=your_azure_openai_key +AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com +AZURE_OPENAI_DEPLOYMENT=gpt-4o # Your deployment name +AZURE_OPENAI_API_VERSION=2023-05-15 +AZURE_EMBEDDING_DEPLOYMENT=text-embedding-3-large +AZURE_EMBEDDING_API_VERSION=2023-05-15 + +# OPTION 2: OpenAI Direct API +# OPENAI_API_KEY=your_openai_api_key +# OPENAI_API_BASE=https://api.openai.com/v1 + +# ============================================================================= +# OPTIONAL SETTINGS +# ============================================================================= + +# Database Configuration (Default: SQLite) +DATABASE_URL=sqlite:///./pathrag.db + +# CORS Settings +CORS_ORIGINS=http://localhost:3000 # Comma-separated list of allowed origins + +# PathRAG Configuration +CHUNK_SIZE=1200 # Size of text chunks for processing +CHUNK_OVERLAP=100 # Overlap between chunks +MAX_TOKENS=32768 # Maximum tokens for LLM context +TEMPERATURE=0.7 # LLM temperature setting (0.0-1.0) +TOP_K=40 # Number of top results to retrieve + +# ============================================================================= +# SERVER CONFIGURATION +# ============================================================================= + +# Server host and port +HOST=0.0.0.0 # Server host (0.0.0.0 allows external connections) +PORT=8000 # Server port + +# Logging configuration +LOG_LEVEL=info # Logging level (debug, info, warning, error, critical) + +# ============================================================================= +# DEVELOPMENT SETTINGS (Not recommended for production) +# ============================================================================= + +# Debug mode (enables auto-reload) +# DEBUG=True + +# ============================================================================= +# IMPORTANT: Never commit your .env file to version control! +# Add .env to your .gitignore file. +# ============================================================================= diff --git a/Demo/backend/start-api.bat b/Demo/backend/start-api.bat new file mode 100644 index 0000000..422591f --- /dev/null +++ b/Demo/backend/start-api.bat @@ -0,0 +1,26 @@ +@echo off +REM Start script for PathRAG API only + +echo Starting PathRAG API... +cd backend +REM Check if Python virtual environment exists +if not exist .venv ( + echo Python virtual environment not found. Creating one... + python -m venv .venv + echo Virtual environment created. +) + +REM Activate virtual environment +echo Activating Python virtual environment... +call .venv\Scripts\activate.bat + +REM Install backend dependencies +echo Installing backend dependencies... +pip install -r requirements.txt +echo Backend dependencies installed. + +REM Start backend API +echo Starting backend API on port 8000... +uvicorn main:app --host 0.0.0.0 --port 8000 + +echo API server stopped. diff --git a/Demo/backend/start-api.sh b/Demo/backend/start-api.sh new file mode 100644 index 0000000..c1b2dfb --- /dev/null +++ b/Demo/backend/start-api.sh @@ -0,0 +1,33 @@ +#!/bin/bash +# Start script for PathRAG API only + +# Colors for terminal output +GREEN='\033[0;32m' +BLUE='\033[0;34m' +YELLOW='\033[1;33m' +NC='\033[0m' # No Color + +echo -e "${GREEN}Starting PathRAG API...${NC}" +cd backend +# Check if Python virtual environment exists +if [ ! -d ".venv" ]; then + echo -e "${YELLOW}Python virtual environment not found. Creating one...${NC}" + python -m venv .venv + echo -e "${GREEN}Virtual environment created.${NC}" +fi + +# Activate virtual environment +echo -e "${BLUE}Activating Python virtual environment...${NC}" +source .venv/bin/activate + +# Install backend dependencies +echo -e "${BLUE}Installing backend dependencies...${NC}" +pip install -r requirements.txt +echo -e "${GREEN}Backend dependencies installed.${NC}" + +# Start backend API +echo -e "${BLUE}Starting backend API on port 8000...${NC}" +cd "$(dirname "$0")" +uvicorn main:app --host 0.0.0.0 --port 8000 + +echo -e "${GREEN}API server stopped.${NC}" diff --git a/Demo/frontend/package-lock.json b/Demo/frontend/package-lock.json new file mode 100644 index 0000000..70ff266 --- /dev/null +++ b/Demo/frontend/package-lock.json @@ -0,0 +1,22850 @@ +{ + "name": "pathrag-ui", + "version": "0.1.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "pathrag-ui", + "version": "0.1.0", + "dependencies": { + "@fortawesome/fontawesome-svg-core": "^6.7.2", + "@fortawesome/free-brands-svg-icons": "^6.7.2", + "@fortawesome/free-regular-svg-icons": "^6.7.2", + "@fortawesome/free-solid-svg-icons": "^6.7.2", + "@fortawesome/react-fontawesome": "^0.2.2", + "@rsuite/icons": "^1.3.2", + "axios": "^1.4.0", + "d3": "^7.8.5", + "jwt-decode": "^3.1.2", + "mermaid": "^11.6.0", + "react": "^18.2.0", + "react-dom": "^18.2.0", + "react-dropzone": "^14.2.3", + "react-markdown": "^10.1.0", + "react-router-dom": "^6.14.1", + "react-scripts": "5.0.1", + "react-syntax-highlighter": "^15.6.1", + "remark-gfm": "^4.0.1", + "rsuite": "^5.37.0", + "styled-components": "^6.1.17", + "web-vitals": "^2.1.4" + }, + "devDependencies": { + "@testing-library/jest-dom": "^5.16.5", + "@testing-library/react": "^13.4.0", + "@testing-library/user-event": "^13.5.0", + "cross-env": "^7.0.3" + } + }, + "node_modules/@adobe/css-tools": { + "version": "4.4.2", + "resolved": "https://registry.npmjs.org/@adobe/css-tools/-/css-tools-4.4.2.tgz", + "integrity": "sha512-baYZExFpsdkBNuvGKTKWCwKH57HRZLVtycZS05WTQNVOiXVSeAki3nU35zlRbToeMW8aHlJfyS+1C4BOv27q0A==", + "dev": true, + "license": "MIT" + }, + "node_modules/@alloc/quick-lru": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz", + "integrity": "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "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.0.0", + "resolved": "https://registry.npmjs.org/@antfu/install-pkg/-/install-pkg-1.0.0.tgz", + "integrity": "sha512-xvX6P/lo1B3ej0OsaErAjqgFYzYVcJpamjLAFLYh9vRJngBrMoUG7aVnrGTeqM7yxbyTD5p3F2+0/QUEh8Vzhw==", + "license": "MIT", + "dependencies": { + "package-manager-detector": "^0.2.8", + "tinyexec": "^0.3.2" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "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==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz", + "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==", + "license": "MIT", + "dependencies": { + "@babel/helper-validator-identifier": "^7.27.1", + "js-tokens": "^4.0.0", + "picocolors": "^1.1.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.27.1.tgz", + "integrity": "sha512-Q+E+rd/yBzNQhXkG+zQnF58e4zoZfBedaxwzPmicKsiK3nt8iJYrSrDbjwFFDGC4f+rPafqRaPH6TsDoSvMf7A==", + "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==", + "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", + "convert-source-map": "^2.0.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.3", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/core/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@nicolo-ribaudo/eslint-scope-5-internals": "5.1.1-v1", + "eslint-visitor-keys": "^2.1.0", + "semver": "^6.3.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || >=14.0.0" + }, + "peerDependencies": { + "@babel/core": "^7.11.0", + "eslint": "^7.5.0 || ^8.0.0 || ^9.0.0" + } + }, + "node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz", + "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==", + "license": "Apache-2.0", + "engines": { + "node": ">=10" + } + }, + "node_modules/@babel/eslint-parser/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "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==", + "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", + "jsesc": "^3.0.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.1.tgz", + "integrity": "sha512-2YaDd/Rd9E598B5+WIc8wJPmWETiiJXFYVE60oX8FDohv7rAUU3CQj+A1MgeEmcsk2+dQuEjIe/GDvig0SqL4g==", + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.27.1", + "@babel/helper-validator-option": "^7.27.1", + "browserslist": "^4.24.0", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.27.1", + "@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", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-create-class-features-plugin/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/helper-create-regexp-features-plugin": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.27.1.tgz", + "integrity": "sha512-uVDC72XVf8UbrH5qQTc18Agb8emwjTiZrQE11Nv3CuBEZmVvTwwE9CBUEvHku06gQCAyYf8Nv6ja1IN+6LMbxQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.27.1", + "regexpu-core": "^6.2.0", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-create-regexp-features-plugin/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/helper-compilation-targets": "^7.22.6", + "@babel/helper-plugin-utils": "^7.22.5", + "debug": "^4.1.1", + "lodash.debounce": "^4.0.8", + "resolve": "^1.14.2" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.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", + "integrity": "sha512-E5chM8eWjTp/aNoVpcbfM7mLxu9XGLWYise2eBKGQomAk/Mb4XoxyqXTZbuTohbsl8EKqdlMhnDI2CCLfcs9wA==", + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.27.1", + "@babel/types": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz", + "integrity": "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==", + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.27.1", + "@babel/types": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.27.1", + "@babel/helper-validator-identifier": "^7.27.1", + "@babel/traverse": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-optimise-call-expression": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.27.1.tgz", + "integrity": "sha512-URMGH08NzYFhubNSGJrpUEphGKQwMQYBySzat5cAByY1/YgIRkULnIy3tAMeszlL/so2HbeilYloUmSpd7GdVw==", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz", + "integrity": "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-remap-async-to-generator": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.27.1.tgz", + "integrity": "sha512-7fiA521aVw8lSPeI4ZOD3vRFkoqkJcS+z4hFo82bFSH/2tNd6eJ5qCVMS5OzDmZh/kaHQeBaeyxK6wljcPtveA==", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.27.1", + "@babel/helper-wrap-function": "^7.27.1", + "@babel/traverse": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-replace-supers": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.27.1.tgz", + "integrity": "sha512-7EHz6qDZc8RYS5ElPoShMheWvEgERonFCs7IAonWLLUTXW59DP14bCZt89/GKyreYn8g3S83m21FelHKbeDCKA==", + "license": "MIT", + "dependencies": { + "@babel/helper-member-expression-to-functions": "^7.27.1", + "@babel/helper-optimise-call-expression": "^7.27.1", + "@babel/traverse": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-skip-transparent-expression-wrappers": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.27.1.tgz", + "integrity": "sha512-Tub4ZKEXqbPjXgWLl2+3JpQAYBJ8+ikpQ2Ocj/q/r0LwE3UhENh7EUabyHjz2kCEsrRY83ew2DQdHluuiDQFzg==", + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.27.1", + "@babel/types": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", + "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.27.1.tgz", + "integrity": "sha512-D2hP9eA+Sqx1kBZgzxZh0y1trbuU+JoDkiEwqhQ36nodYqJwyEIhPSdMNd7lOm/4io72luTPWH20Yda0xOuUow==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz", + "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/template": "^7.27.1", + "@babel/traverse": "^7.27.1", + "@babel/types": "^7.27.1" + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/template": "^7.27.1", + "@babel/types": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.27.1.tgz", + "integrity": "sha512-I0dZ3ZpCrJ1c04OqlNsQcKiZlsrXf/kkE4FXzID9rIOYICsAbA8mMDzhW/luRNAHdCNt7os/u8wenklZDlUVUQ==", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.27.1" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-firefox-class-in-computed-class-key": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-firefox-class-in-computed-class-key/-/plugin-bugfix-firefox-class-in-computed-class-key-7.27.1.tgz", + "integrity": "sha512-QPG3C9cCVRQLxAVwmefEmwdTanECuUBMQZ/ym5kiw3XKCGA7qkuQLcjWWHcrD/GKbn/WmJwaezfuuAOcyKlRPA==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/traverse": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-safari-class-field-initializer-scope": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-class-field-initializer-scope/-/plugin-bugfix-safari-class-field-initializer-scope-7.27.1.tgz", + "integrity": "sha512-qNeq3bCKnGgLkEXUuFry6dPlGfCdQNZbn7yUAPCInwAJHMU7THJfrBSozkcWq5sNM6RcF3S8XyQL2A52KNR9IA==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression/-/plugin-bugfix-safari-id-destructuring-collision-in-function-expression-7.27.1.tgz", + "integrity": "sha512-g4L7OYun04N1WyqMNjldFwlfPCLVkgB54A/YCXICZYBsvJJE3kByKv9c9+R/nAfmIfjl2rKYLNyMHboYbZaWaA==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.27.1.tgz", + "integrity": "sha512-oO02gcONcD5O1iTLi/6frMJBIwWEHceWGSGqrpCmEL8nogiS6J9PBlE48CaK20/Jx1LuRml9aDftLgdjXT8+Cw==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1", + "@babel/plugin-transform-optional-chaining": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.13.0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/traverse": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-proposal-class-properties": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.18.6.tgz", + "integrity": "sha512-cumfXOF0+nzZrrN8Rf0t7M+tF6sZc7vhQwYQck9q1/5w2OExlD+b4v4RpMJFaV1Z7WcDRgO6FqvxqxGlwo+RHQ==", + "deprecated": "This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-class-properties instead.", + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.18.6", + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/plugin-syntax-decorators": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-nullish-coalescing-operator": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-nullish-coalescing-operator/-/plugin-proposal-nullish-coalescing-operator-7.18.6.tgz", + "integrity": "sha512-wQxQzxYeJqHcfppzBDnm1yAY0jSRkUXR2z8RePZYrKwMKgMlE8+Z6LUno+bd6LvbGh8Gltvy74+9pIYkr+XkKA==", + "deprecated": "This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-nullish-coalescing-operator instead.", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6", + "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-numeric-separator": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-numeric-separator/-/plugin-proposal-numeric-separator-7.18.6.tgz", + "integrity": "sha512-ozlZFogPqoLm8WBr5Z8UckIoE4YQ5KESVcNudyXOR8uqIkliTEgJ3RoketfG6pmzLdeZF0H/wjE9/cCEitBl7Q==", + "deprecated": "This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-numeric-separator instead.", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.18.6", + "@babel/plugin-syntax-numeric-separator": "^7.10.4" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-optional-chaining": { + "version": "7.21.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.21.0.tgz", + "integrity": "sha512-p4zeefM72gpmEe2fkUr/OnOXpWEf8nAgk7ZYVqqfFiyIG7oFfVZcCrU64hWn5xp4tQ9LkV4bTIa5rD0KANpKNA==", + "deprecated": "This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-optional-chaining instead.", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/helper-skip-transparent-expression-wrappers": "^7.20.0", + "@babel/plugin-syntax-optional-chaining": "^7.8.3" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-private-methods": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-methods/-/plugin-proposal-private-methods-7.18.6.tgz", + "integrity": "sha512-nutsvktDItsNn4rpGItSNV2sz1XwS+nfU0Rg8aCx3W3NOKVzdMjJRu0O5OkgDp3ZGICSTbgRpxZoWsxoKRvbeA==", + "deprecated": "This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-private-methods instead.", + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.18.6", + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-private-property-in-object": { + "version": "7.21.0-placeholder-for-preset-env.2", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.0-placeholder-for-preset-env.2.tgz", + "integrity": "sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-async-generators": { + "version": "7.8.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz", + "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-bigint": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-bigint/-/plugin-syntax-bigint-7.8.3.tgz", + "integrity": "sha512-wnTnFlG+YxQm3vDxpGE57Pj0srRU4sHE/mDkt1qv2YJJSeUAec2ma4WLUnUPeKjyrfntVwe/N6dCXpU+zL3Npg==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-class-properties": { + "version": "7.12.13", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz", + "integrity": "sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.12.13" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-class-static-block": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-static-block/-/plugin-syntax-class-static-block-7.14.5.tgz", + "integrity": "sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-decorators": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-decorators/-/plugin-syntax-decorators-7.27.1.tgz", + "integrity": "sha512-YMq8Z87Lhl8EGkmb0MwYkt36QnxC+fzCgrl66ereamPlYToRpIk5nUjKUY3QKLWq8mwUB1BgbeXcTJhZOCDg5A==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-flow": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-flow/-/plugin-syntax-flow-7.27.1.tgz", + "integrity": "sha512-p9OkPbZ5G7UT1MofwYFigGebnrzGJacoBSQM0/6bi/PUMVE+qlWDD/OalvQKbwgQzU6dl0xAv6r4X7Jme0RYxA==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-import-assertions": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-assertions/-/plugin-syntax-import-assertions-7.27.1.tgz", + "integrity": "sha512-UT/Jrhw57xg4ILHLFnzFpPDlMbcdEicaAtjPQpbj9wa8T4r5KVWCimHcL/460g8Ht0DMxDyjsLgiWSkVjnwPFg==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-import-attributes": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-attributes/-/plugin-syntax-import-attributes-7.27.1.tgz", + "integrity": "sha512-oFT0FrKHgF53f4vOsZGi2Hh3I35PfSmVs4IBFLFj4dnafP+hIWDLg3VyKmUHfLoLHlyxY4C7DGtmHuJgn+IGww==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-import-meta": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-import-meta/-/plugin-syntax-import-meta-7.10.4.tgz", + "integrity": "sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-json-strings": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz", + "integrity": "sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-jsx": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.27.1.tgz", + "integrity": "sha512-y8YTNIeKoyhGd9O0Jiyzyyqk8gdjnumGTQPsz0xOZOQ2RmkVJeZ1vmmfIvFEKqucBG6axJGBZDE/7iI5suUI/w==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-logical-assignment-operators": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz", + "integrity": "sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-nullish-coalescing-operator": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz", + "integrity": "sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-numeric-separator": { + "version": "7.10.4", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz", + "integrity": "sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-object-rest-spread": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz", + "integrity": "sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-optional-catch-binding": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz", + "integrity": "sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-optional-chaining": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz", + "integrity": "sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-private-property-in-object": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-private-property-in-object/-/plugin-syntax-private-property-in-object-7.14.5.tgz", + "integrity": "sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-top-level-await": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz", + "integrity": "sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-typescript": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-typescript/-/plugin-syntax-typescript-7.27.1.tgz", + "integrity": "sha512-xfYCBMxveHrRMnAWl1ZlPXOZjzkN82THFvLhQhFXFt81Z5HnN+EtUkZhv/zcKpmT3fzmWZB0ywiBrbC3vogbwQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-unicode-sets-regex": { + "version": "7.18.6", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-unicode-sets-regex/-/plugin-syntax-unicode-sets-regex-7.18.6.tgz", + "integrity": "sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==", + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.18.6", + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-transform-arrow-functions": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.27.1.tgz", + "integrity": "sha512-8Z4TGic6xW70FKThA5HYEKKyBpOOsucTOD1DjU3fZxDg+K3zBJcXMFnt/4yQiZnf5+MiOMSXQ9PaEK/Ilh1DeA==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-remap-async-to-generator": "^7.27.1", + "@babel/traverse": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-async-to-generator": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.27.1.tgz", + "integrity": "sha512-NREkZsZVJS4xmTr8qzE5y8AfIPqsdQfRuUiLRTEzb7Qii8iFWCyDKaUV2c0rCuh4ljDZ98ALHP/PetiBV2nddA==", + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-remap-async-to-generator": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-block-scoped-functions": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.27.1.tgz", + "integrity": "sha512-cnqkuOtZLapWYZUYM5rVIdv1nXYuFVIltZ6ZJ7nIj585QsjKM5dhL2Fu/lICXZ1OyIAFc7Qy+bvDAtTXqGrlhg==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-class-properties": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-class-properties/-/plugin-transform-class-properties-7.27.1.tgz", + "integrity": "sha512-D0VcalChDMtuRvJIu3U/fwWjf8ZMykz5iZsg77Nuj821vCKI3zCyRLwRdWbsuJ/uRwZhZ002QtCqIkwC/ZkvbA==", + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.12.0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.27.1", + "@babel/helper-compilation-targets": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-replace-supers": "^7.27.1", + "@babel/traverse": "^7.27.1", + "globals": "^11.1.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-classes/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==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/plugin-transform-computed-properties": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.27.1.tgz", + "integrity": "sha512-lj9PGWvMTVksbWiDT2tW68zGS/cyo4AkZ/QTp0sQT0mjPopCmrSkzxeXkznjqBxzDI6TclZhOJbBmbBLjuOZUw==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/template": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-dotall-regex": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.27.1.tgz", + "integrity": "sha512-gEbkDVGRvjj7+T1ivxrfgygpT7GUd4vmODtYpbs0gZATdkX8/iSnOtZSxiZnsgm1YjTgjI6VKBGSJJevkrclzw==", + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-duplicate-keys": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.27.1.tgz", + "integrity": "sha512-MTyJk98sHvSs+cvZ4nOauwTTG1JeonDjSGvGGUNHreGQns+Mpt6WX/dVzWBHgg+dYZhkC4X+zTDfkTU+Vy9y7Q==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-duplicate-named-capturing-groups-regex": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-named-capturing-groups-regex/-/plugin-transform-duplicate-named-capturing-groups-regex-7.27.1.tgz", + "integrity": "sha512-hkGcueTEzuhB30B3eJCbCYeCaaEQOmQR0AdvzpD4LoN0GXMWzzGSuRrxR2xTnCrvNbVwK9N6/jQ92GSLfiZWoQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-transform-dynamic-import": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dynamic-import/-/plugin-transform-dynamic-import-7.27.1.tgz", + "integrity": "sha512-MHzkWQcEmjzzVW9j2q8LGjwGWpG2mjwaaB0BNQwst3FIjqsg8Ct/mIZlvSPJvfi9y2AC8mi/ktxbFVL9pZ1I4A==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "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", + "integrity": "sha512-uspvXnhHvGKf2r4VVtBpeFnuDWsJLQ6MF6lGJLC89jBR1uoVeqM416AZtTuhTezOfgHicpJQmoD5YUakO/YmXQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-export-namespace-from": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-export-namespace-from/-/plugin-transform-export-namespace-from-7.27.1.tgz", + "integrity": "sha512-tQvHWSZ3/jH2xuq/vZDy0jNn+ZdXJeM8gHvX4lnJmsc3+50yPlWdZXIc5ay+umX+2/tJIqHqiEqcJvxlmIvRvQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-flow-strip-types": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-flow-strip-types/-/plugin-transform-flow-strip-types-7.27.1.tgz", + "integrity": "sha512-G5eDKsu50udECw7DL2AcsysXiQyB7Nfg521t2OAJ4tbfTJ27doHLeF/vlI1NZGlLdbb/v+ibvtL1YBQqYOwJGg==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/plugin-syntax-flow": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-for-of": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.27.1.tgz", + "integrity": "sha512-BfbWFFEJFQzLCQ5N8VocnCtA8J1CLkNTe2Ms2wocj75dd6VpiqS5Z5quTYcUoo4Yq+DN0rtikODccuv7RU81sw==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-function-name": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.27.1.tgz", + "integrity": "sha512-1bQeydJF9Nr1eBCMMbC+hdwmRlsv5XYOMu03YSWFwNs0HsAmtSxxF1fyuYPqemVldVyFmlCU7w8UE14LupUSZQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-compilation-targets": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/traverse": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-json-strings": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-json-strings/-/plugin-transform-json-strings-7.27.1.tgz", + "integrity": "sha512-6WVLVJiTjqcQauBhn1LkICsR2H+zm62I3h9faTDKt1qP4jn2o72tSvqMwtGFKGTpojce0gJs+76eZ2uCHRZh0Q==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-literals": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.27.1.tgz", + "integrity": "sha512-0HCFSepIpLTkLcsi86GG3mTUzxV5jpmbv97hTETW3yzrAij8aqlD36toB1D0daVFJM8NK6GvKO0gslVQmm+zZA==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-logical-assignment-operators": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-logical-assignment-operators/-/plugin-transform-logical-assignment-operators-7.27.1.tgz", + "integrity": "sha512-SJvDs5dXxiae4FbSL1aBJlG4wvl594N6YEVVn9e3JGulwioy6z3oPjx/sQBO3Y4NwUu5HNix6KJ3wBZoewcdbw==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-member-expression-literals": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.27.1.tgz", + "integrity": "sha512-hqoBX4dcZ1I33jCSWcXrP+1Ku7kdqXf1oeah7ooKOIiAdKQ+uqftgCFNOSzA5AMS2XIHEYeGFg4cKRCdpxzVOQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-amd": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.27.1.tgz", + "integrity": "sha512-iCsytMg/N9/oFq6n+gFTvUYDZQOMK5kEdeYxmxt91fcJGycfxVP9CnrxoliM0oumFERba2i8ZtwRUCMhvP1LnA==", + "license": "MIT", + "dependencies": { + "@babel/helper-module-transforms": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-commonjs": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.27.1.tgz", + "integrity": "sha512-OJguuwlTYlN0gBZFRPqwOGNWssZjfIUdS7HMYtN8c1KmwpwHFBwTeFZrg9XZa+DFTitWOW5iTAG7tyCUPsCCyw==", + "license": "MIT", + "dependencies": { + "@babel/helper-module-transforms": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-systemjs": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.27.1.tgz", + "integrity": "sha512-w5N1XzsRbc0PQStASMksmUeqECuzKuTJer7kFagK8AXgpCMkeDMO5S+aaFb7A51ZYDF7XI34qsTX+fkHiIm5yA==", + "license": "MIT", + "dependencies": { + "@babel/helper-module-transforms": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-validator-identifier": "^7.27.1", + "@babel/traverse": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-umd": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.27.1.tgz", + "integrity": "sha512-iQBE/xC5BV1OxJbp6WG7jq9IWiD+xxlZhLrdwpPkTX3ydmXdvoCpyfJN7acaIBZaOqTfr76pgzqBJflNbeRK+w==", + "license": "MIT", + "dependencies": { + "@babel/helper-module-transforms": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-named-capturing-groups-regex": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.27.1.tgz", + "integrity": "sha512-SstR5JYy8ddZvD6MhV0tM/j16Qds4mIpJTOd1Yu9J9pJjH93bxHECF7pgtc28XvkzTD6Pxcm/0Z73Hvk7kb3Ng==", + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-transform-new-target": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.27.1.tgz", + "integrity": "sha512-f6PiYeqXQ05lYq3TIfIDu/MtliKUbNwkGApPUvyo6+tc7uaR4cPjPe7DFPr15Uyycg2lZU6btZ575CuQoYh7MQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-nullish-coalescing-operator": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-nullish-coalescing-operator/-/plugin-transform-nullish-coalescing-operator-7.27.1.tgz", + "integrity": "sha512-aGZh6xMo6q9vq1JGcw58lZ1Z0+i0xB2x0XaauNIUXd6O1xXc3RwoWEBlsTQrY4KQ9Jf0s5rgD6SiNkaUdJegTA==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-numeric-separator": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-numeric-separator/-/plugin-transform-numeric-separator-7.27.1.tgz", + "integrity": "sha512-fdPKAcujuvEChxDBJ5c+0BTaS6revLV7CJL08e4m3de8qJfNIuCc2nc7XJYOjBoTMJeqSmwXJ0ypE14RCjLwaw==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-object-rest-spread": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-rest-spread/-/plugin-transform-object-rest-spread-7.27.1.tgz", + "integrity": "sha512-/sSliVc9gHE20/7D5qsdGlq7RG5NCDTWsAhyqzGuq174EtWJoGzIu1BQ7G56eDsTcy1jseBZwv50olSdXOlGuA==", + "license": "MIT", + "dependencies": { + "@babel/helper-compilation-targets": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/plugin-transform-parameters": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-object-super": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.27.1.tgz", + "integrity": "sha512-SFy8S9plRPbIcxlJ8A6mT/CxFdJx/c04JEctz4jf8YZaVS2px34j7NXRrlGlHkN/M2gnpL37ZpGRGVFLd3l8Ng==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-replace-supers": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-optional-catch-binding": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-catch-binding/-/plugin-transform-optional-catch-binding-7.27.1.tgz", + "integrity": "sha512-txEAEKzYrHEX4xSZN4kJ+OfKXFVSWKB2ZxM9dpcE3wT7smwkNmXo5ORRlVzMVdJbD+Q8ILTgSD7959uj+3Dm3Q==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-optional-chaining": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-optional-chaining/-/plugin-transform-optional-chaining-7.27.1.tgz", + "integrity": "sha512-BQmKPPIuc8EkZgNKsv0X4bPmOoayeu4F1YCwx2/CfmDSXDbp7GnzlUH+/ul5VGfRg1AoFPsrIThlEBj2xb4CAg==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-private-methods": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-methods/-/plugin-transform-private-methods-7.27.1.tgz", + "integrity": "sha512-10FVt+X55AjRAYI9BrdISN9/AQWHqldOeZDUoLyif1Kn05a56xVBXb8ZouL8pZ9jem8QpXaOt8TS7RHUIS+GPA==", + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-private-property-in-object": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-private-property-in-object/-/plugin-transform-private-property-in-object-7.27.1.tgz", + "integrity": "sha512-5J+IhqTi1XPa0DXF83jYOaARrX+41gOewWbkPyjMNRDqgOCqdffGh8L3f/Ek5utaEBZExjSAzcyjmV9SSAWObQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.27.1", + "@babel/helper-create-class-features-plugin": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-property-literals": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.27.1.tgz", + "integrity": "sha512-oThy3BCuCha8kDZ8ZkgOg2exvPYUlprMukKQXI1r1pJ47NCvxfkEy8vK+r/hT9nF0Aa4H1WUPZZjHTFtAhGfmQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-constant-elements": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-constant-elements/-/plugin-transform-react-constant-elements-7.27.1.tgz", + "integrity": "sha512-edoidOjl/ZxvYo4lSBOQGDSyToYVkTAwyVoa2tkuYTSmjrB1+uAedoL5iROVLXkxH+vRgA7uP4tMg2pUJpZ3Ug==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.27.1.tgz", + "integrity": "sha512-2KH4LWGSrJIkVf5tSiBFYuXDAoWRq2MMwgivCf+93dd0GQi8RXLjKA/0EvRnVV5G0hrHczsquXuD01L8s6dmBw==", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.27.1", + "@babel/helper-module-imports": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/plugin-syntax-jsx": "^7.27.1", + "@babel/types": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-development": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-development/-/plugin-transform-react-jsx-development-7.27.1.tgz", + "integrity": "sha512-ykDdF5yI4f1WrAolLqeF3hmYU12j9ntLQl/AOG1HAS21jxyg1Q0/J/tpREuYLfatGdGmXp/3yS0ZA76kOlVq9Q==", + "license": "MIT", + "dependencies": { + "@babel/plugin-transform-react-jsx": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-pure-annotations": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-pure-annotations/-/plugin-transform-react-pure-annotations-7.27.1.tgz", + "integrity": "sha512-JfuinvDOsD9FVMTHpzA/pBLisxpv1aSf+OIV8lgH3MuWrks19R27e6a6DipIg4aX1Zm9Wpb04p8wljfKrVSnPA==", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-regexp-modifiers": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regexp-modifiers/-/plugin-transform-regexp-modifiers-7.27.1.tgz", + "integrity": "sha512-TtEciroaiODtXvLZv4rmfMhkCv8jx3wgKpL68PuiPh2M4fvz5jhsA7697N1gMvkvr/JTF13DrFYyEbY9U7cVPA==", + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-transform-reserved-words": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.27.1.tgz", + "integrity": "sha512-V2ABPHIJX4kC7HegLkYoDpfg9PVmuWy/i6vUM5eGK22bx4YVFD3M5F0QQnWQoDs6AGsUWTVOopBiMFQgHaSkVw==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "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==", + "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", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-runtime/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/plugin-transform-shorthand-properties": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.27.1.tgz", + "integrity": "sha512-N/wH1vcn4oYawbJ13Y/FxcQrWk63jhfNa7jef0ih7PHSIHX2LB7GWE1rkPrOnka9kwMxb6hMl19p7lidA+EHmQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-spread": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.27.1.tgz", + "integrity": "sha512-kpb3HUqaILBJcRFVhFUs6Trdd4mkrzcGXss+6/mxUd273PfbWqSDHRzMT2234gIg2QYfAjvXLSquP1xECSg09Q==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-sticky-regex": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.27.1.tgz", + "integrity": "sha512-lhInBO5bi/Kowe2/aLdBAawijx+q1pQzicSgnkB6dUPc1+RC8QmJHKf2OjvU+NZWitguJHEaEmbV6VWEouT58g==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-template-literals": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.27.1.tgz", + "integrity": "sha512-fBJKiV7F2DxZUkg5EtHKXQdbsbURW3DZKQUWphDum0uRP6eHGGa/He9mc0mypL680pb+e/lDIthRohlv8NCHkg==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-typeof-symbol": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.27.1.tgz", + "integrity": "sha512-RiSILC+nRJM7FY5srIyc4/fGIwUhyDuuBSdWn4y6yT6gm652DpCHZjIipgn6B7MQ1ITOUnAKWixEUjQRIBIcLw==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.27.1", + "@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", + "@babel/plugin-syntax-typescript": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-escapes": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.27.1.tgz", + "integrity": "sha512-Ysg4v6AmF26k9vpfFuTZg8HRfVWzsh1kVfowA23y9j/Gu6dOuahdUVhkLqpObp3JIv27MLSii6noRnuKN8H0Mg==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-property-regex": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-property-regex/-/plugin-transform-unicode-property-regex-7.27.1.tgz", + "integrity": "sha512-uW20S39PnaTImxp39O5qFlHLS9LJEmANjMG7SxIhap8rCHqu0Ik+tLEPX5DKmHn6CsWQ7j3lix2tFOa5YtL12Q==", + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-regex": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.27.1.tgz", + "integrity": "sha512-xvINq24TRojDuyt6JGtHmkVkrfVV3FPT16uytxImLeBZqW3/H52yN+kM1MGuyPkIQxrzKwPHs5U/MP3qKyzkGw==", + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-sets-regex": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-sets-regex/-/plugin-transform-unicode-sets-regex-7.27.1.tgz", + "integrity": "sha512-EtkOujbc4cgvb0mlpQefi4NTPBzhSIevblFevACNLUspmrALgmEBdL/XfnyyITfd8fKBZrZys92zOWcik7j9Tw==", + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/preset-env": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.27.1.tgz", + "integrity": "sha512-TZ5USxFpLgKDpdEt8YWBR7p6g+bZo6sHaXLqP2BY/U0acaoI8FTVflcYCr/v94twM1C5IWFdZ/hscq9WjUeLXA==", + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.27.1", + "@babel/helper-compilation-targets": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-validator-option": "^7.27.1", + "@babel/plugin-bugfix-firefox-class-in-computed-class-key": "^7.27.1", + "@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-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-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-class-properties": "^7.27.1", + "@babel/plugin-transform-class-static-block": "^7.27.1", + "@babel/plugin-transform-classes": "^7.27.1", + "@babel/plugin-transform-computed-properties": "^7.27.1", + "@babel/plugin-transform-destructuring": "^7.27.1", + "@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-exponentiation-operator": "^7.27.1", + "@babel/plugin-transform-export-namespace-from": "^7.27.1", + "@babel/plugin-transform-for-of": "^7.27.1", + "@babel/plugin-transform-function-name": "^7.27.1", + "@babel/plugin-transform-json-strings": "^7.27.1", + "@babel/plugin-transform-literals": "^7.27.1", + "@babel/plugin-transform-logical-assignment-operators": "^7.27.1", + "@babel/plugin-transform-member-expression-literals": "^7.27.1", + "@babel/plugin-transform-modules-amd": "^7.27.1", + "@babel/plugin-transform-modules-commonjs": "^7.27.1", + "@babel/plugin-transform-modules-systemjs": "^7.27.1", + "@babel/plugin-transform-modules-umd": "^7.27.1", + "@babel/plugin-transform-named-capturing-groups-regex": "^7.27.1", + "@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.1", + "@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-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-regexp-modifiers": "^7.27.1", + "@babel/plugin-transform-reserved-words": "^7.27.1", + "@babel/plugin-transform-shorthand-properties": "^7.27.1", + "@babel/plugin-transform-spread": "^7.27.1", + "@babel/plugin-transform-sticky-regex": "^7.27.1", + "@babel/plugin-transform-template-literals": "^7.27.1", + "@babel/plugin-transform-typeof-symbol": "^7.27.1", + "@babel/plugin-transform-unicode-escapes": "^7.27.1", + "@babel/plugin-transform-unicode-property-regex": "^7.27.1", + "@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", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/preset-env/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/preset-modules": { + "version": "0.1.6-no-external-plugins", + "resolved": "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.6-no-external-plugins.tgz", + "integrity": "sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.0.0", + "@babel/types": "^7.4.4", + "esutils": "^2.0.2" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/@babel/preset-react": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/preset-react/-/preset-react-7.27.1.tgz", + "integrity": "sha512-oJHWh2gLhU9dW9HHr42q0cI0/iHHXTLGe39qvpAZZzagHy0MzYLCnCVV0symeRvzmjHyVU7mw2K06E6u/JwbhA==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-validator-option": "^7.27.1", + "@babel/plugin-transform-react-display-name": "^7.27.1", + "@babel/plugin-transform-react-jsx": "^7.27.1", + "@babel/plugin-transform-react-jsx-development": "^7.27.1", + "@babel/plugin-transform-react-pure-annotations": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/preset-typescript": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/preset-typescript/-/preset-typescript-7.27.1.tgz", + "integrity": "sha512-l7WfQfX0WK4M0v2RudjuQK4u99BS6yLHYEmdtVPP7lKV013zr9DygFuWNlnbvQ9LR+LS0Egz/XAvGx5U9MX0fQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/helper-validator-option": "^7.27.1", + "@babel/plugin-syntax-jsx": "^7.27.1", + "@babel/plugin-transform-modules-commonjs": "^7.27.1", + "@babel/plugin-transform-typescript": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/runtime": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.27.1.tgz", + "integrity": "sha512-1x3D2xEk2fRo3PAhwQwu5UubzgiVWSXTBfWpVd2Mx2AzRqJuDJCsgaDVZ7HB5iGzDW1Hl1sWN2mFyKjmR9uAog==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/template": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.1.tgz", + "integrity": "sha512-Fyo3ghWMqkHHpHQCoBs2VnYjR4iWFFjguTDEqA5WgZDOrFesVjMhMM2FSqTKSoUSDO1VQtavj8NFpdRBEvJTtg==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.27.1", + "@babel/parser": "^7.27.1", + "@babel/types": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "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==", + "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" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse/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==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/types": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.27.1.tgz", + "integrity": "sha512-+EzkxvLNfiUeKMgy/3luqfsCWFRXLb7U6wNQTk60tovuckwB15B191tJWvpp4HjiQWdJkCxO3Wbvc6jlk3Xb2Q==", + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@bcoe/v8-coverage": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/@bcoe/v8-coverage/-/v8-coverage-0.2.3.tgz", + "integrity": "sha512-0hYQ8SB4Db5zvZB4axdMHGwEaQjkZzFjQiN9LVYvIFB2nSUHW9tYpxWriPrWDASIxiaXax83REcLxuSdnGPZtw==", + "license": "MIT" + }, + "node_modules/@braintree/sanitize-url": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/@braintree/sanitize-url/-/sanitize-url-7.1.1.tgz", + "integrity": "sha512-i1L7noDNxtFyL5DmZafWy1wRVhGehQmzZaz1HiN5e7iylJMSZR7ekOV7NsIqa5qBldlLrsKv4HbgFUVlQrz8Mw==", + "license": "MIT" + }, + "node_modules/@chevrotain/cst-dts-gen": { + "version": "11.0.3", + "resolved": "https://registry.npmjs.org/@chevrotain/cst-dts-gen/-/cst-dts-gen-11.0.3.tgz", + "integrity": "sha512-BvIKpRLeS/8UbfxXxgC33xOumsacaeCKAjAeLyOn7Pcp95HiRbrpl14S+9vaZLolnbssPIUuiUd8IvgkRyt6NQ==", + "license": "Apache-2.0", + "dependencies": { + "@chevrotain/gast": "11.0.3", + "@chevrotain/types": "11.0.3", + "lodash-es": "4.17.21" + } + }, + "node_modules/@chevrotain/gast": { + "version": "11.0.3", + "resolved": "https://registry.npmjs.org/@chevrotain/gast/-/gast-11.0.3.tgz", + "integrity": "sha512-+qNfcoNk70PyS/uxmj3li5NiECO+2YKZZQMbmjTqRI3Qchu8Hig/Q9vgkHpI3alNjr7M+a2St5pw5w5F6NL5/Q==", + "license": "Apache-2.0", + "dependencies": { + "@chevrotain/types": "11.0.3", + "lodash-es": "4.17.21" + } + }, + "node_modules/@chevrotain/regexp-to-ast": { + "version": "11.0.3", + "resolved": "https://registry.npmjs.org/@chevrotain/regexp-to-ast/-/regexp-to-ast-11.0.3.tgz", + "integrity": "sha512-1fMHaBZxLFvWI067AVbGJav1eRY7N8DDvYCTwGBiE/ytKBgP8azTdgyrKyWZ9Mfh09eHWb5PgTSO8wi7U824RA==", + "license": "Apache-2.0" + }, + "node_modules/@chevrotain/types": { + "version": "11.0.3", + "resolved": "https://registry.npmjs.org/@chevrotain/types/-/types-11.0.3.tgz", + "integrity": "sha512-gsiM3G8b58kZC2HaWR50gu6Y1440cHiJ+i3JUvcp/35JchYejb2+5MVeJK0iKThYpAa/P2PYFV4hoi44HD+aHQ==", + "license": "Apache-2.0" + }, + "node_modules/@chevrotain/utils": { + "version": "11.0.3", + "resolved": "https://registry.npmjs.org/@chevrotain/utils/-/utils-11.0.3.tgz", + "integrity": "sha512-YslZMgtJUyuMbZ+aKvfF3x1f5liK4mWNxghFRv7jqRR9C3R3fAOGTTKvxXDa2Y1s9zSbcpuO0cAxDYsc9SrXoQ==", + "license": "Apache-2.0" + }, + "node_modules/@csstools/normalize.css": { + "version": "12.1.1", + "resolved": "https://registry.npmjs.org/@csstools/normalize.css/-/normalize.css-12.1.1.tgz", + "integrity": "sha512-YAYeJ+Xqh7fUou1d1j9XHl44BmsuThiTr4iNrgCQ3J27IbhXsxXDGZ1cXv8Qvs99d4rBbLiSKy3+WZiet32PcQ==", + "license": "CC0-1.0" + }, + "node_modules/@csstools/postcss-cascade-layers": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@csstools/postcss-cascade-layers/-/postcss-cascade-layers-1.1.1.tgz", + "integrity": "sha512-+KdYrpKC5TgomQr2DlZF4lDEpHcoxnj5IGddYYfBWJAKfj1JtuHUIqMa+E1pJJ+z3kvDViWMqyqPlG4Ja7amQA==", + "license": "CC0-1.0", + "dependencies": { + "@csstools/selector-specificity": "^2.0.2", + "postcss-selector-parser": "^6.0.10" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-color-function": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@csstools/postcss-color-function/-/postcss-color-function-1.1.1.tgz", + "integrity": "sha512-Bc0f62WmHdtRDjf5f3e2STwRAl89N2CLb+9iAwzrv4L2hncrbDwnQD9PCq0gtAt7pOI2leIV08HIBUd4jxD8cw==", + "license": "CC0-1.0", + "dependencies": { + "@csstools/postcss-progressive-custom-properties": "^1.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-font-format-keywords": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@csstools/postcss-font-format-keywords/-/postcss-font-format-keywords-1.0.1.tgz", + "integrity": "sha512-ZgrlzuUAjXIOc2JueK0X5sZDjCtgimVp/O5CEqTcs5ShWBa6smhWYbS0x5cVc/+rycTDbjjzoP0KTDnUneZGOg==", + "license": "CC0-1.0", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-hwb-function": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@csstools/postcss-hwb-function/-/postcss-hwb-function-1.0.2.tgz", + "integrity": "sha512-YHdEru4o3Rsbjmu6vHy4UKOXZD+Rn2zmkAmLRfPet6+Jz4Ojw8cbWxe1n42VaXQhD3CQUXXTooIy8OkVbUcL+w==", + "license": "CC0-1.0", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-ic-unit": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@csstools/postcss-ic-unit/-/postcss-ic-unit-1.0.1.tgz", + "integrity": "sha512-Ot1rcwRAaRHNKC9tAqoqNZhjdYBzKk1POgWfhN4uCOE47ebGcLRqXjKkApVDpjifL6u2/55ekkpnFcp+s/OZUw==", + "license": "CC0-1.0", + "dependencies": { + "@csstools/postcss-progressive-custom-properties": "^1.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-is-pseudo-class": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/@csstools/postcss-is-pseudo-class/-/postcss-is-pseudo-class-2.0.7.tgz", + "integrity": "sha512-7JPeVVZHd+jxYdULl87lvjgvWldYu+Bc62s9vD/ED6/QTGjy0jy0US/f6BG53sVMTBJ1lzKZFpYmofBN9eaRiA==", + "license": "CC0-1.0", + "dependencies": { + "@csstools/selector-specificity": "^2.0.0", + "postcss-selector-parser": "^6.0.10" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-nested-calc": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@csstools/postcss-nested-calc/-/postcss-nested-calc-1.0.0.tgz", + "integrity": "sha512-JCsQsw1wjYwv1bJmgjKSoZNvf7R6+wuHDAbi5f/7MbFhl2d/+v+TvBTU4BJH3G1X1H87dHl0mh6TfYogbT/dJQ==", + "license": "CC0-1.0", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-normalize-display-values": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@csstools/postcss-normalize-display-values/-/postcss-normalize-display-values-1.0.1.tgz", + "integrity": "sha512-jcOanIbv55OFKQ3sYeFD/T0Ti7AMXc9nM1hZWu8m/2722gOTxFg7xYu4RDLJLeZmPUVQlGzo4jhzvTUq3x4ZUw==", + "license": "CC0-1.0", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-oklab-function": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/@csstools/postcss-oklab-function/-/postcss-oklab-function-1.1.1.tgz", + "integrity": "sha512-nJpJgsdA3dA9y5pgyb/UfEzE7W5Ka7u0CX0/HIMVBNWzWemdcTH3XwANECU6anWv/ao4vVNLTMxhiPNZsTK6iA==", + "license": "CC0-1.0", + "dependencies": { + "@csstools/postcss-progressive-custom-properties": "^1.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-progressive-custom-properties": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@csstools/postcss-progressive-custom-properties/-/postcss-progressive-custom-properties-1.3.0.tgz", + "integrity": "sha512-ASA9W1aIy5ygskZYuWams4BzafD12ULvSypmaLJT2jvQ8G0M3I8PRQhC0h7mG0Z3LI05+agZjqSR9+K9yaQQjA==", + "license": "CC0-1.0", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.3" + } + }, + "node_modules/@csstools/postcss-stepped-value-functions": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@csstools/postcss-stepped-value-functions/-/postcss-stepped-value-functions-1.0.1.tgz", + "integrity": "sha512-dz0LNoo3ijpTOQqEJLY8nyaapl6umbmDcgj4AD0lgVQ572b2eqA1iGZYTTWhrcrHztWDDRAX2DGYyw2VBjvCvQ==", + "license": "CC0-1.0", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-text-decoration-shorthand": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/@csstools/postcss-text-decoration-shorthand/-/postcss-text-decoration-shorthand-1.0.0.tgz", + "integrity": "sha512-c1XwKJ2eMIWrzQenN0XbcfzckOLLJiczqy+YvfGmzoVXd7pT9FfObiSEfzs84bpE/VqfpEuAZ9tCRbZkZxxbdw==", + "license": "CC0-1.0", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-trigonometric-functions": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@csstools/postcss-trigonometric-functions/-/postcss-trigonometric-functions-1.0.2.tgz", + "integrity": "sha512-woKaLO///4bb+zZC2s80l+7cm07M7268MsyG3M0ActXXEFi6SuhvriQYcb58iiKGbjwwIU7n45iRLEHypB47Og==", + "license": "CC0-1.0", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/postcss-unset-value": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@csstools/postcss-unset-value/-/postcss-unset-value-1.0.2.tgz", + "integrity": "sha512-c8J4roPBILnelAsdLr4XOAR/GsTm0GJi4XpcfvoWk3U6KiTCqiFYc63KhRMQQX35jYMp4Ao8Ij9+IZRgMfJp1g==", + "license": "CC0-1.0", + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/@csstools/selector-specificity": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/@csstools/selector-specificity/-/selector-specificity-2.2.0.tgz", + "integrity": "sha512-+OJ9konv95ClSTOJCmMZqpd5+YGsB2S+x6w3E1oaM8UuR5j8nTNHYSz8c9BEPGDOCMQYIEEGlVPj/VY64iTbGw==", + "license": "CC0-1.0", + "engines": { + "node": "^14 || ^16 || >=18" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss-selector-parser": "^6.0.10" + } + }, + "node_modules/@emotion/is-prop-valid": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/@emotion/is-prop-valid/-/is-prop-valid-1.2.2.tgz", + "integrity": "sha512-uNsoYd37AFmaCdXlg6EYD1KaPOaRWRByMCYzbKUX4+hhMfrxdVSelShywL4JVaAeM/eHUOSprYBQls+/neX3pw==", + "license": "MIT", + "dependencies": { + "@emotion/memoize": "^0.8.1" + } + }, + "node_modules/@emotion/memoize": { + "version": "0.8.1", + "resolved": "https://registry.npmjs.org/@emotion/memoize/-/memoize-0.8.1.tgz", + "integrity": "sha512-W2P2c/VRW1/1tLox0mVUalvnWXxavmv/Oum2aPsRcoDJuob75FC3Y8FbpfLwUegRcxINtGUMPq0tFCvYNTBXNA==", + "license": "MIT" + }, + "node_modules/@emotion/unitless": { + "version": "0.8.1", + "resolved": "https://registry.npmjs.org/@emotion/unitless/-/unitless-0.8.1.tgz", + "integrity": "sha512-KOEGMu6dmJZtpadb476IsZBclKvILjopjUii3V+7MnXIQCYh8W3NgNcgwo21n9LXZX6EDIKvqfjYxXebDwxKmQ==", + "license": "MIT" + }, + "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==", + "license": "MIT", + "dependencies": { + "eslint-visitor-keys": "^3.4.3" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" + } + }, + "node_modules/@eslint-community/regexpp": { + "version": "4.12.1", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz", + "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==", + "license": "MIT", + "engines": { + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + } + }, + "node_modules/@eslint/eslintrc": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.4.tgz", + "integrity": "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==", + "license": "MIT", + "dependencies": { + "ajv": "^6.12.4", + "debug": "^4.3.2", + "espree": "^9.6.0", + "globals": "^13.19.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.0", + "minimatch": "^3.1.2", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint/eslintrc/node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "license": "Python-2.0" + }, + "node_modules/@eslint/eslintrc/node_modules/globals": { + "version": "13.24.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz", + "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==", + "license": "MIT", + "dependencies": { + "type-fest": "^0.20.2" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@eslint/eslintrc/node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/@eslint/eslintrc/node_modules/type-fest": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@eslint/js": { + "version": "8.57.1", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.57.1.tgz", + "integrity": "sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q==", + "license": "MIT", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + } + }, + "node_modules/@fortawesome/fontawesome-common-types": { + "version": "6.7.2", + "resolved": "https://registry.npmjs.org/@fortawesome/fontawesome-common-types/-/fontawesome-common-types-6.7.2.tgz", + "integrity": "sha512-Zs+YeHUC5fkt7Mg1l6XTniei3k4bwG/yo3iFUtZWd/pMx9g3fdvkSK9E0FOC+++phXOka78uJcYb8JaFkW52Xg==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/@fortawesome/fontawesome-svg-core": { + "version": "6.7.2", + "resolved": "https://registry.npmjs.org/@fortawesome/fontawesome-svg-core/-/fontawesome-svg-core-6.7.2.tgz", + "integrity": "sha512-yxtOBWDrdi5DD5o1pmVdq3WMCvnobT0LU6R8RyyVXPvFRd2o79/0NCuQoCjNTeZz9EzA9xS3JxNWfv54RIHFEA==", + "license": "MIT", + "dependencies": { + "@fortawesome/fontawesome-common-types": "6.7.2" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/@fortawesome/free-brands-svg-icons": { + "version": "6.7.2", + "resolved": "https://registry.npmjs.org/@fortawesome/free-brands-svg-icons/-/free-brands-svg-icons-6.7.2.tgz", + "integrity": "sha512-zu0evbcRTgjKfrr77/2XX+bU+kuGfjm0LbajJHVIgBWNIDzrhpRxiCPNT8DW5AdmSsq7Mcf9D1bH0aSeSUSM+Q==", + "license": "(CC-BY-4.0 AND MIT)", + "dependencies": { + "@fortawesome/fontawesome-common-types": "6.7.2" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/@fortawesome/free-regular-svg-icons": { + "version": "6.7.2", + "resolved": "https://registry.npmjs.org/@fortawesome/free-regular-svg-icons/-/free-regular-svg-icons-6.7.2.tgz", + "integrity": "sha512-7Z/ur0gvCMW8G93dXIQOkQqHo2M5HLhYrRVC0//fakJXxcF1VmMPsxnG6Ee8qEylA8b8Q3peQXWMNZ62lYF28g==", + "license": "(CC-BY-4.0 AND MIT)", + "dependencies": { + "@fortawesome/fontawesome-common-types": "6.7.2" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/@fortawesome/free-solid-svg-icons": { + "version": "6.7.2", + "resolved": "https://registry.npmjs.org/@fortawesome/free-solid-svg-icons/-/free-solid-svg-icons-6.7.2.tgz", + "integrity": "sha512-GsBrnOzU8uj0LECDfD5zomZJIjrPhIlWU82AHwa2s40FKH+kcxQaBvBo3Z4TxyZHIyX8XTDxsyA33/Vx9eFuQA==", + "license": "(CC-BY-4.0 AND MIT)", + "dependencies": { + "@fortawesome/fontawesome-common-types": "6.7.2" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/@fortawesome/react-fontawesome": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/@fortawesome/react-fontawesome/-/react-fontawesome-0.2.2.tgz", + "integrity": "sha512-EnkrprPNqI6SXJl//m29hpaNzOp1bruISWaOiRtkMi/xSvHJlzc2j2JAYS7egxt/EbjSNV/k6Xy0AQI6vB2+1g==", + "license": "MIT", + "dependencies": { + "prop-types": "^15.8.1" + }, + "peerDependencies": { + "@fortawesome/fontawesome-svg-core": "~1 || ~6", + "react": ">=16.3" + } + }, + "node_modules/@humanwhocodes/config-array": { + "version": "0.13.0", + "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.13.0.tgz", + "integrity": "sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw==", + "deprecated": "Use @eslint/config-array instead", + "license": "Apache-2.0", + "dependencies": { + "@humanwhocodes/object-schema": "^2.0.3", + "debug": "^4.3.1", + "minimatch": "^3.0.5" + }, + "engines": { + "node": ">=10.10.0" + } + }, + "node_modules/@humanwhocodes/module-importer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz", + "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==", + "license": "Apache-2.0", + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@humanwhocodes/object-schema": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.3.tgz", + "integrity": "sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA==", + "deprecated": "Use @eslint/object-schema instead", + "license": "BSD-3-Clause" + }, + "node_modules/@iconify/types": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@iconify/types/-/types-2.0.0.tgz", + "integrity": "sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg==", + "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==", + "license": "MIT", + "dependencies": { + "@antfu/install-pkg": "^1.0.0", + "@antfu/utils": "^8.1.0", + "@iconify/types": "^2.0.0", + "debug": "^4.4.0", + "globals": "^15.14.0", + "kolorist": "^1.8.0", + "local-pkg": "^1.0.0", + "mlly": "^1.7.4" + } + }, + "node_modules/@isaacs/cliui": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz", + "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==", + "license": "ISC", + "dependencies": { + "string-width": "^5.1.2", + "string-width-cjs": "npm:string-width@^4.2.0", + "strip-ansi": "^7.0.1", + "strip-ansi-cjs": "npm:strip-ansi@^6.0.1", + "wrap-ansi": "^8.1.0", + "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "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==", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "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==", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/@isaacs/cliui/node_modules/string-width": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz", + "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==", + "license": "MIT", + "dependencies": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/@isaacs/cliui/node_modules/wrap-ansi": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz", + "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^6.1.0", + "string-width": "^5.0.1", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/@istanbuljs/load-nyc-config": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@istanbuljs/load-nyc-config/-/load-nyc-config-1.1.0.tgz", + "integrity": "sha512-VjeHSlIzpv/NyD3N0YuHfXOPDIixcA1q2ZV98wsMqcYlPmv2n3Yb2lYP9XMElnaFVXg5A7YLTeLu6V84uQDjmQ==", + "license": "ISC", + "dependencies": { + "camelcase": "^5.3.1", + "find-up": "^4.1.0", + "get-package-type": "^0.1.0", + "js-yaml": "^3.13.1", + "resolve-from": "^5.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@istanbuljs/load-nyc-config/node_modules/camelcase": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz", + "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/@istanbuljs/schema": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/@istanbuljs/schema/-/schema-0.1.3.tgz", + "integrity": "sha512-ZXRY4jNvVgSVQ8DL3LTcakaAtXwTVUxE81hslsyD2AtoXW/wVob10HkOJ1X/pAlcI7D+2YoZKg5do8G/w6RYgA==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/@jest/console": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/console/-/console-27.5.1.tgz", + "integrity": "sha512-kZ/tNpS3NXn0mlXXXPNuDZnb4c0oZ20r4K5eemM2k30ZC3G0T02nXUvyhf5YdbXWHPEJLc9qGLxEZ216MdL+Zg==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "jest-message-util": "^27.5.1", + "jest-util": "^27.5.1", + "slash": "^3.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/console/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/console/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/@jest/console/node_modules/jest-message-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-27.5.1.tgz", + "integrity": "sha512-rMyFe1+jnyAAf+NHwTclDz0eAaLkVDdKVHHBFWsBWHnnh5YeJMNWWsv7AbFYXfK3oTqvL7VTWkhNLu1jX24D+g==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^27.5.1", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^27.5.1", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/console/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/core": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/core/-/core-27.5.1.tgz", + "integrity": "sha512-AK6/UTrvQD0Cd24NSqmIA6rKsu0tKIxfiCducZvqxYdmMisOYAsdItspT+fQDQYARPf8XgjAFZi0ogW2agH5nQ==", + "license": "MIT", + "dependencies": { + "@jest/console": "^27.5.1", + "@jest/reporters": "^27.5.1", + "@jest/test-result": "^27.5.1", + "@jest/transform": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "emittery": "^0.8.1", + "exit": "^0.1.2", + "graceful-fs": "^4.2.9", + "jest-changed-files": "^27.5.1", + "jest-config": "^27.5.1", + "jest-haste-map": "^27.5.1", + "jest-message-util": "^27.5.1", + "jest-regex-util": "^27.5.1", + "jest-resolve": "^27.5.1", + "jest-resolve-dependencies": "^27.5.1", + "jest-runner": "^27.5.1", + "jest-runtime": "^27.5.1", + "jest-snapshot": "^27.5.1", + "jest-util": "^27.5.1", + "jest-validate": "^27.5.1", + "jest-watcher": "^27.5.1", + "micromatch": "^4.0.4", + "rimraf": "^3.0.0", + "slash": "^3.0.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + } + }, + "node_modules/@jest/core/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/core/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/@jest/core/node_modules/jest-message-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-27.5.1.tgz", + "integrity": "sha512-rMyFe1+jnyAAf+NHwTclDz0eAaLkVDdKVHHBFWsBWHnnh5YeJMNWWsv7AbFYXfK3oTqvL7VTWkhNLu1jX24D+g==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^27.5.1", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^27.5.1", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/core/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/environment": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/environment/-/environment-27.5.1.tgz", + "integrity": "sha512-/WQjhPJe3/ghaol/4Bq480JKXV/Rfw8nQdN7f41fM8VDHLcxKXou6QyXAh3EFr9/bVG3x74z1NWDkP87EiY8gA==", + "license": "MIT", + "dependencies": { + "@jest/fake-timers": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "jest-mock": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/environment/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/environment/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/@jest/expect-utils": { + "version": "29.7.0", + "resolved": "https://registry.npmjs.org/@jest/expect-utils/-/expect-utils-29.7.0.tgz", + "integrity": "sha512-GlsNBWiFQFCVi9QVSx7f5AgMeLxe9YCCs5PuP2O2LdjDAA8Jh9eX7lA1Jq/xdXw3Wb3hyvlFNfZIfcRetSzYcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "jest-get-type": "^29.6.3" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/fake-timers": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/fake-timers/-/fake-timers-27.5.1.tgz", + "integrity": "sha512-/aPowoolwa07k7/oM3aASneNeBGCmGQsc3ugN4u6s4C/+s5M64MFo/+djTdiwcbQlRfFElGuDXWzaWj6QgKObQ==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@sinonjs/fake-timers": "^8.0.1", + "@types/node": "*", + "jest-message-util": "^27.5.1", + "jest-mock": "^27.5.1", + "jest-util": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/fake-timers/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/fake-timers/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/@jest/fake-timers/node_modules/jest-message-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-27.5.1.tgz", + "integrity": "sha512-rMyFe1+jnyAAf+NHwTclDz0eAaLkVDdKVHHBFWsBWHnnh5YeJMNWWsv7AbFYXfK3oTqvL7VTWkhNLu1jX24D+g==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^27.5.1", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^27.5.1", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/fake-timers/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/globals": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/globals/-/globals-27.5.1.tgz", + "integrity": "sha512-ZEJNB41OBQQgGzgyInAv0UUfDDj3upmHydjieSxFvTRuZElrx7tXg/uVQ5hYVEwiXs3+aMsAeEc9X7xiSKCm4Q==", + "license": "MIT", + "dependencies": { + "@jest/environment": "^27.5.1", + "@jest/types": "^27.5.1", + "expect": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/globals/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/globals/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/@jest/globals/node_modules/diff-sequences": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-27.5.1.tgz", + "integrity": "sha512-k1gCAXAsNgLwEL+Y8Wvl+M6oEFj5bgazfZULpS5CneoPPXRaCCW7dm+q21Ky2VEE5X+VeRDBVg1Pcvvsr4TtNQ==", + "license": "MIT", + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/globals/node_modules/expect": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/expect/-/expect-27.5.1.tgz", + "integrity": "sha512-E1q5hSUG2AmYQwQJ041nvgpkODHQvB+RKlB4IYdru6uJsyFTRyZAP463M+1lINorwbqAmUggi6+WwkD8lCS/Dw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "jest-get-type": "^27.5.1", + "jest-matcher-utils": "^27.5.1", + "jest-message-util": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/globals/node_modules/jest-diff": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-27.5.1.tgz", + "integrity": "sha512-m0NvkX55LDt9T4mctTEgnZk3fmEg3NRYutvMPWM/0iPnkFj2wIeF45O1718cMSOFO1vINkqmxqD8vE37uTEbqw==", + "license": "MIT", + "dependencies": { + "chalk": "^4.0.0", + "diff-sequences": "^27.5.1", + "jest-get-type": "^27.5.1", + "pretty-format": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/globals/node_modules/jest-get-type": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-27.5.1.tgz", + "integrity": "sha512-2KY95ksYSaK7DMBWQn6dQz3kqAf3BB64y2udeG+hv4KfSOb9qwcYQstTJc1KCbsix+wLZWZYN8t7nwX3GOBLRw==", + "license": "MIT", + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/globals/node_modules/jest-matcher-utils": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-27.5.1.tgz", + "integrity": "sha512-z2uTx/T6LBaCoNWNFWwChLBKYxTMcGBRjAt+2SbP929/Fflb9aa5LGma654Rz8z9HLxsrUaYzxE9T/EFIL/PAw==", + "license": "MIT", + "dependencies": { + "chalk": "^4.0.0", + "jest-diff": "^27.5.1", + "jest-get-type": "^27.5.1", + "pretty-format": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/globals/node_modules/jest-message-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-27.5.1.tgz", + "integrity": "sha512-rMyFe1+jnyAAf+NHwTclDz0eAaLkVDdKVHHBFWsBWHnnh5YeJMNWWsv7AbFYXfK3oTqvL7VTWkhNLu1jX24D+g==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^27.5.1", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^27.5.1", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/reporters": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/reporters/-/reporters-27.5.1.tgz", + "integrity": "sha512-cPXh9hWIlVJMQkVk84aIvXuBB4uQQmFqZiacloFuGiP3ah1sbCxCosidXFDfqG8+6fO1oR2dTJTlsOy4VFmUfw==", + "license": "MIT", + "dependencies": { + "@bcoe/v8-coverage": "^0.2.3", + "@jest/console": "^27.5.1", + "@jest/test-result": "^27.5.1", + "@jest/transform": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "collect-v8-coverage": "^1.0.0", + "exit": "^0.1.2", + "glob": "^7.1.2", + "graceful-fs": "^4.2.9", + "istanbul-lib-coverage": "^3.0.0", + "istanbul-lib-instrument": "^5.1.0", + "istanbul-lib-report": "^3.0.0", + "istanbul-lib-source-maps": "^4.0.0", + "istanbul-reports": "^3.1.3", + "jest-haste-map": "^27.5.1", + "jest-resolve": "^27.5.1", + "jest-util": "^27.5.1", + "jest-worker": "^27.5.1", + "slash": "^3.0.0", + "source-map": "^0.6.0", + "string-length": "^4.0.1", + "terminal-link": "^2.0.0", + "v8-to-istanbul": "^8.1.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + } + }, + "node_modules/@jest/reporters/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/reporters/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/@jest/reporters/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/reporters/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/@jest/schemas": { + "version": "29.6.3", + "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-29.6.3.tgz", + "integrity": "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@sinclair/typebox": "^0.27.8" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/source-map": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/source-map/-/source-map-27.5.1.tgz", + "integrity": "sha512-y9NIHUYF3PJRlHk98NdC/N1gl88BL08aQQgu4k4ZopQkCw9t9cV8mtl3TV8b/YCB8XaVTFrmUTAJvjsntDireg==", + "license": "MIT", + "dependencies": { + "callsites": "^3.0.0", + "graceful-fs": "^4.2.9", + "source-map": "^0.6.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/source-map/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/@jest/test-result": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/test-result/-/test-result-27.5.1.tgz", + "integrity": "sha512-EW35l2RYFUcUQxFJz5Cv5MTOxlJIQs4I7gxzi2zVU7PJhOwfYq1MdC5nhSmYjX1gmMmLPvB3sIaC+BkcHRBfag==", + "license": "MIT", + "dependencies": { + "@jest/console": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/istanbul-lib-coverage": "^2.0.0", + "collect-v8-coverage": "^1.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/test-result/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/test-result/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/@jest/test-sequencer": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/test-sequencer/-/test-sequencer-27.5.1.tgz", + "integrity": "sha512-LCheJF7WB2+9JuCS7VB/EmGIdQuhtqjRNI9A43idHv3E4KltCTsPsLxvdaubFHSYwY/fNjMWjl6vNRhDiN7vpQ==", + "license": "MIT", + "dependencies": { + "@jest/test-result": "^27.5.1", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^27.5.1", + "jest-runtime": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/transform": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/transform/-/transform-27.5.1.tgz", + "integrity": "sha512-ipON6WtYgl/1329g5AIJVbUuEh0wZVbdpGwC99Jw4LwuoBNS95MVphU6zOeD9pDkon+LLbFL7lOQRapbB8SCHw==", + "license": "MIT", + "dependencies": { + "@babel/core": "^7.1.0", + "@jest/types": "^27.5.1", + "babel-plugin-istanbul": "^6.1.1", + "chalk": "^4.0.0", + "convert-source-map": "^1.4.0", + "fast-json-stable-stringify": "^2.0.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^27.5.1", + "jest-regex-util": "^27.5.1", + "jest-util": "^27.5.1", + "micromatch": "^4.0.4", + "pirates": "^4.0.4", + "slash": "^3.0.0", + "source-map": "^0.6.1", + "write-file-atomic": "^3.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/transform/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/transform/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/@jest/transform/node_modules/convert-source-map": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", + "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==", + "license": "MIT" + }, + "node_modules/@jest/transform/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/@jest/transform/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/@jest/types": { + "version": "29.6.3", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-29.6.3.tgz", + "integrity": "sha512-u3UPsIilWKOM3F9CXtrG8LEJmNxwoCQC/XVj4IKYXvvpx7QIi/Kg1LI5uDmDpKlac62NUtX7eLjRh+jVZcLOzw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/schemas": "^29.6.3", + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^17.0.8", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@jridgewell/set-array": "^1.2.1", + "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/trace-mapping": "^0.3.24" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "license": "MIT", + "engines": { + "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==", + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.25" + } + }, + "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==", + "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==", + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@juggle/resize-observer": { + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/@juggle/resize-observer/-/resize-observer-3.4.0.tgz", + "integrity": "sha512-dfLbk+PwWvFzSxwk3n5ySL0hfBog779o8h68wK/7/APo/7cgyWp5jcXockbxdk5kFRkbeXWm4Fbi9FrdN381sA==", + "license": "Apache-2.0" + }, + "node_modules/@leichtgewicht/ip-codec": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@leichtgewicht/ip-codec/-/ip-codec-2.0.5.tgz", + "integrity": "sha512-Vo+PSpZG2/fmgmiNzYK9qWRh8h/CHrwD0mo1h1DzL4yzHNSfWYujGTYsWGreD000gcgmZ7K4Ys6Tx9TxtsKdDw==", + "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==", + "license": "MIT", + "dependencies": { + "langium": "3.3.1" + } + }, + "node_modules/@nicolo-ribaudo/eslint-scope-5-internals": { + "version": "5.1.1-v1", + "resolved": "https://registry.npmjs.org/@nicolo-ribaudo/eslint-scope-5-internals/-/eslint-scope-5-internals-5.1.1-v1.tgz", + "integrity": "sha512-54/JRvkLIzzDWshCWfuhadfrfZVPiElY8Fcgmg1HroEly/EDSszzhBAsarCux+D/kOslTRquNzuyGSmUSTTHGg==", + "license": "MIT", + "dependencies": { + "eslint-scope": "5.1.1" + } + }, + "node_modules/@nicolo-ribaudo/eslint-scope-5-internals/node_modules/eslint-scope": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz", + "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==", + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^4.1.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/@nicolo-ribaudo/eslint-scope-5-internals/node_modules/estraverse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", + "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz", + "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==", + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz", + "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==", + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz", + "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==", + "license": "MIT", + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@pkgjs/parseargs": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz", + "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==", + "license": "MIT", + "optional": true, + "engines": { + "node": ">=14" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "ansi-html": "^0.0.9", + "core-js-pure": "^3.23.3", + "error-stack-parser": "^2.0.6", + "html-entities": "^2.1.0", + "loader-utils": "^2.0.4", + "schema-utils": "^4.2.0", + "source-map": "^0.7.3" + }, + "engines": { + "node": ">= 10.13" + }, + "peerDependencies": { + "@types/webpack": "4.x || 5.x", + "react-refresh": ">=0.10.0 <1.0.0", + "sockjs-client": "^1.4.0", + "type-fest": ">=0.17.0 <5.0.0", + "webpack": ">=4.43.0 <6.0.0", + "webpack-dev-server": "3.x || 4.x || 5.x", + "webpack-hot-middleware": "2.x", + "webpack-plugin-serve": "0.x || 1.x" + }, + "peerDependenciesMeta": { + "@types/webpack": { + "optional": true + }, + "sockjs-client": { + "optional": true + }, + "type-fest": { + "optional": true + }, + "webpack-dev-server": { + "optional": true + }, + "webpack-hot-middleware": { + "optional": true + }, + "webpack-plugin-serve": { + "optional": true + } + } + }, + "node_modules/@remix-run/router": { + "version": "1.23.0", + "resolved": "https://registry.npmjs.org/@remix-run/router/-/router-1.23.0.tgz", + "integrity": "sha512-O3rHJzAQKamUz1fvE0Qaw0xSFqsA/yafi2iqeE0pvdFtCO1viYx8QL6f3Ln/aCCTLxs68SLf0KPM9eSeM8yBnA==", + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/@rollup/plugin-babel": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/@rollup/plugin-babel/-/plugin-babel-5.3.1.tgz", + "integrity": "sha512-WFfdLWU/xVWKeRQnKmIAQULUI7Il0gZnBIH/ZFO069wYIfPu+8zrfp/KMW0atmELoRDq8FbiP3VCss9MhCut7Q==", + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.10.4", + "@rollup/pluginutils": "^3.1.0" + }, + "engines": { + "node": ">= 10.0.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0", + "@types/babel__core": "^7.1.9", + "rollup": "^1.20.0||^2.0.0" + }, + "peerDependenciesMeta": { + "@types/babel__core": { + "optional": true + } + } + }, + "node_modules/@rollup/plugin-node-resolve": { + "version": "11.2.1", + "resolved": "https://registry.npmjs.org/@rollup/plugin-node-resolve/-/plugin-node-resolve-11.2.1.tgz", + "integrity": "sha512-yc2n43jcqVyGE2sqV5/YCmocy9ArjVAP/BeXyTtADTBBX6V0e5UMqwO8CdQ0kzjb6zu5P1qMzsScCMRvE9OlVg==", + "license": "MIT", + "dependencies": { + "@rollup/pluginutils": "^3.1.0", + "@types/resolve": "1.17.1", + "builtin-modules": "^3.1.0", + "deepmerge": "^4.2.2", + "is-module": "^1.0.0", + "resolve": "^1.19.0" + }, + "engines": { + "node": ">= 10.0.0" + }, + "peerDependencies": { + "rollup": "^1.20.0||^2.0.0" + } + }, + "node_modules/@rollup/plugin-replace": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/@rollup/plugin-replace/-/plugin-replace-2.4.2.tgz", + "integrity": "sha512-IGcu+cydlUMZ5En85jxHH4qj2hta/11BHq95iHEyb2sbgiN0eCdzvUcHw5gt9pBL5lTi4JDYJ1acCoMGpTvEZg==", + "license": "MIT", + "dependencies": { + "@rollup/pluginutils": "^3.1.0", + "magic-string": "^0.25.7" + }, + "peerDependencies": { + "rollup": "^1.20.0 || ^2.0.0" + } + }, + "node_modules/@rollup/pluginutils": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-3.1.0.tgz", + "integrity": "sha512-GksZ6pr6TpIjHm8h9lSQ8pi8BE9VeubNT0OMJ3B5uZJ8pz73NPiqOtCog/x2/QzM1ENChPKxMDhiQuRHsqc+lg==", + "license": "MIT", + "dependencies": { + "@types/estree": "0.0.39", + "estree-walker": "^1.0.1", + "picomatch": "^2.2.2" + }, + "engines": { + "node": ">= 8.0.0" + }, + "peerDependencies": { + "rollup": "^1.20.0||^2.0.0" + } + }, + "node_modules/@rollup/pluginutils/node_modules/@types/estree": { + "version": "0.0.39", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-0.0.39.tgz", + "integrity": "sha512-EYNwp3bU+98cpU4lAWYYL7Zz+2gryWH1qbdDTidVd6hkiR6weksdbMadyXKXNPEkQFhXM+hVO9ZygomHXp+AIw==", + "license": "MIT" + }, + "node_modules/@rsuite/icon-font": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/@rsuite/icon-font/-/icon-font-4.1.0.tgz", + "integrity": "sha512-q0Y+uQCVvzhD6lFeAFrvCDd1lTjZfM6MIaBjre3lSW1w586VWbuFnhTiqos3v9HIMlUpm3aAsxd3SuM6gYaqqQ==", + "license": "(CC-BY-4.0 AND OFL-1.1 AND MIT)" + }, + "node_modules/@rsuite/icons": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/@rsuite/icons/-/icons-1.3.2.tgz", + "integrity": "sha512-3sOdZpPcVePwTCoWcHHIEg4rsjWp9ehwjC84SjvgyqNyEf/BJNVDm0+jDAGGbhOF0HiWYyfU10LwrwnDSAYltA==", + "license": "MIT", + "dependencies": { + "@rsuite/icon-font": "^4.1.0", + "classnames": "^2.2.5" + }, + "peerDependencies": { + "react": ">=16.8.0", + "react-dom": ">=16.8.0" + } + }, + "node_modules/@rtsao/scc": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@rtsao/scc/-/scc-1.1.0.tgz", + "integrity": "sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g==", + "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==", + "license": "MIT" + }, + "node_modules/@sinclair/typebox": { + "version": "0.27.8", + "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz", + "integrity": "sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@sinonjs/commons": { + "version": "1.8.6", + "resolved": "https://registry.npmjs.org/@sinonjs/commons/-/commons-1.8.6.tgz", + "integrity": "sha512-Ky+XkAkqPZSm3NLBeUng77EBQl3cmeJhITaGHdYH8kjVB+aun3S4XBRti2zt17mtt0mIUDiNxYeoJm6drVvBJQ==", + "license": "BSD-3-Clause", + "dependencies": { + "type-detect": "4.0.8" + } + }, + "node_modules/@sinonjs/fake-timers": { + "version": "8.1.0", + "resolved": "https://registry.npmjs.org/@sinonjs/fake-timers/-/fake-timers-8.1.0.tgz", + "integrity": "sha512-OAPJUAtgeINhh/TAlUID4QTs53Njm7xzddaVlEs/SXwgtiD1tW22zAB/W1wdqfrpmikgaWQ9Fw6Ws+hsiRm5Vg==", + "license": "BSD-3-Clause", + "dependencies": { + "@sinonjs/commons": "^1.7.0" + } + }, + "node_modules/@surma/rollup-plugin-off-main-thread": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/@surma/rollup-plugin-off-main-thread/-/rollup-plugin-off-main-thread-2.2.3.tgz", + "integrity": "sha512-lR8q/9W7hZpMWweNiAKU7NQerBnzQQLvi8qnTDU/fxItPhtZVMbPV3lbCwjhIlNBe9Bbr5V+KHshvWmVSG9cxQ==", + "license": "Apache-2.0", + "dependencies": { + "ejs": "^3.1.6", + "json5": "^2.2.0", + "magic-string": "^0.25.0", + "string.prototype.matchall": "^4.0.6" + } + }, + "node_modules/@svgr/babel-plugin-add-jsx-attribute": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-add-jsx-attribute/-/babel-plugin-add-jsx-attribute-5.4.0.tgz", + "integrity": "sha512-ZFf2gs/8/6B8PnSofI0inYXr2SDNTDScPXhN7k5EqD4aZ3gi6u+rbmZHVB8IM3wDyx8ntKACZbtXSm7oZGRqVg==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-remove-jsx-attribute": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-attribute/-/babel-plugin-remove-jsx-attribute-5.4.0.tgz", + "integrity": "sha512-yaS4o2PgUtwLFGTKbsiAy6D0o3ugcUhWK0Z45umJ66EPWunAz9fuFw2gJuje6wqQvQWOTJvIahUwndOXb7QCPg==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-remove-jsx-empty-expression": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-remove-jsx-empty-expression/-/babel-plugin-remove-jsx-empty-expression-5.0.1.tgz", + "integrity": "sha512-LA72+88A11ND/yFIMzyuLRSMJ+tRKeYKeQ+mR3DcAZ5I4h5CPWN9AHyUzJbWSYp/u2u0xhmgOe0+E41+GjEueA==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-replace-jsx-attribute-value": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-replace-jsx-attribute-value/-/babel-plugin-replace-jsx-attribute-value-5.0.1.tgz", + "integrity": "sha512-PoiE6ZD2Eiy5mK+fjHqwGOS+IXX0wq/YDtNyIgOrc6ejFnxN4b13pRpiIPbtPwHEc+NT2KCjteAcq33/F1Y9KQ==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-svg-dynamic-title": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-dynamic-title/-/babel-plugin-svg-dynamic-title-5.4.0.tgz", + "integrity": "sha512-zSOZH8PdZOpuG1ZVx/cLVePB2ibo3WPpqo7gFIjLV9a0QsuQAzJiwwqmuEdTaW2pegyBE17Uu15mOgOcgabQZg==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-svg-em-dimensions": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-svg-em-dimensions/-/babel-plugin-svg-em-dimensions-5.4.0.tgz", + "integrity": "sha512-cPzDbDA5oT/sPXDCUYoVXEmm3VIoAWAPT6mSPTJNbQaBNUuEKVKyGH93oDY4e42PYHRW67N5alJx/eEol20abw==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-transform-react-native-svg": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-react-native-svg/-/babel-plugin-transform-react-native-svg-5.4.0.tgz", + "integrity": "sha512-3eYP/SaopZ41GHwXma7Rmxcv9uRslRDTY1estspeB1w1ueZWd/tPlMfEOoccYpEMZU3jD4OU7YitnXcF5hLW2Q==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-transform-svg-component": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-plugin-transform-svg-component/-/babel-plugin-transform-svg-component-5.5.0.tgz", + "integrity": "sha512-q4jSH1UUvbrsOtlo/tKcgSeiCHRSBdXoIoqX1pgcKK/aU3JD27wmMKwGtpB8qRYUYoyXvfGxUVKchLuR5pB3rQ==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-preset": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/@svgr/babel-preset/-/babel-preset-5.5.0.tgz", + "integrity": "sha512-4FiXBjvQ+z2j7yASeGPEi8VD/5rrGQk4Xrq3EdJmoZgz/tpqChpo5hgXDvmEauwtvOc52q8ghhZK4Oy7qph4ig==", + "license": "MIT", + "dependencies": { + "@svgr/babel-plugin-add-jsx-attribute": "^5.4.0", + "@svgr/babel-plugin-remove-jsx-attribute": "^5.4.0", + "@svgr/babel-plugin-remove-jsx-empty-expression": "^5.0.1", + "@svgr/babel-plugin-replace-jsx-attribute-value": "^5.0.1", + "@svgr/babel-plugin-svg-dynamic-title": "^5.4.0", + "@svgr/babel-plugin-svg-em-dimensions": "^5.4.0", + "@svgr/babel-plugin-transform-react-native-svg": "^5.4.0", + "@svgr/babel-plugin-transform-svg-component": "^5.5.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/core": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/@svgr/core/-/core-5.5.0.tgz", + "integrity": "sha512-q52VOcsJPvV3jO1wkPtzTuKlvX7Y3xIcWRpCMtBF3MrteZJtBfQw/+u0B1BHy5ColpQc1/YVTrPEtSYIMNZlrQ==", + "license": "MIT", + "dependencies": { + "@svgr/plugin-jsx": "^5.5.0", + "camelcase": "^6.2.0", + "cosmiconfig": "^7.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/hast-util-to-babel-ast": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/@svgr/hast-util-to-babel-ast/-/hast-util-to-babel-ast-5.5.0.tgz", + "integrity": "sha512-cAaR/CAiZRB8GP32N+1jocovUtvlj0+e65TB50/6Lcime+EA49m/8l+P2ko+XPJ4dw3xaPS3jOL4F2X4KWxoeQ==", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.12.6" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/plugin-jsx": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/@svgr/plugin-jsx/-/plugin-jsx-5.5.0.tgz", + "integrity": "sha512-V/wVh33j12hGh05IDg8GpIUXbjAPnTdPTKuP4VNLggnwaHMPNQNae2pRnyTAILWCQdz5GyMqtO488g7CKM8CBA==", + "license": "MIT", + "dependencies": { + "@babel/core": "^7.12.3", + "@svgr/babel-preset": "^5.5.0", + "@svgr/hast-util-to-babel-ast": "^5.5.0", + "svg-parser": "^2.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/plugin-svgo": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/@svgr/plugin-svgo/-/plugin-svgo-5.5.0.tgz", + "integrity": "sha512-r5swKk46GuQl4RrVejVwpeeJaydoxkdwkM1mBKOgJLBUJPGaLci6ylg/IjhrRsREKDkr4kbMWdgOtbXEh0fyLQ==", + "license": "MIT", + "dependencies": { + "cosmiconfig": "^7.0.0", + "deepmerge": "^4.2.2", + "svgo": "^1.2.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/webpack": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/@svgr/webpack/-/webpack-5.5.0.tgz", + "integrity": "sha512-DOBOK255wfQxguUta2INKkzPj6AIS6iafZYiYmHn6W3pHlycSRRlvWKCfLDG10fXfLWqE3DJHgRUOyJYmARa7g==", + "license": "MIT", + "dependencies": { + "@babel/core": "^7.12.3", + "@babel/plugin-transform-react-constant-elements": "^7.12.1", + "@babel/preset-env": "^7.12.1", + "@babel/preset-react": "^7.12.5", + "@svgr/core": "^5.5.0", + "@svgr/plugin-jsx": "^5.5.0", + "@svgr/plugin-svgo": "^5.5.0", + "loader-utils": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@testing-library/dom": { + "version": "10.4.0", + "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.0.tgz", + "integrity": "sha512-pemlzrSESWbdAloYml3bAJMEfNh1Z7EduzqPKprCH5S341frlpYnUEW0H72dLxa6IsYr+mPno20GiSm+h9dEdQ==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "@babel/code-frame": "^7.10.4", + "@babel/runtime": "^7.12.5", + "@types/aria-query": "^5.0.1", + "aria-query": "5.3.0", + "chalk": "^4.1.0", + "dom-accessibility-api": "^0.5.9", + "lz-string": "^1.5.0", + "pretty-format": "^27.0.2" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/@testing-library/jest-dom": { + "version": "5.17.0", + "resolved": "https://registry.npmjs.org/@testing-library/jest-dom/-/jest-dom-5.17.0.tgz", + "integrity": "sha512-ynmNeT7asXyH3aSVv4vvX4Rb+0qjOhdNHnO/3vuZNqPmhDpV/+rCSGwQ7bLcmU2cJ4dvoheIO85LQj0IbJHEtg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@adobe/css-tools": "^4.0.1", + "@babel/runtime": "^7.9.2", + "@types/testing-library__jest-dom": "^5.9.1", + "aria-query": "^5.0.0", + "chalk": "^3.0.0", + "css.escape": "^1.5.1", + "dom-accessibility-api": "^0.5.6", + "lodash": "^4.17.15", + "redent": "^3.0.0" + }, + "engines": { + "node": ">=8", + "npm": ">=6", + "yarn": ">=1" + } + }, + "node_modules/@testing-library/jest-dom/node_modules/chalk": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-3.0.0.tgz", + "integrity": "sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg==", + "dev": true, + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@testing-library/react": { + "version": "13.4.0", + "resolved": "https://registry.npmjs.org/@testing-library/react/-/react-13.4.0.tgz", + "integrity": "sha512-sXOGON+WNTh3MLE9rve97ftaZukN3oNf2KjDy7YTx6hcTO2uuLHuCGynMDhFwGw/jYf4OJ2Qk0i4i79qMNNkyw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.12.5", + "@testing-library/dom": "^8.5.0", + "@types/react-dom": "^18.0.0" + }, + "engines": { + "node": ">=12" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@testing-library/react/node_modules/@testing-library/dom": { + "version": "8.20.1", + "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-8.20.1.tgz", + "integrity": "sha512-/DiOQ5xBxgdYRC8LNk7U+RWat0S3qRLeIw3ZIkMQ9kkVlRmwD/Eg8k8CqIpD6GW7u20JIUOfMKbxtiLutpjQ4g==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.10.4", + "@babel/runtime": "^7.12.5", + "@types/aria-query": "^5.0.1", + "aria-query": "5.1.3", + "chalk": "^4.1.0", + "dom-accessibility-api": "^0.5.9", + "lz-string": "^1.5.0", + "pretty-format": "^27.0.2" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@testing-library/react/node_modules/aria-query": { + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.1.3.tgz", + "integrity": "sha512-R5iJ5lkuHybztUfuOAznmboyjWq8O6sqNqtK7CLOqdydi54VNbORp49mb14KbWgG1QD3JFO9hJdZ+y4KutfdOQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "deep-equal": "^2.0.5" + } + }, + "node_modules/@testing-library/user-event": { + "version": "13.5.0", + "resolved": "https://registry.npmjs.org/@testing-library/user-event/-/user-event-13.5.0.tgz", + "integrity": "sha512-5Kwtbo3Y/NowpkbRuSepbyMFkZmHgD+vPzYB/RJ4oxt5Gj/avFFBYjhw27cqSVPVw/3a67NK1PbiIr9k4Gwmdg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.12.5" + }, + "engines": { + "node": ">=10", + "npm": ">=6" + }, + "peerDependencies": { + "@testing-library/dom": ">=7.21.4" + } + }, + "node_modules/@tootallnate/once": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@tootallnate/once/-/once-1.1.2.tgz", + "integrity": "sha512-RbzJvlNzmRq5c3O09UipeuXno4tA1FE6ikOjxZK0tuxVv3412l64l5t1W5pj4+rJq9vpkm/kwiR07aZXnsKPxw==", + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/@trysound/sax": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/@trysound/sax/-/sax-0.2.0.tgz", + "integrity": "sha512-L7z9BgrNEcYyUYtF+HaEfiS5ebkh9jXqbszz7pC0hRBPaatV0XjSD3+eHrpqFemQfgwiFF0QPIarnIihIDn7OA==", + "license": "ISC", + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/@types/aria-query": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz", + "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/babel__core": { + "version": "7.20.5", + "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz", + "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==", + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.20.7", + "@babel/types": "^7.20.7", + "@types/babel__generator": "*", + "@types/babel__template": "*", + "@types/babel__traverse": "*" + } + }, + "node_modules/@types/babel__generator": { + "version": "7.27.0", + "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz", + "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__template": { + "version": "7.4.4", + "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz", + "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==", + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.20.7" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@types/connect": "*", + "@types/node": "*" + } + }, + "node_modules/@types/bonjour": { + "version": "3.5.13", + "resolved": "https://registry.npmjs.org/@types/bonjour/-/bonjour-3.5.13.tgz", + "integrity": "sha512-z9fJ5Im06zvUL548KvYNecEVlA7cVDkGUi6kZusb04mpyEFKCIZJvloCcmpmLaIahDpOQGHaHmG6imtPMmPXGQ==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/connect": { + "version": "3.4.38", + "resolved": "https://registry.npmjs.org/@types/connect/-/connect-3.4.38.tgz", + "integrity": "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/connect-history-api-fallback": { + "version": "1.5.4", + "resolved": "https://registry.npmjs.org/@types/connect-history-api-fallback/-/connect-history-api-fallback-1.5.4.tgz", + "integrity": "sha512-n6Cr2xS1h4uAulPRdlw6Jl6s1oG8KrVilPN2yUITEs+K48EzMJJ3W1xy8K5eWuFvjp3R74AOIGSmp2UfBJ8HFw==", + "license": "MIT", + "dependencies": { + "@types/express-serve-static-core": "*", + "@types/node": "*" + } + }, + "node_modules/@types/d3": { + "version": "7.4.3", + "resolved": "https://registry.npmjs.org/@types/d3/-/d3-7.4.3.tgz", + "integrity": "sha512-lZXZ9ckh5R8uiFVt8ogUNf+pIrK4EsWrx2Np75WvF/eTpJ0FMHNhjXk8CKEx/+gpHbNQyJWehbFaTvqmHWB3ww==", + "license": "MIT", + "dependencies": { + "@types/d3-array": "*", + "@types/d3-axis": "*", + "@types/d3-brush": "*", + "@types/d3-chord": "*", + "@types/d3-color": "*", + "@types/d3-contour": "*", + "@types/d3-delaunay": "*", + "@types/d3-dispatch": "*", + "@types/d3-drag": "*", + "@types/d3-dsv": "*", + "@types/d3-ease": "*", + "@types/d3-fetch": "*", + "@types/d3-force": "*", + "@types/d3-format": "*", + "@types/d3-geo": "*", + "@types/d3-hierarchy": "*", + "@types/d3-interpolate": "*", + "@types/d3-path": "*", + "@types/d3-polygon": "*", + "@types/d3-quadtree": "*", + "@types/d3-random": "*", + "@types/d3-scale": "*", + "@types/d3-scale-chromatic": "*", + "@types/d3-selection": "*", + "@types/d3-shape": "*", + "@types/d3-time": "*", + "@types/d3-time-format": "*", + "@types/d3-timer": "*", + "@types/d3-transition": "*", + "@types/d3-zoom": "*" + } + }, + "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==", + "license": "MIT" + }, + "node_modules/@types/d3-axis": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/@types/d3-axis/-/d3-axis-3.0.6.tgz", + "integrity": "sha512-pYeijfZuBd87T0hGn0FO1vQ/cgLk6E1ALJjfkC0oJ8cbwkZl3TpgS8bVBLZN+2jjGgg38epgxb2zmoGtSfvgMw==", + "license": "MIT", + "dependencies": { + "@types/d3-selection": "*" + } + }, + "node_modules/@types/d3-brush": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/@types/d3-brush/-/d3-brush-3.0.6.tgz", + "integrity": "sha512-nH60IZNNxEcrh6L1ZSMNA28rj27ut/2ZmI3r96Zd+1jrZD++zD3LsMIjWlvg4AYrHn/Pqz4CF3veCxGjtbqt7A==", + "license": "MIT", + "dependencies": { + "@types/d3-selection": "*" + } + }, + "node_modules/@types/d3-chord": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/@types/d3-chord/-/d3-chord-3.0.6.tgz", + "integrity": "sha512-LFYWWd8nwfwEmTZG9PfQxd17HbNPksHBiJHaKuY1XeqscXacsS2tyoo6OdRsjf+NQYeB6XrNL3a25E3gH69lcg==", + "license": "MIT" + }, + "node_modules/@types/d3-color": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz", + "integrity": "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==", + "license": "MIT" + }, + "node_modules/@types/d3-contour": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/@types/d3-contour/-/d3-contour-3.0.6.tgz", + "integrity": "sha512-BjzLgXGnCWjUSYGfH1cpdo41/hgdWETu4YxpezoztawmqsvCeep+8QGfiY6YbDvfgHz/DkjeIkkZVJavB4a3rg==", + "license": "MIT", + "dependencies": { + "@types/d3-array": "*", + "@types/geojson": "*" + } + }, + "node_modules/@types/d3-delaunay": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-delaunay/-/d3-delaunay-6.0.4.tgz", + "integrity": "sha512-ZMaSKu4THYCU6sV64Lhg6qjf1orxBthaC161plr5KuPHo3CNm8DTHiLw/5Eq2b6TsNP0W0iJrUOFscY6Q450Hw==", + "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==", + "license": "MIT" + }, + "node_modules/@types/d3-drag": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-drag/-/d3-drag-3.0.7.tgz", + "integrity": "sha512-HE3jVKlzU9AaMazNufooRJ5ZpWmLIoc90A37WU2JMmeq28w1FQqCZswHZ3xR+SuxYftzHq6WU6KJHvqxKzTxxQ==", + "license": "MIT", + "dependencies": { + "@types/d3-selection": "*" + } + }, + "node_modules/@types/d3-dsv": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-dsv/-/d3-dsv-3.0.7.tgz", + "integrity": "sha512-n6QBF9/+XASqcKK6waudgL0pf/S5XHPPI8APyMLLUHd8NqouBGLsU8MgtO7NINGtPBtk9Kko/W4ea0oAspwh9g==", + "license": "MIT" + }, + "node_modules/@types/d3-ease": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/d3-ease/-/d3-ease-3.0.2.tgz", + "integrity": "sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA==", + "license": "MIT" + }, + "node_modules/@types/d3-fetch": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-fetch/-/d3-fetch-3.0.7.tgz", + "integrity": "sha512-fTAfNmxSb9SOWNB9IoG5c8Hg6R+AzUHDRlsXsDZsNp6sxAEOP0tkP3gKkNSO/qmHPoBFTxNrjDprVHDQDvo5aA==", + "license": "MIT", + "dependencies": { + "@types/d3-dsv": "*" + } + }, + "node_modules/@types/d3-force": { + "version": "3.0.10", + "resolved": "https://registry.npmjs.org/@types/d3-force/-/d3-force-3.0.10.tgz", + "integrity": "sha512-ZYeSaCF3p73RdOKcjj+swRlZfnYpK1EbaDiYICEEp5Q6sUiqFaFQ9qgoshp5CzIyyb/yD09kD9o2zEltCexlgw==", + "license": "MIT" + }, + "node_modules/@types/d3-format": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-format/-/d3-format-3.0.4.tgz", + "integrity": "sha512-fALi2aI6shfg7vM5KiR1wNJnZ7r6UuggVqtDA+xiEdPZQwy/trcQaHnwShLuLdta2rTymCNpxYTiMZX/e09F4g==", + "license": "MIT" + }, + "node_modules/@types/d3-geo": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@types/d3-geo/-/d3-geo-3.1.0.tgz", + "integrity": "sha512-856sckF0oP/diXtS4jNsiQw/UuK5fQG8l/a9VVLeSouf1/PPbBE1i1W852zVwKwYCBkFJJB7nCFTbk6UMEXBOQ==", + "license": "MIT", + "dependencies": { + "@types/geojson": "*" + } + }, + "node_modules/@types/d3-hierarchy": { + "version": "3.1.7", + "resolved": "https://registry.npmjs.org/@types/d3-hierarchy/-/d3-hierarchy-3.1.7.tgz", + "integrity": "sha512-tJFtNoYBtRtkNysX1Xq4sxtjK8YgoWUNpIiUee0/jHGRwqvzYxkq0hGVbbOGSz+JgFxxRu4K8nb3YpG3CMARtg==", + "license": "MIT" + }, + "node_modules/@types/d3-interpolate": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz", + "integrity": "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==", + "license": "MIT", + "dependencies": { + "@types/d3-color": "*" + } + }, + "node_modules/@types/d3-path": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@types/d3-path/-/d3-path-3.1.1.tgz", + "integrity": "sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg==", + "license": "MIT" + }, + "node_modules/@types/d3-polygon": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/d3-polygon/-/d3-polygon-3.0.2.tgz", + "integrity": "sha512-ZuWOtMaHCkN9xoeEMr1ubW2nGWsp4nIql+OPQRstu4ypeZ+zk3YKqQT0CXVe/PYqrKpZAi+J9mTs05TKwjXSRA==", + "license": "MIT" + }, + "node_modules/@types/d3-quadtree": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/@types/d3-quadtree/-/d3-quadtree-3.0.6.tgz", + "integrity": "sha512-oUzyO1/Zm6rsxKRHA1vH0NEDG58HrT5icx/azi9MF1TWdtttWl0UIUsjEQBBh+SIkrpd21ZjEv7ptxWys1ncsg==", + "license": "MIT" + }, + "node_modules/@types/d3-random": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/d3-random/-/d3-random-3.0.3.tgz", + "integrity": "sha512-Imagg1vJ3y76Y2ea0871wpabqp613+8/r0mCLEBfdtqC7xMSfj9idOnmBYyMoULfHePJyxMAw3nWhJxzc+LFwQ==", + "license": "MIT" + }, + "node_modules/@types/d3-scale": { + "version": "4.0.9", + "resolved": "https://registry.npmjs.org/@types/d3-scale/-/d3-scale-4.0.9.tgz", + "integrity": "sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw==", + "license": "MIT", + "dependencies": { + "@types/d3-time": "*" + } + }, + "node_modules/@types/d3-scale-chromatic": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@types/d3-scale-chromatic/-/d3-scale-chromatic-3.1.0.tgz", + "integrity": "sha512-iWMJgwkK7yTRmWqRB5plb1kadXyQ5Sj8V/zYlFGMUBbIPKQScw+Dku9cAAMgJG+z5GYDoMjWGLVOvjghDEFnKQ==", + "license": "MIT" + }, + "node_modules/@types/d3-selection": { + "version": "3.0.11", + "resolved": "https://registry.npmjs.org/@types/d3-selection/-/d3-selection-3.0.11.tgz", + "integrity": "sha512-bhAXu23DJWsrI45xafYpkQ4NtcKMwWnAC/vKrd2l+nxMFuvOT3XMYTIj2opv8vq8AO5Yh7Qac/nSeP/3zjTK0w==", + "license": "MIT" + }, + "node_modules/@types/d3-shape": { + "version": "3.1.7", + "resolved": "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-3.1.7.tgz", + "integrity": "sha512-VLvUQ33C+3J+8p+Daf+nYSOsjB4GXp19/S/aGo60m9h1v6XaxjiT82lKVWJCfzhtuZ3yD7i/TPeC/fuKLLOSmg==", + "license": "MIT", + "dependencies": { + "@types/d3-path": "*" + } + }, + "node_modules/@types/d3-time": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-time/-/d3-time-3.0.4.tgz", + "integrity": "sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g==", + "license": "MIT" + }, + "node_modules/@types/d3-time-format": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/@types/d3-time-format/-/d3-time-format-4.0.3.tgz", + "integrity": "sha512-5xg9rC+wWL8kdDj153qZcsJ0FWiFt0J5RB6LYUNZjwSnesfblqrI/bJ1wBdJ8OQfncgbJG5+2F+qfqnqyzYxyg==", + "license": "MIT" + }, + "node_modules/@types/d3-timer": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/d3-timer/-/d3-timer-3.0.2.tgz", + "integrity": "sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw==", + "license": "MIT" + }, + "node_modules/@types/d3-transition": { + "version": "3.0.9", + "resolved": "https://registry.npmjs.org/@types/d3-transition/-/d3-transition-3.0.9.tgz", + "integrity": "sha512-uZS5shfxzO3rGlu0cC3bjmMFKsXv+SmZZcgp0KD22ts4uGXp5EVYGzu/0YdwZeKmddhcAccYtREJKkPfXkZuCg==", + "license": "MIT", + "dependencies": { + "@types/d3-selection": "*" + } + }, + "node_modules/@types/d3-zoom": { + "version": "3.0.8", + "resolved": "https://registry.npmjs.org/@types/d3-zoom/-/d3-zoom-3.0.8.tgz", + "integrity": "sha512-iqMC4/YlFCSlO8+2Ii1GGGliCAY4XdeG748w5vQUbevlbDu0zSjH/+jojorQVBK/se0j6DUFNPBGSqD3YWYnDw==", + "license": "MIT", + "dependencies": { + "@types/d3-interpolate": "*", + "@types/d3-selection": "*" + } + }, + "node_modules/@types/debug": { + "version": "4.1.12", + "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.12.tgz", + "integrity": "sha512-vIChWdVG3LG1SMxEvI/AK+FWJthlrqlTu7fbrlywTkkaONwk/UAGaULXRlf8vkzFBLVm0zkMdCquhL5aOjhXPQ==", + "license": "MIT", + "dependencies": { + "@types/ms": "*" + } + }, + "node_modules/@types/eslint": { + "version": "8.56.12", + "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-8.56.12.tgz", + "integrity": "sha512-03ruubjWyOHlmljCVoxSuNDdmfZDzsrrz0P2LeJsOXr+ZwFQ+0yQIwNCwt/GYhV7Z31fgtXJTAEs+FYlEL851g==", + "license": "MIT", + "dependencies": { + "@types/estree": "*", + "@types/json-schema": "*" + } + }, + "node_modules/@types/eslint-scope": { + "version": "3.7.7", + "resolved": "https://registry.npmjs.org/@types/eslint-scope/-/eslint-scope-3.7.7.tgz", + "integrity": "sha512-MzMFlSLBqNF2gcHWO0G1vP/YQyfvrxZ0bF+u7mzUdZ1/xK4A4sru+nraZz5i3iEIk1l1uyicaDVTB4QbbEkAYg==", + "license": "MIT", + "dependencies": { + "@types/eslint": "*", + "@types/estree": "*" + } + }, + "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==", + "license": "MIT" + }, + "node_modules/@types/estree-jsx": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/@types/estree-jsx/-/estree-jsx-1.0.5.tgz", + "integrity": "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==", + "license": "MIT", + "dependencies": { + "@types/estree": "*" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@types/body-parser": "*", + "@types/express-serve-static-core": "^4.17.33", + "@types/qs": "*", + "@types/serve-static": "*" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@types/node": "*", + "@types/qs": "*", + "@types/range-parser": "*", + "@types/send": "*" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@types/node": "*", + "@types/qs": "*", + "@types/range-parser": "*", + "@types/send": "*" + } + }, + "node_modules/@types/geojson": { + "version": "7946.0.16", + "resolved": "https://registry.npmjs.org/@types/geojson/-/geojson-7946.0.16.tgz", + "integrity": "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg==", + "license": "MIT" + }, + "node_modules/@types/graceful-fs": { + "version": "4.1.9", + "resolved": "https://registry.npmjs.org/@types/graceful-fs/-/graceful-fs-4.1.9.tgz", + "integrity": "sha512-olP3sd1qOEe5dXTSaFvQG+02VdRXcdytWLAZsAq1PecU8uqQAhkrnbli7DagjtXKW/Bl7YJbUsa8MPcuc8LHEQ==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/hast": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz", + "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==", + "license": "MIT", + "dependencies": { + "@types/unist": "*" + } + }, + "node_modules/@types/html-minifier-terser": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/@types/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz", + "integrity": "sha512-oh/6byDPnL1zeNXFrDXFLyZjkr1MsBG667IM792caf1L2UPOOMf65NFzjUH/ltyfwjAGfs1rsX1eftK0jC/KIg==", + "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==", + "license": "MIT" + }, + "node_modules/@types/http-proxy": { + "version": "1.17.16", + "resolved": "https://registry.npmjs.org/@types/http-proxy/-/http-proxy-1.17.16.tgz", + "integrity": "sha512-sdWoUajOB1cd0A8cRRQ1cfyWNbmFKLAqBB89Y8x5iYyG/mkJHc0YUH8pdWBy2omi9qtCpiIgGjuwO0dQST2l5w==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/istanbul-lib-coverage": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.6.tgz", + "integrity": "sha512-2QF/t/auWm0lsy8XtKVPG19v3sSOQlJe/YHZgfjb/KBBHOGSV+J2q/S671rcq9uTBrLAXmZpqJiaQbMT+zNU1w==", + "license": "MIT" + }, + "node_modules/@types/istanbul-lib-report": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/istanbul-lib-report/-/istanbul-lib-report-3.0.3.tgz", + "integrity": "sha512-NQn7AHQnk/RSLOxrBbGyJM/aVQ+pjj5HCgasFxc0K/KhoATfQ/47AyUl15I2yBUpihjmas+a+VJBOqecrFH+uA==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "*" + } + }, + "node_modules/@types/istanbul-reports": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/istanbul-reports/-/istanbul-reports-3.0.4.tgz", + "integrity": "sha512-pk2B1NWalF9toCRu6gjBzR69syFjP4Od8WRAX+0mmf9lAjCRicLOWc+ZrxZHx/0XRjotgkF9t6iaMJ+aXcOdZQ==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-report": "*" + } + }, + "node_modules/@types/jest": { + "version": "29.5.14", + "resolved": "https://registry.npmjs.org/@types/jest/-/jest-29.5.14.tgz", + "integrity": "sha512-ZN+4sdnLUbo8EVvVc2ao0GFW6oVrQRPn4K2lglySj7APvSrgzxHiNNK99us4WDMi57xxA2yggblIAMNhXOotLQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "expect": "^29.0.0", + "pretty-format": "^29.0.0" + } + }, + "node_modules/@types/jest/node_modules/ansi-styles": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz", + "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/@types/jest/node_modules/pretty-format": { + "version": "29.7.0", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-29.7.0.tgz", + "integrity": "sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/schemas": "^29.6.3", + "ansi-styles": "^5.0.0", + "react-is": "^18.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@types/jest/node_modules/react-is": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz", + "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/json-schema": { + "version": "7.0.15", + "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz", + "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==", + "license": "MIT" + }, + "node_modules/@types/json5": { + "version": "0.0.29", + "resolved": "https://registry.npmjs.org/@types/json5/-/json5-0.0.29.tgz", + "integrity": "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==", + "license": "MIT" + }, + "node_modules/@types/lodash": { + "version": "4.17.16", + "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.17.16.tgz", + "integrity": "sha512-HX7Em5NYQAXKW+1T+FiuG27NGwzJfCX3s1GjOa7ujxZa52kjJLOr4FUxT+giF6Tgxv1e+/czV/iTtBw27WTU9g==", + "license": "MIT" + }, + "node_modules/@types/mdast": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz", + "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==", + "license": "MIT", + "dependencies": { + "@types/unist": "*" + } + }, + "node_modules/@types/mime": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/@types/mime/-/mime-1.3.5.tgz", + "integrity": "sha512-/pyBZWSLD2n0dcHE3hq8s8ZvcETHtEuF+3E7XVt0Ig2nvsVQXdghHVcEkIWjy9A0wKfTn97a/PSDYohKIlnP/w==", + "license": "MIT" + }, + "node_modules/@types/ms": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/@types/ms/-/ms-2.1.0.tgz", + "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==", + "license": "MIT" + }, + "node_modules/@types/node": { + "version": "22.15.3", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.15.3.tgz", + "integrity": "sha512-lX7HFZeHf4QG/J7tBZqrCAXwz9J5RD56Y6MpP0eJkka8p+K0RY/yBTW7CYFJ4VGCclxqOLKmiGP5juQc6MKgcw==", + "license": "MIT", + "dependencies": { + "undici-types": "~6.21.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==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/parse-json": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@types/parse-json/-/parse-json-4.0.2.tgz", + "integrity": "sha512-dISoDXWWQwUquiKsyZ4Ng+HX2KsPL7LyHKHQwgGFEA3IaKac4Obd+h2a/a6waisAoepJlBcx9paWqjA8/HVjCw==", + "license": "MIT" + }, + "node_modules/@types/prettier": { + "version": "2.7.3", + "resolved": "https://registry.npmjs.org/@types/prettier/-/prettier-2.7.3.tgz", + "integrity": "sha512-+68kP9yzs4LMp7VNh8gdzMSPZFL44MLGqiHWvttYJe+6qnuVr4Ek9wSBQoveqY/r+LwjCcU29kNVkidwim+kYA==", + "license": "MIT" + }, + "node_modules/@types/prop-types": { + "version": "15.7.14", + "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.14.tgz", + "integrity": "sha512-gNMvNH49DJ7OJYv+KAKn0Xp45p8PLl6zo2YnvDIbTd4J6MER2BmWN49TG7n9LvkyihINxeKW8+3bfS2yDC9dzQ==", + "license": "MIT" + }, + "node_modules/@types/q": { + "version": "1.5.8", + "resolved": "https://registry.npmjs.org/@types/q/-/q-1.5.8.tgz", + "integrity": "sha512-hroOstUScF6zhIi+5+x0dzqrHA1EJi+Irri6b1fxolMTqqHIV/Cg77EtnQcZqZCu8hR3mX2BzIxN4/GzI68Kfw==", + "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==", + "license": "MIT" + }, + "node_modules/@types/range-parser": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/@types/range-parser/-/range-parser-1.2.7.tgz", + "integrity": "sha512-hKormJbkJqzQGhziax5PItDUTMAM9uE2XXQmM37dyd4hVM+5aVl7oVxMVUiVQn2oCQFN/LKCZdvSM0pFRqbSmQ==", + "license": "MIT" + }, + "node_modules/@types/react": { + "version": "18.3.20", + "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.20.tgz", + "integrity": "sha512-IPaCZN7PShZK/3t6Q87pfTkRm6oLTd4vztyoj+cbHUF1g3FfVb2tFIL79uCRKEfv16AhqDMBywP2VW3KIZUvcg==", + "license": "MIT", + "dependencies": { + "@types/prop-types": "*", + "csstype": "^3.0.2" + } + }, + "node_modules/@types/react-dom": { + "version": "18.3.7", + "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.7.tgz", + "integrity": "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "@types/react": "^18.0.0" + } + }, + "node_modules/@types/react-window": { + "version": "1.8.8", + "resolved": "https://registry.npmjs.org/@types/react-window/-/react-window-1.8.8.tgz", + "integrity": "sha512-8Ls660bHR1AUA2kuRvVG9D/4XpRC6wjAaPT9dil7Ckc76eP9TKWZwwmgfq8Q1LANX3QNDnoU4Zp48A3w+zK69Q==", + "license": "MIT", + "dependencies": { + "@types/react": "*" + } + }, + "node_modules/@types/resolve": { + "version": "1.17.1", + "resolved": "https://registry.npmjs.org/@types/resolve/-/resolve-1.17.1.tgz", + "integrity": "sha512-yy7HuzQhj0dhGpD8RLXSZWEkLsV9ibvxvi6EiJ3bkqLAO1RGo0WbkWQiwpRlSFymTJRz0d3k5LM3kkx8ArDbLw==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/retry": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/@types/retry/-/retry-0.12.0.tgz", + "integrity": "sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA==", + "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==", + "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==", + "license": "MIT", + "dependencies": { + "@types/mime": "^1", + "@types/node": "*" + } + }, + "node_modules/@types/serve-index": { + "version": "1.9.4", + "resolved": "https://registry.npmjs.org/@types/serve-index/-/serve-index-1.9.4.tgz", + "integrity": "sha512-qLpGZ/c2fhSs5gnYsQxtDEq3Oy8SXPClIXkW5ghvAvsNuVSA8k+gCONcUCS/UjLEYvYps+e8uBtfgXgvhwfNug==", + "license": "MIT", + "dependencies": { + "@types/express": "*" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@types/http-errors": "*", + "@types/node": "*", + "@types/send": "*" + } + }, + "node_modules/@types/sockjs": { + "version": "0.3.36", + "resolved": "https://registry.npmjs.org/@types/sockjs/-/sockjs-0.3.36.tgz", + "integrity": "sha512-MK9V6NzAS1+Ud7JV9lJLFqW85VbC9dq3LmwZCuBe4wBDgKC0Kj/jd8Xl+nSviU+Qc3+m7umHHyHg//2KSa0a0Q==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/stack-utils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.3.tgz", + "integrity": "sha512-9aEbYZ3TbYMznPdcdr3SmIrLXwC/AKZXQeCf9Pgao5CKb8CyHuEX5jzWPTkvregvhRJHcpRO6BFoGW9ycaOkYw==", + "license": "MIT" + }, + "node_modules/@types/stylis": { + "version": "4.2.5", + "resolved": "https://registry.npmjs.org/@types/stylis/-/stylis-4.2.5.tgz", + "integrity": "sha512-1Xve+NMN7FWjY14vLoY5tL3BVEQ/n42YLwaqJIPYhotZ9uBHt87VceMwWQpzmdEt2TNXIorIFG+YeCUUW7RInw==", + "license": "MIT" + }, + "node_modules/@types/testing-library__jest-dom": { + "version": "5.14.9", + "resolved": "https://registry.npmjs.org/@types/testing-library__jest-dom/-/testing-library__jest-dom-5.14.9.tgz", + "integrity": "sha512-FSYhIjFlfOpGSRyVoMBMuS3ws5ehFQODymf3vlI7U1K8c7PHwWwFY7VREfmsuzHSOnoKs/9/Y983ayOs7eRzqw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/jest": "*" + } + }, + "node_modules/@types/trusted-types": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz", + "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==", + "license": "MIT" + }, + "node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "license": "MIT" + }, + "node_modules/@types/ws": { + "version": "8.18.1", + "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz", + "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/yargs": { + "version": "17.0.33", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-17.0.33.tgz", + "integrity": "sha512-WpxBCKWPLr4xSsHgz511rFJAM+wS28w2zEO1QDNY5zM/S8ok70NNfztH0xwhqKyaK0OHCbN98LDAZuy1ctxDkA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/@types/yargs-parser": { + "version": "21.0.3", + "resolved": "https://registry.npmjs.org/@types/yargs-parser/-/yargs-parser-21.0.3.tgz", + "integrity": "sha512-I4q9QU9MQv4oEOz4tAHJtNz1cwuLxn2F3xcc2iV5WdqLPpUnj30aUuxt1mAxYTG+oe8CZMV/+6rU4S4gRDzqtQ==", + "license": "MIT" + }, + "node_modules/@typescript-eslint/eslint-plugin": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-5.62.0.tgz", + "integrity": "sha512-TiZzBSJja/LbhNPvk6yc0JrX9XqhQ0hdh6M2svYfsHGejaKFIAGd9MQ+ERIMzLGlN/kZoYIgdxFV0PuljTKXag==", + "license": "MIT", + "dependencies": { + "@eslint-community/regexpp": "^4.4.0", + "@typescript-eslint/scope-manager": "5.62.0", + "@typescript-eslint/type-utils": "5.62.0", + "@typescript-eslint/utils": "5.62.0", + "debug": "^4.3.4", + "graphemer": "^1.4.0", + "ignore": "^5.2.0", + "natural-compare-lite": "^1.4.0", + "semver": "^7.3.7", + "tsutils": "^3.21.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "@typescript-eslint/parser": "^5.0.0", + "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/experimental-utils": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-5.62.0.tgz", + "integrity": "sha512-RTXpeB3eMkpoclG3ZHft6vG/Z30azNHuqY6wKPBHlVMZFuEvrtlEDe8gMqDb+SO+9hjC/pLekeSCryf9vMZlCw==", + "license": "MIT", + "dependencies": { + "@typescript-eslint/utils": "5.62.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/@typescript-eslint/parser": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.62.0.tgz", + "integrity": "sha512-VlJEV0fOQ7BExOsHYAGrgbEiZoi8D+Bl2+f6V2RrXerRSylnp+ZBHmPvaIa8cz0Ajx7WO7Z5RqfgYg7ED1nRhA==", + "license": "BSD-2-Clause", + "dependencies": { + "@typescript-eslint/scope-manager": "5.62.0", + "@typescript-eslint/types": "5.62.0", + "@typescript-eslint/typescript-estree": "5.62.0", + "debug": "^4.3.4" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/scope-manager": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-5.62.0.tgz", + "integrity": "sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w==", + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "5.62.0", + "@typescript-eslint/visitor-keys": "5.62.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/type-utils": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-5.62.0.tgz", + "integrity": "sha512-xsSQreu+VnfbqQpW5vnCJdq1Z3Q0U31qiWmRhr98ONQmcp/yhiPJFPq8MXiJVLiksmOKSjIldZzkebzHuCGzew==", + "license": "MIT", + "dependencies": { + "@typescript-eslint/typescript-estree": "5.62.0", + "@typescript-eslint/utils": "5.62.0", + "debug": "^4.3.4", + "tsutils": "^3.21.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "*" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/types": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-5.62.0.tgz", + "integrity": "sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ==", + "license": "MIT", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@typescript-eslint/typescript-estree": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-5.62.0.tgz", + "integrity": "sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA==", + "license": "BSD-2-Clause", + "dependencies": { + "@typescript-eslint/types": "5.62.0", + "@typescript-eslint/visitor-keys": "5.62.0", + "debug": "^4.3.4", + "globby": "^11.1.0", + "is-glob": "^4.0.3", + "semver": "^7.3.7", + "tsutils": "^3.21.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@typescript-eslint/utils": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.62.0.tgz", + "integrity": "sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ==", + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.2.0", + "@types/json-schema": "^7.0.9", + "@types/semver": "^7.3.12", + "@typescript-eslint/scope-manager": "5.62.0", + "@typescript-eslint/types": "5.62.0", + "@typescript-eslint/typescript-estree": "5.62.0", + "eslint-scope": "^5.1.1", + "semver": "^7.3.7" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + }, + "peerDependencies": { + "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/@typescript-eslint/utils/node_modules/eslint-scope": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz", + "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==", + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^4.1.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/@typescript-eslint/utils/node_modules/estraverse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", + "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/@typescript-eslint/visitor-keys": { + "version": "5.62.0", + "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.62.0.tgz", + "integrity": "sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw==", + "license": "MIT", + "dependencies": { + "@typescript-eslint/types": "5.62.0", + "eslint-visitor-keys": "^3.3.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/typescript-eslint" + } + }, + "node_modules/@ungap/structured-clone": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz", + "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==", + "license": "ISC" + }, + "node_modules/@webassemblyjs/ast": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.14.1.tgz", + "integrity": "sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ==", + "license": "MIT", + "dependencies": { + "@webassemblyjs/helper-numbers": "1.13.2", + "@webassemblyjs/helper-wasm-bytecode": "1.13.2" + } + }, + "node_modules/@webassemblyjs/floating-point-hex-parser": { + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.13.2.tgz", + "integrity": "sha512-6oXyTOzbKxGH4steLbLNOu71Oj+C8Lg34n6CqRvqfS2O71BxY6ByfMDRhBytzknj9yGUPVJ1qIKhRlAwO1AovA==", + "license": "MIT" + }, + "node_modules/@webassemblyjs/helper-api-error": { + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.13.2.tgz", + "integrity": "sha512-U56GMYxy4ZQCbDZd6JuvvNV/WFildOjsaWD3Tzzvmw/mas3cXzRJPMjP83JqEsgSbyrmaGjBfDtV7KDXV9UzFQ==", + "license": "MIT" + }, + "node_modules/@webassemblyjs/helper-buffer": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.14.1.tgz", + "integrity": "sha512-jyH7wtcHiKssDtFPRB+iQdxlDf96m0E39yb0k5uJVhFGleZFoNw1c4aeIcVUPPbXUVJ94wwnMOAqUHyzoEPVMA==", + "license": "MIT" + }, + "node_modules/@webassemblyjs/helper-numbers": { + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.13.2.tgz", + "integrity": "sha512-FE8aCmS5Q6eQYcV3gI35O4J789wlQA+7JrqTTpJqn5emA4U2hvwJmvFRC0HODS+3Ye6WioDklgd6scJ3+PLnEA==", + "license": "MIT", + "dependencies": { + "@webassemblyjs/floating-point-hex-parser": "1.13.2", + "@webassemblyjs/helper-api-error": "1.13.2", + "@xtuc/long": "4.2.2" + } + }, + "node_modules/@webassemblyjs/helper-wasm-bytecode": { + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.13.2.tgz", + "integrity": "sha512-3QbLKy93F0EAIXLh0ogEVR6rOubA9AoZ+WRYhNbFyuB70j3dRdwH9g+qXhLAO0kiYGlg3TxDV+I4rQTr/YNXkA==", + "license": "MIT" + }, + "node_modules/@webassemblyjs/helper-wasm-section": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.14.1.tgz", + "integrity": "sha512-ds5mXEqTJ6oxRoqjhWDU83OgzAYjwsCV8Lo/N+oRsNDmx/ZDpqalmrtgOMkHwxsG0iI//3BwWAErYRHtgn0dZw==", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.14.1", + "@webassemblyjs/helper-buffer": "1.14.1", + "@webassemblyjs/helper-wasm-bytecode": "1.13.2", + "@webassemblyjs/wasm-gen": "1.14.1" + } + }, + "node_modules/@webassemblyjs/ieee754": { + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.13.2.tgz", + "integrity": "sha512-4LtOzh58S/5lX4ITKxnAK2USuNEvpdVV9AlgGQb8rJDHaLeHciwG4zlGr0j/SNWlr7x3vO1lDEsuePvtcDNCkw==", + "license": "MIT", + "dependencies": { + "@xtuc/ieee754": "^1.2.0" + } + }, + "node_modules/@webassemblyjs/leb128": { + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.13.2.tgz", + "integrity": "sha512-Lde1oNoIdzVzdkNEAWZ1dZ5orIbff80YPdHx20mrHwHrVNNTjNr8E3xz9BdpcGqRQbAEa+fkrCb+fRFTl/6sQw==", + "license": "Apache-2.0", + "dependencies": { + "@xtuc/long": "4.2.2" + } + }, + "node_modules/@webassemblyjs/utf8": { + "version": "1.13.2", + "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.13.2.tgz", + "integrity": "sha512-3NQWGjKTASY1xV5m7Hr0iPeXD9+RDobLll3T9d2AO+g3my8xy5peVyjSag4I50mR1bBSN/Ct12lo+R9tJk0NZQ==", + "license": "MIT" + }, + "node_modules/@webassemblyjs/wasm-edit": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.14.1.tgz", + "integrity": "sha512-RNJUIQH/J8iA/1NzlE4N7KtyZNHi3w7at7hDjvRNm5rcUXa00z1vRz3glZoULfJ5mpvYhLybmVcwcjGrC1pRrQ==", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.14.1", + "@webassemblyjs/helper-buffer": "1.14.1", + "@webassemblyjs/helper-wasm-bytecode": "1.13.2", + "@webassemblyjs/helper-wasm-section": "1.14.1", + "@webassemblyjs/wasm-gen": "1.14.1", + "@webassemblyjs/wasm-opt": "1.14.1", + "@webassemblyjs/wasm-parser": "1.14.1", + "@webassemblyjs/wast-printer": "1.14.1" + } + }, + "node_modules/@webassemblyjs/wasm-gen": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.14.1.tgz", + "integrity": "sha512-AmomSIjP8ZbfGQhumkNvgC33AY7qtMCXnN6bL2u2Js4gVCg8fp735aEiMSBbDR7UQIj90n4wKAFUSEd0QN2Ukg==", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.14.1", + "@webassemblyjs/helper-wasm-bytecode": "1.13.2", + "@webassemblyjs/ieee754": "1.13.2", + "@webassemblyjs/leb128": "1.13.2", + "@webassemblyjs/utf8": "1.13.2" + } + }, + "node_modules/@webassemblyjs/wasm-opt": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.14.1.tgz", + "integrity": "sha512-PTcKLUNvBqnY2U6E5bdOQcSM+oVP/PmrDY9NzowJjislEjwP/C4an2303MCVS2Mg9d3AJpIGdUFIQQWbPds0Sw==", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.14.1", + "@webassemblyjs/helper-buffer": "1.14.1", + "@webassemblyjs/wasm-gen": "1.14.1", + "@webassemblyjs/wasm-parser": "1.14.1" + } + }, + "node_modules/@webassemblyjs/wasm-parser": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.14.1.tgz", + "integrity": "sha512-JLBl+KZ0R5qB7mCnud/yyX08jWFw5MsoalJ1pQ4EdFlgj9VdXKGuENGsiCIjegI1W7p91rUlcB/LB5yRJKNTcQ==", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.14.1", + "@webassemblyjs/helper-api-error": "1.13.2", + "@webassemblyjs/helper-wasm-bytecode": "1.13.2", + "@webassemblyjs/ieee754": "1.13.2", + "@webassemblyjs/leb128": "1.13.2", + "@webassemblyjs/utf8": "1.13.2" + } + }, + "node_modules/@webassemblyjs/wast-printer": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.14.1.tgz", + "integrity": "sha512-kPSSXE6De1XOR820C90RIo2ogvZG+c3KiHzqUoO/F34Y2shGzesfqv7o57xrxovZJH/MetF5UjroJ/R/3isoiw==", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.14.1", + "@xtuc/long": "4.2.2" + } + }, + "node_modules/@xtuc/ieee754": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz", + "integrity": "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==", + "license": "BSD-3-Clause" + }, + "node_modules/@xtuc/long": { + "version": "4.2.2", + "resolved": "https://registry.npmjs.org/@xtuc/long/-/long-4.2.2.tgz", + "integrity": "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==", + "license": "Apache-2.0" + }, + "node_modules/abab": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/abab/-/abab-2.0.6.tgz", + "integrity": "sha512-j2afSsaIENvHZN2B8GOpF566vZ5WVk5opAiMTvWgaQT8DkbOqsTfvNAvHoRGU2zzP8cPoqys+xHTRDWW8L+/BA==", + "deprecated": "Use your platform's native atob() and btoa() methods instead", + "license": "BSD-3-Clause" + }, + "node_modules/accepts": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz", + "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==", + "license": "MIT", + "dependencies": { + "mime-types": "~2.1.34", + "negotiator": "0.6.3" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/accepts/node_modules/negotiator": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz", + "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/acorn": { + "version": "8.14.1", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.1.tgz", + "integrity": "sha512-OvQ/2pUDKmgfCg++xsTX1wGxfTaszcHVcTctW4UJB4hibJx2HXxxO5UmVgyjMa+ZDsiaf5wWLXYpRWMmBI0QHg==", + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-globals": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/acorn-globals/-/acorn-globals-6.0.0.tgz", + "integrity": "sha512-ZQl7LOWaF5ePqqcX4hLuv/bLXYQNfNWw2c0/yX/TsPRKamzHcTGQnlCjHT3TsmkOUVEPS3crCxiPfdzE/Trlhg==", + "license": "MIT", + "dependencies": { + "acorn": "^7.1.1", + "acorn-walk": "^7.1.1" + } + }, + "node_modules/acorn-globals/node_modules/acorn": { + "version": "7.4.1", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz", + "integrity": "sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==", + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-jsx": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz", + "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==", + "license": "MIT", + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/acorn-walk": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-7.2.0.tgz", + "integrity": "sha512-OPdCF6GsMIP+Az+aWfAAOEt2/+iVDKE7oy6lJ098aoe59oAmK76qV6Gw60SbZ8jHuG2wH058GF4pLFbYamYrVA==", + "license": "MIT", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/address": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/address/-/address-1.2.2.tgz", + "integrity": "sha512-4B/qKCfeE/ODUaAUpSwfzazo5x29WD4r3vXiWsB7I2mSDAihwEqKO+g8GELZUQSSAo5e1XTYh3ZVfLyxBc12nA==", + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/adjust-sourcemap-loader": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/adjust-sourcemap-loader/-/adjust-sourcemap-loader-4.0.0.tgz", + "integrity": "sha512-OXwN5b9pCUXNQHJpwwD2qP40byEmSgzj8B4ydSN0uMNYWiFmJ6x6KwUllMmfk8Rwu/HJDFR7U8ubsWBoN0Xp0A==", + "license": "MIT", + "dependencies": { + "loader-utils": "^2.0.0", + "regex-parser": "^2.2.11" + }, + "engines": { + "node": ">=8.9" + } + }, + "node_modules/agent-base": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz", + "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==", + "license": "MIT", + "dependencies": { + "debug": "4" + }, + "engines": { + "node": ">= 6.0.0" + } + }, + "node_modules/ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ajv-formats": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-2.1.1.tgz", + "integrity": "sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==", + "license": "MIT", + "dependencies": { + "ajv": "^8.0.0" + }, + "peerDependencies": { + "ajv": "^8.0.0" + }, + "peerDependenciesMeta": { + "ajv": { + "optional": true + } + } + }, + "node_modules/ajv-formats/node_modules/ajv": { + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz", + "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.3", + "fast-uri": "^3.0.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ajv-formats/node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", + "license": "MIT" + }, + "node_modules/ajv-keywords": { + "version": "3.5.2", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz", + "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==", + "license": "MIT", + "peerDependencies": { + "ajv": "^6.9.1" + } + }, + "node_modules/ansi-escapes": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz", + "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==", + "license": "MIT", + "dependencies": { + "type-fest": "^0.21.3" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ansi-html": { + "version": "0.0.9", + "resolved": "https://registry.npmjs.org/ansi-html/-/ansi-html-0.0.9.tgz", + "integrity": "sha512-ozbS3LuenHVxNRh/wdnN16QapUHzauqSomAl1jwwJRRsGwFwtj644lIhxfWu0Fy0acCij2+AEgHvjscq3dlVXg==", + "engines": [ + "node >= 0.8.0" + ], + "license": "Apache-2.0", + "bin": { + "ansi-html": "bin/ansi-html" + } + }, + "node_modules/ansi-html-community": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/ansi-html-community/-/ansi-html-community-0.0.8.tgz", + "integrity": "sha512-1APHAyr3+PCamwNw3bXCPp4HFLONZt/yIH0sZp0/469KWNTEy+qN5jQ3GVX6DMZ1UXAi34yVwtTeaG/HpBuuzw==", + "engines": [ + "node >= 0.8.0" + ], + "license": "Apache-2.0", + "bin": { + "ansi-html": "bin/ansi-html" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/any-promise": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz", + "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==", + "license": "MIT" + }, + "node_modules/anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "license": "ISC", + "dependencies": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/arg": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz", + "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==", + "license": "MIT" + }, + "node_modules/argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "license": "MIT", + "dependencies": { + "sprintf-js": "~1.0.2" + } + }, + "node_modules/aria-query": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz", + "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "dequal": "^2.0.3" + } + }, + "node_modules/array-buffer-byte-length": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/array-buffer-byte-length/-/array-buffer-byte-length-1.0.2.tgz", + "integrity": "sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "is-array-buffer": "^3.0.5" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array-flatten": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz", + "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==", + "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==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "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" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array-union": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/array-union/-/array-union-2.1.0.tgz", + "integrity": "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/array.prototype.findlast": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/array.prototype.findlast/-/array.prototype.findlast-1.2.5.tgz", + "integrity": "sha512-CVvd6FHg1Z3POpBLxO6E6zr+rSKEQ9L6rZHAaY7lLfhKsWYUBBOuMs0e9o24oopj6H+geRCX0YJ+TJLBK2eHyQ==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.2", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0", + "es-shim-unscopables": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array.prototype.findlastindex": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/array.prototype.findlastindex/-/array.prototype.findlastindex-1.2.6.tgz", + "integrity": "sha512-F/TKATkzseUExPlfvmwQKGITM3DGTK+vkAsCZoDc5daVygbJBnjEUCbgkAvVFsgfXfX4YIqZ/27G3k3tdXrTxQ==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.4", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.9", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "es-shim-unscopables": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array.prototype.flat": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.3.tgz", + "integrity": "sha512-rwG/ja1neyLqCuGZ5YYrznA62D4mZXg0i1cIskIUKSiqF3Cje9/wXAls9B9s1Wa2fomMsIv8czB8jZcPmxCXFg==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.5", + "es-shim-unscopables": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array.prototype.flatmap": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.3.tgz", + "integrity": "sha512-Y7Wt51eKJSyi80hFrJCePGGNo5ktJCslFuboqJsbf57CCPcm5zztluPlc4/aD8sWsKvlwatezpV4U1efk8kpjg==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.5", + "es-shim-unscopables": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array.prototype.reduce": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/array.prototype.reduce/-/array.prototype.reduce-1.0.8.tgz", + "integrity": "sha512-DwuEqgXFBwbmZSRqt3BpQigWNUoqw9Ml2dTWdF3B2zQlQX4OeUE0zyuzX0fX0IbTvjdkZbcBTU3idgpO78qkTw==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.4", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.9", + "es-array-method-boxes-properly": "^1.0.0", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "is-string": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array.prototype.tosorted": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/array.prototype.tosorted/-/array.prototype.tosorted-1.1.4.tgz", + "integrity": "sha512-p6Fx8B7b7ZhL/gmUsAy0D15WhvDccw3mnGNbZpi3pmeJdxtWsj2jEaI4Y6oo3XiHfzuSgPwKc04MYt6KgvC/wA==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.3", + "es-errors": "^1.3.0", + "es-shim-unscopables": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/arraybuffer.prototype.slice": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.4.tgz", + "integrity": "sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==", + "license": "MIT", + "dependencies": { + "array-buffer-byte-length": "^1.0.1", + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.5", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6", + "is-array-buffer": "^3.0.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/asap": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/asap/-/asap-2.0.6.tgz", + "integrity": "sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA==", + "license": "MIT" + }, + "node_modules/ast-types-flow": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/ast-types-flow/-/ast-types-flow-0.0.8.tgz", + "integrity": "sha512-OH/2E5Fg20h2aPrbe+QL8JZQFko0YZaF+j4mnQ7BGhfavO7OpSLa8a0y9sBwomHdSbkhTS8TQNayBfnW5DwbvQ==", + "license": "MIT" + }, + "node_modules/async": { + "version": "3.2.6", + "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz", + "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==", + "license": "MIT" + }, + "node_modules/async-function": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/async-function/-/async-function-1.0.0.tgz", + "integrity": "sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==", + "license": "MIT" + }, + "node_modules/at-least-node": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz", + "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==", + "license": "ISC", + "engines": { + "node": ">= 4.0.0" + } + }, + "node_modules/attr-accept": { + "version": "2.2.5", + "resolved": "https://registry.npmjs.org/attr-accept/-/attr-accept-2.2.5.tgz", + "integrity": "sha512-0bDNnY/u6pPwHDMoF0FieU354oBi0a8rD9FcsLwzcGWbc8KS8KPIi7y+s13OlVY+gMWc/9xEMUgNE6Qm8ZllYQ==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/autoprefixer": { + "version": "10.4.21", + "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.21.tgz", + "integrity": "sha512-O+A6LWV5LDHSJD3LjHYoNi4VLsj/Whi7k6zG12xTYaU4cQ8oxQGckXNX8cRHK5yOZ/ppVHe0ZBXGzSV9jXdVbQ==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/autoprefixer" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "browserslist": "^4.24.4", + "caniuse-lite": "^1.0.30001702", + "fraction.js": "^4.3.7", + "normalize-range": "^0.1.2", + "picocolors": "^1.1.1", + "postcss-value-parser": "^4.2.0" + }, + "bin": { + "autoprefixer": "bin/autoprefixer" + }, + "engines": { + "node": "^10 || ^12 || >=14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/available-typed-arrays": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz", + "integrity": "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==", + "license": "MIT", + "dependencies": { + "possible-typed-array-names": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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==", + "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==", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.15.6", + "form-data": "^4.0.0", + "proxy-from-env": "^1.1.0" + } + }, + "node_modules/axobject-query": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/axobject-query/-/axobject-query-4.1.0.tgz", + "integrity": "sha512-qIj0G9wZbMGNLjLmg1PT6v2mE9AH2zlnADJD/2tC6E00hgmhUOfEB6greHPAfLRSufHqROIUTkw6E+M3lH0PTQ==", + "license": "Apache-2.0", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/babel-jest": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/babel-jest/-/babel-jest-27.5.1.tgz", + "integrity": "sha512-cdQ5dXjGRd0IBRATiQ4mZGlGlRE8kJpjPOixdNRdT+m3UcNqmYWN6rK6nvtXYfY3D76cb8s/O1Ss8ea24PIwcg==", + "license": "MIT", + "dependencies": { + "@jest/transform": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/babel__core": "^7.1.14", + "babel-plugin-istanbul": "^6.1.1", + "babel-preset-jest": "^27.5.1", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "slash": "^3.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + }, + "peerDependencies": { + "@babel/core": "^7.8.0" + } + }, + "node_modules/babel-jest/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/babel-jest/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/babel-loader": { + "version": "8.4.1", + "resolved": "https://registry.npmjs.org/babel-loader/-/babel-loader-8.4.1.tgz", + "integrity": "sha512-nXzRChX+Z1GoE6yWavBQg6jDslyFF3SDjl2paADuoQtQW10JqShJt62R6eJQ5m/pjJFDT8xgKIWSP85OY8eXeA==", + "license": "MIT", + "dependencies": { + "find-cache-dir": "^3.3.1", + "loader-utils": "^2.0.4", + "make-dir": "^3.1.0", + "schema-utils": "^2.6.5" + }, + "engines": { + "node": ">= 8.9" + }, + "peerDependencies": { + "@babel/core": "^7.0.0", + "webpack": ">=2" + } + }, + "node_modules/babel-loader/node_modules/schema-utils": { + "version": "2.7.1", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-2.7.1.tgz", + "integrity": "sha512-SHiNtMOUGWBQJwzISiVYKu82GiV4QYGePp3odlY1tuKO7gPtphAT5R/py0fA6xtbgLL/RvtJZnU9b8s0F1q0Xg==", + "license": "MIT", + "dependencies": { + "@types/json-schema": "^7.0.5", + "ajv": "^6.12.4", + "ajv-keywords": "^3.5.2" + }, + "engines": { + "node": ">= 8.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/babel-plugin-istanbul": { + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/babel-plugin-istanbul/-/babel-plugin-istanbul-6.1.1.tgz", + "integrity": "sha512-Y1IQok9821cC9onCx5otgFfRm7Lm+I+wwxOx738M/WLPZ9Q42m4IG5W0FNX8WLL2gYMZo3JkuXIH2DOpWM+qwA==", + "license": "BSD-3-Clause", + "dependencies": { + "@babel/helper-plugin-utils": "^7.0.0", + "@istanbuljs/load-nyc-config": "^1.0.0", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-instrument": "^5.0.4", + "test-exclude": "^6.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/babel-plugin-jest-hoist": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/babel-plugin-jest-hoist/-/babel-plugin-jest-hoist-27.5.1.tgz", + "integrity": "sha512-50wCwD5EMNW4aRpOwtqzyZHIewTYNxLA4nhB+09d8BIssfNfzBRhkBIHiaPv1Si226TQSvp8gxAJm2iY2qs2hQ==", + "license": "MIT", + "dependencies": { + "@babel/template": "^7.3.3", + "@babel/types": "^7.3.3", + "@types/babel__core": "^7.0.0", + "@types/babel__traverse": "^7.0.6" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/babel-plugin-macros": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/babel-plugin-macros/-/babel-plugin-macros-3.1.0.tgz", + "integrity": "sha512-Cg7TFGpIr01vOQNODXOOaGz2NpCU5gl8x1qJFbb6hbZxR7XrcE2vtbAsTAbJ7/xwJtUuJEw8K8Zr/AE0LHlesg==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.12.5", + "cosmiconfig": "^7.0.0", + "resolve": "^1.19.0" + }, + "engines": { + "node": ">=10", + "npm": ">=6" + } + }, + "node_modules/babel-plugin-named-asset-import": { + "version": "0.3.8", + "resolved": "https://registry.npmjs.org/babel-plugin-named-asset-import/-/babel-plugin-named-asset-import-0.3.8.tgz", + "integrity": "sha512-WXiAc++qo7XcJ1ZnTYGtLxmBCVbddAml3CEXgWaBzNzLNoxtQ8AiGEFDMOhot9XjTCQbvP5E77Fj9Gk924f00Q==", + "license": "MIT", + "peerDependencies": { + "@babel/core": "^7.1.0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.22.6", + "@babel/helper-define-polyfill-provider": "^0.6.4", + "semver": "^6.3.1" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/babel-plugin-polyfill-corejs2/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@babel/helper-define-polyfill-provider": "^0.6.3", + "core-js-compat": "^3.40.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==", + "license": "MIT", + "dependencies": { + "@babel/helper-define-polyfill-provider": "^0.6.4" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/babel-plugin-transform-react-remove-prop-types": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/babel-plugin-transform-react-remove-prop-types/-/babel-plugin-transform-react-remove-prop-types-0.4.24.tgz", + "integrity": "sha512-eqj0hVcJUR57/Ug2zE1Yswsw4LhuqqHhD+8v120T1cl3kjg76QwtyBrdIk4WVwK+lAhBJVYCd/v+4nc4y+8JsA==", + "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==", + "license": "MIT", + "dependencies": { + "@babel/plugin-syntax-async-generators": "^7.8.4", + "@babel/plugin-syntax-bigint": "^7.8.3", + "@babel/plugin-syntax-class-properties": "^7.12.13", + "@babel/plugin-syntax-class-static-block": "^7.14.5", + "@babel/plugin-syntax-import-attributes": "^7.24.7", + "@babel/plugin-syntax-import-meta": "^7.10.4", + "@babel/plugin-syntax-json-strings": "^7.8.3", + "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4", + "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3", + "@babel/plugin-syntax-numeric-separator": "^7.10.4", + "@babel/plugin-syntax-object-rest-spread": "^7.8.3", + "@babel/plugin-syntax-optional-catch-binding": "^7.8.3", + "@babel/plugin-syntax-optional-chaining": "^7.8.3", + "@babel/plugin-syntax-private-property-in-object": "^7.14.5", + "@babel/plugin-syntax-top-level-await": "^7.14.5" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/babel-preset-jest": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/babel-preset-jest/-/babel-preset-jest-27.5.1.tgz", + "integrity": "sha512-Nptf2FzlPCWYuJg41HBqXVT8ym6bXOevuCTbhxlUpjwtysGaIWFvDEjp4y+G7fl13FgOdjs7P/DmErqH7da0Ag==", + "license": "MIT", + "dependencies": { + "babel-plugin-jest-hoist": "^27.5.1", + "babel-preset-current-node-syntax": "^1.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/babel-preset-react-app": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/babel-preset-react-app/-/babel-preset-react-app-10.1.0.tgz", + "integrity": "sha512-f9B1xMdnkCIqe+2dHrJsoQFRz7reChaAHE/65SdaykPklQqhme2WaC08oD3is77x9ff98/9EazAKFDZv5rFEQg==", + "license": "MIT", + "dependencies": { + "@babel/core": "^7.16.0", + "@babel/plugin-proposal-class-properties": "^7.16.0", + "@babel/plugin-proposal-decorators": "^7.16.4", + "@babel/plugin-proposal-nullish-coalescing-operator": "^7.16.0", + "@babel/plugin-proposal-numeric-separator": "^7.16.0", + "@babel/plugin-proposal-optional-chaining": "^7.16.0", + "@babel/plugin-proposal-private-methods": "^7.16.0", + "@babel/plugin-proposal-private-property-in-object": "^7.16.7", + "@babel/plugin-transform-flow-strip-types": "^7.16.0", + "@babel/plugin-transform-react-display-name": "^7.16.0", + "@babel/plugin-transform-runtime": "^7.16.4", + "@babel/preset-env": "^7.16.4", + "@babel/preset-react": "^7.16.0", + "@babel/preset-typescript": "^7.16.0", + "@babel/runtime": "^7.16.3", + "babel-plugin-macros": "^3.1.0", + "babel-plugin-transform-react-remove-prop-types": "^0.4.24" + } + }, + "node_modules/babel-preset-react-app/node_modules/@babel/plugin-proposal-private-property-in-object": { + "version": "7.21.11", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.21.11.tgz", + "integrity": "sha512-0QZ8qP/3RLDVBwBFoWAwCtgcDZJVwA5LUJRZU8x2YFfKNuFq161wK3cuGrALu5yiPu+vzwTAg/sMWVNeWeNyaw==", + "deprecated": "This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-private-property-in-object instead.", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.18.6", + "@babel/helper-create-class-features-plugin": "^7.21.0", + "@babel/helper-plugin-utils": "^7.20.2", + "@babel/plugin-syntax-private-property-in-object": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/bail": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz", + "integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "license": "MIT" + }, + "node_modules/batch": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/batch/-/batch-0.6.1.tgz", + "integrity": "sha512-x+VAiMRL6UPkx+kudNvxTl6hB2XNNCG2r+7wixVfIYwu/2HKRXimwQyaumLjMveWvT2Hkd/cAJw+QBMfJ/EKVw==", + "license": "MIT" + }, + "node_modules/bfj": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/bfj/-/bfj-7.1.0.tgz", + "integrity": "sha512-I6MMLkn+anzNdCUp9hMRyui1HaNEUCco50lxbvNS4+EyXg8lN3nJ48PjPWtbH8UVS9CuMoaKE9U2V3l29DaRQw==", + "license": "MIT", + "dependencies": { + "bluebird": "^3.7.2", + "check-types": "^11.2.3", + "hoopy": "^0.1.4", + "jsonpath": "^1.1.1", + "tryer": "^1.0.1" + }, + "engines": { + "node": ">= 8.0.0" + } + }, + "node_modules/big.js": { + "version": "5.2.2", + "resolved": "https://registry.npmjs.org/big.js/-/big.js-5.2.2.tgz", + "integrity": "sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==", + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/binary-extensions": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz", + "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==", + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/bluebird": { + "version": "3.7.2", + "resolved": "https://registry.npmjs.org/bluebird/-/bluebird-3.7.2.tgz", + "integrity": "sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==", + "license": "MIT" + }, + "node_modules/body-parser": { + "version": "1.20.3", + "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz", + "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==", + "license": "MIT", + "dependencies": { + "bytes": "3.1.2", + "content-type": "~1.0.5", + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "on-finished": "2.4.1", + "qs": "6.13.0", + "raw-body": "2.5.2", + "type-is": "~1.6.18", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/body-parser/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/body-parser/node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/body-parser/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, + "node_modules/bonjour-service": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/bonjour-service/-/bonjour-service-1.3.0.tgz", + "integrity": "sha512-3YuAUiSkWykd+2Azjgyxei8OWf8thdn8AITIog2M4UICzoqfjlqr64WIjEXZllf/W6vK1goqleSR6brGomxQqA==", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.3", + "multicast-dns": "^7.2.5" + } + }, + "node_modules/boolbase": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz", + "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==", + "license": "ISC" + }, + "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==", + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/braces": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", + "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", + "license": "MIT", + "dependencies": { + "fill-range": "^7.1.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/browser-process-hrtime": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/browser-process-hrtime/-/browser-process-hrtime-1.0.0.tgz", + "integrity": "sha512-9o5UecI3GhkpM6DrXr69PblIuWxPKk9Y0jHBRhdocZ2y7YECBFCsHm79Pr3OyR2AvjhDkabFJaDJMYRazHgsow==", + "license": "BSD-2-Clause" + }, + "node_modules/browserslist": { + "version": "4.24.4", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.4.tgz", + "integrity": "sha512-KDi1Ny1gSePi1vm0q4oxSF8b4DR44GF4BbmS2YdhPLOEqd8pDviZOGH/GsmRwoWJ2+5Lr085X7naowMwKHDG1A==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "caniuse-lite": "^1.0.30001688", + "electron-to-chromium": "^1.5.73", + "node-releases": "^2.0.19", + "update-browserslist-db": "^1.1.1" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/bser": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/bser/-/bser-2.1.1.tgz", + "integrity": "sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==", + "license": "Apache-2.0", + "dependencies": { + "node-int64": "^0.4.0" + } + }, + "node_modules/buffer-from": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz", + "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==", + "license": "MIT" + }, + "node_modules/builtin-modules": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/builtin-modules/-/builtin-modules-3.3.0.tgz", + "integrity": "sha512-zhaCDicdLuWN5UbN5IMnFqNMhNfo919sH85y2/ea+5Yg9TsTkeZxpL+JLbp6cgYFS4sRLp3YV4S6yDuqVWHYOw==", + "license": "MIT", + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/bytes": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz", + "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/call-bind": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz", + "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.0", + "es-define-property": "^1.0.0", + "get-intrinsic": "^1.2.4", + "set-function-length": "^1.2.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz", + "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/call-bound": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.4.tgz", + "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "get-intrinsic": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/camel-case": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/camel-case/-/camel-case-4.1.2.tgz", + "integrity": "sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==", + "license": "MIT", + "dependencies": { + "pascal-case": "^3.1.2", + "tslib": "^2.0.3" + } + }, + "node_modules/camelcase": { + "version": "6.3.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", + "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/camelcase-css": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz", + "integrity": "sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==", + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/camelize": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/camelize/-/camelize-1.0.1.tgz", + "integrity": "sha512-dU+Tx2fsypxTgtLoE36npi3UqcjSSMNYfkqgmoEhtZrraP5VWq0K7FkWVTYa8eMPtnU/G2txVsfdCJTn9uzpuQ==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/caniuse-api": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/caniuse-api/-/caniuse-api-3.0.0.tgz", + "integrity": "sha512-bsTwuIg/BZZK/vreVTYYbSWoe2F+71P7K5QGEX+pT250DZbfU1MQ5prOKpPR+LL6uWKK3KMwMCAS74QB3Um1uw==", + "license": "MIT", + "dependencies": { + "browserslist": "^4.0.0", + "caniuse-lite": "^1.0.0", + "lodash.memoize": "^4.1.2", + "lodash.uniq": "^4.5.0" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001716", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001716.tgz", + "integrity": "sha512-49/c1+x3Kwz7ZIWt+4DvK3aMJy9oYXXG6/97JKsnjdCk/6n9vVyWL8NAwVt95Lwt9eigI10Hl782kDfZUUlRXw==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "CC-BY-4.0" + }, + "node_modules/case-sensitive-paths-webpack-plugin": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/case-sensitive-paths-webpack-plugin/-/case-sensitive-paths-webpack-plugin-2.4.0.tgz", + "integrity": "sha512-roIFONhcxog0JSSWbvVAh3OocukmSgpqOH6YpMkCvav/ySIV3JKg4Dc8vYtQjYi/UxpNE36r/9v+VqTQqgkYmw==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/ccount": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz", + "integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/char-regex": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-1.0.2.tgz", + "integrity": "sha512-kWWXztvZ5SBQV+eRgKFeh8q5sLuZY2+8WUIzlxWVTg+oGwY14qylx1KbKzHd8P6ZYkAg0xyIDU9JMHhyJMZ1jw==", + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/character-entities": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/character-entities/-/character-entities-2.0.2.tgz", + "integrity": "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/character-entities-html4": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz", + "integrity": "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/character-entities-legacy": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz", + "integrity": "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/character-reference-invalid": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-2.0.1.tgz", + "integrity": "sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/check-types": { + "version": "11.2.3", + "resolved": "https://registry.npmjs.org/check-types/-/check-types-11.2.3.tgz", + "integrity": "sha512-+67P1GkJRaxQD6PKK0Et9DhwQB+vGg3PM5+aavopCpZT1lj9jeqfvpgTLAWErNj8qApkkmXlu/Ug74kmhagkXg==", + "license": "MIT" + }, + "node_modules/chevrotain": { + "version": "11.0.3", + "resolved": "https://registry.npmjs.org/chevrotain/-/chevrotain-11.0.3.tgz", + "integrity": "sha512-ci2iJH6LeIkvP9eJW6gpueU8cnZhv85ELY8w8WiFtNjMHA5ad6pQLaJo9mEly/9qUyCpvqX8/POVUTf18/HFdw==", + "license": "Apache-2.0", + "dependencies": { + "@chevrotain/cst-dts-gen": "11.0.3", + "@chevrotain/gast": "11.0.3", + "@chevrotain/regexp-to-ast": "11.0.3", + "@chevrotain/types": "11.0.3", + "@chevrotain/utils": "11.0.3", + "lodash-es": "4.17.21" + } + }, + "node_modules/chevrotain-allstar": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/chevrotain-allstar/-/chevrotain-allstar-0.3.1.tgz", + "integrity": "sha512-b7g+y9A0v4mxCW1qUhf3BSVPg+/NvGErk/dOkrDaHA0nQIQGAtrOjlX//9OQtRlSCy+x9rfB5N8yC71lH1nvMw==", + "license": "MIT", + "dependencies": { + "lodash-es": "^4.17.21" + }, + "peerDependencies": { + "chevrotain": "^11.0.0" + } + }, + "node_modules/chokidar": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz", + "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==", + "license": "MIT", + "dependencies": { + "anymatch": "~3.1.2", + "braces": "~3.0.2", + "glob-parent": "~5.1.2", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.6.0" + }, + "engines": { + "node": ">= 8.10.0" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/chokidar/node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/chrome-trace-event": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-1.0.4.tgz", + "integrity": "sha512-rNjApaLzuwaOTjCiT8lSDdGN1APCiqkChLMJxJPWLunPAt5fy8xgU9/jNOchV84wfIxrA0lRQB7oCT8jrn/wrQ==", + "license": "MIT", + "engines": { + "node": ">=6.0" + } + }, + "node_modules/ci-info": { + "version": "3.9.0", + "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-3.9.0.tgz", + "integrity": "sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/sibiraj-s" + } + ], + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/cjs-module-lexer": { + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-1.4.3.tgz", + "integrity": "sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q==", + "license": "MIT" + }, + "node_modules/classnames": { + "version": "2.5.1", + "resolved": "https://registry.npmjs.org/classnames/-/classnames-2.5.1.tgz", + "integrity": "sha512-saHYOzhIQs6wy2sVxTM6bUDsQO4F50V9RQ22qBpEdCW+I+/Wmke2HOl6lS6dTpdxVhb88/I6+Hs+438c3lfUow==", + "license": "MIT" + }, + "node_modules/clean-css": { + "version": "5.3.3", + "resolved": "https://registry.npmjs.org/clean-css/-/clean-css-5.3.3.tgz", + "integrity": "sha512-D5J+kHaVb/wKSFcyyV75uCn8fiY4sV38XJoe4CUyGQ+mOU/fMVYUdH1hJC+CJQ5uY3EnW27SbJYS4X8BiLrAFg==", + "license": "MIT", + "dependencies": { + "source-map": "~0.6.0" + }, + "engines": { + "node": ">= 10.0" + } + }, + "node_modules/clean-css/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/cliui": { + "version": "7.0.4", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz", + "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==", + "license": "ISC", + "dependencies": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.0", + "wrap-ansi": "^7.0.0" + } + }, + "node_modules/co": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", + "integrity": "sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ==", + "license": "MIT", + "engines": { + "iojs": ">= 1.0.0", + "node": ">= 0.12.0" + } + }, + "node_modules/coa": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/coa/-/coa-2.0.2.tgz", + "integrity": "sha512-q5/jG+YQnSy4nRTV4F7lPepBJZ8qBNJJDBuJdoejDyLXgmL7IEo+Le2JDZudFTFt7mrCqIRaSjws4ygRCTCAXA==", + "license": "MIT", + "dependencies": { + "@types/q": "^1.5.1", + "chalk": "^2.4.1", + "q": "^1.1.2" + }, + "engines": { + "node": ">= 4.0" + } + }, + "node_modules/coa/node_modules/ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "license": "MIT", + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/coa/node_modules/chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/coa/node_modules/color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "license": "MIT", + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/coa/node_modules/color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "license": "MIT" + }, + "node_modules/coa/node_modules/escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "license": "MIT", + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/coa/node_modules/has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/coa/node_modules/supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "license": "MIT", + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/collect-v8-coverage": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/collect-v8-coverage/-/collect-v8-coverage-1.0.2.tgz", + "integrity": "sha512-lHl4d5/ONEbLlJvaJNtsF/Lz+WvB07u2ycqTYbdrq7UypDXailES4valYb2eWiJFxZlVmpGekfqoxQhzyFdT4Q==", + "license": "MIT" + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "license": "MIT" + }, + "node_modules/colord": { + "version": "2.9.3", + "resolved": "https://registry.npmjs.org/colord/-/colord-2.9.3.tgz", + "integrity": "sha512-jeC1axXpnb0/2nn/Y1LPuLdgXBLH7aDcHu4KEKfqw3CUhX7ZpfBSlPKyqXE6btIgEzfWtrX3/tyBCaCvXvMkOw==", + "license": "MIT" + }, + "node_modules/colorette": { + "version": "2.0.20", + "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz", + "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==", + "license": "MIT" + }, + "node_modules/combined-stream": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", + "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==", + "license": "MIT", + "dependencies": { + "delayed-stream": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/comma-separated-tokens": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz", + "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "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/common-tags": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/common-tags/-/common-tags-1.8.2.tgz", + "integrity": "sha512-gk/Z852D2Wtb//0I+kRFNKKE9dIIVirjoqPoA1wJU+XePVXZfGeBpk45+A1rKO4Q43prqWBNY/MiIeRLbPWUaA==", + "license": "MIT", + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/commondir": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz", + "integrity": "sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==", + "license": "MIT" + }, + "node_modules/compressible": { + "version": "2.0.18", + "resolved": "https://registry.npmjs.org/compressible/-/compressible-2.0.18.tgz", + "integrity": "sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg==", + "license": "MIT", + "dependencies": { + "mime-db": ">= 1.43.0 < 2" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/compression": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/compression/-/compression-1.8.0.tgz", + "integrity": "sha512-k6WLKfunuqCYD3t6AsuPGvQWaKwuLLh2/xHNcX4qE+vIfDNXpSqnrhwA7O53R7WVQUnt8dVAIW+YHr7xTgOgGA==", + "license": "MIT", + "dependencies": { + "bytes": "3.1.2", + "compressible": "~2.0.18", + "debug": "2.6.9", + "negotiator": "~0.6.4", + "on-headers": "~1.0.2", + "safe-buffer": "5.2.1", + "vary": "~1.1.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/compression/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/compression/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "license": "MIT" + }, + "node_modules/confbox": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/confbox/-/confbox-0.2.2.tgz", + "integrity": "sha512-1NB+BKqhtNipMsov4xI/NnhCKp9XG9NamYp5PVm9klAT0fsrNPjaFICsCFhNhwZJKNh7zB/3q8qXz0E9oaMNtQ==", + "license": "MIT" + }, + "node_modules/confusing-browser-globals": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/confusing-browser-globals/-/confusing-browser-globals-1.0.11.tgz", + "integrity": "sha512-JsPKdmh8ZkmnHxDk55FZ1TqVLvEQTvoByJZRN9jzI0UjxK/QgAmsphz7PGtqgPieQZ/CQcHWXCR7ATDNhGe+YA==", + "license": "MIT" + }, + "node_modules/connect-history-api-fallback": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/connect-history-api-fallback/-/connect-history-api-fallback-2.0.0.tgz", + "integrity": "sha512-U73+6lQFmfiNPrYbXqr6kZ1i1wiRqXnp2nhMsINseWXO8lDau0LGEffJ8kQi4EjLZympVgRdvqjAgiZ1tgzDDA==", + "license": "MIT", + "engines": { + "node": ">=0.8" + } + }, + "node_modules/content-disposition": { + "version": "0.5.4", + "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz", + "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==", + "license": "MIT", + "dependencies": { + "safe-buffer": "5.2.1" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/content-type": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz", + "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "license": "MIT" + }, + "node_modules/cookie": { + "version": "0.7.1", + "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz", + "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie-signature": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz", + "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==", + "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==", + "hasInstallScript": true, + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/core-js" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "browserslist": "^4.24.4" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/core-js" + } + }, + "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==", + "hasInstallScript": true, + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/core-js" + } + }, + "node_modules/core-util-is": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz", + "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==", + "license": "MIT" + }, + "node_modules/cose-base": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/cose-base/-/cose-base-1.0.3.tgz", + "integrity": "sha512-s9whTXInMSgAp/NVXVNuVxVKzGH2qck3aQlVHxDCdAEPgtMKwc4Wq6/QKhgdEdgbLSi9rBTAcPoRa6JpiG4ksg==", + "license": "MIT", + "dependencies": { + "layout-base": "^1.0.0" + } + }, + "node_modules/cosmiconfig": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-7.1.0.tgz", + "integrity": "sha512-AdmX6xUzdNASswsFtmwSt7Vj8po9IuqXm0UXz7QKPuEUmPB4XyjGfaAr2PSuELMwkRMVH1EpIkX5bTZGRB3eCA==", + "license": "MIT", + "dependencies": { + "@types/parse-json": "^4.0.0", + "import-fresh": "^3.2.1", + "parse-json": "^5.0.0", + "path-type": "^4.0.0", + "yaml": "^1.10.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/cross-env": { + "version": "7.0.3", + "resolved": "https://registry.npmjs.org/cross-env/-/cross-env-7.0.3.tgz", + "integrity": "sha512-+/HKd6EgcQCJGh2PSjZuUitQBQynKor4wrFbRg4DtAgS1aWO+gU52xpH7M9ScGgXSYmAVS9bIJ8EzuaGw0oNAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "cross-spawn": "^7.0.1" + }, + "bin": { + "cross-env": "src/bin/cross-env.js", + "cross-env-shell": "src/bin/cross-env-shell.js" + }, + "engines": { + "node": ">=10.14", + "npm": ">=6", + "yarn": ">=1" + } + }, + "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/crypto-random-string": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/crypto-random-string/-/crypto-random-string-2.0.0.tgz", + "integrity": "sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/css-blank-pseudo": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/css-blank-pseudo/-/css-blank-pseudo-3.0.3.tgz", + "integrity": "sha512-VS90XWtsHGqoM0t4KpH053c4ehxZ2E6HtGI7x68YFV0pTo/QmkV/YFA+NnlvK8guxZVNWGQhVNJGC39Q8XF4OQ==", + "license": "CC0-1.0", + "dependencies": { + "postcss-selector-parser": "^6.0.9" + }, + "bin": { + "css-blank-pseudo": "dist/cli.cjs" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/css-color-keywords": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/css-color-keywords/-/css-color-keywords-1.0.0.tgz", + "integrity": "sha512-FyyrDHZKEjXDpNJYvVsV960FiqQyXc/LlYmsxl2BcdMb2WPx0OGRVgTg55rPSyLSNMqP52R9r8geSp7apN3Ofg==", + "license": "ISC", + "engines": { + "node": ">=4" + } + }, + "node_modules/css-declaration-sorter": { + "version": "6.4.1", + "resolved": "https://registry.npmjs.org/css-declaration-sorter/-/css-declaration-sorter-6.4.1.tgz", + "integrity": "sha512-rtdthzxKuyq6IzqX6jEcIzQF/YqccluefyCYheovBOLhFT/drQA9zj/UbRAa9J7C0o6EG6u3E6g+vKkay7/k3g==", + "license": "ISC", + "engines": { + "node": "^10 || ^12 || >=14" + }, + "peerDependencies": { + "postcss": "^8.0.9" + } + }, + "node_modules/css-has-pseudo": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/css-has-pseudo/-/css-has-pseudo-3.0.4.tgz", + "integrity": "sha512-Vse0xpR1K9MNlp2j5w1pgWIJtm1a8qS0JwS9goFYcImjlHEmywP9VUF05aGBXzGpDJF86QXk4L0ypBmwPhGArw==", + "license": "CC0-1.0", + "dependencies": { + "postcss-selector-parser": "^6.0.9" + }, + "bin": { + "css-has-pseudo": "dist/cli.cjs" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/css-loader": { + "version": "6.11.0", + "resolved": "https://registry.npmjs.org/css-loader/-/css-loader-6.11.0.tgz", + "integrity": "sha512-CTJ+AEQJjq5NzLga5pE39qdiSV56F8ywCIsqNIRF0r7BDgWsN25aazToqAFg7ZrtA/U016xudB3ffgweORxX7g==", + "license": "MIT", + "dependencies": { + "icss-utils": "^5.1.0", + "postcss": "^8.4.33", + "postcss-modules-extract-imports": "^3.1.0", + "postcss-modules-local-by-default": "^4.0.5", + "postcss-modules-scope": "^3.2.0", + "postcss-modules-values": "^4.0.0", + "postcss-value-parser": "^4.2.0", + "semver": "^7.5.4" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "@rspack/core": "0.x || 1.x", + "webpack": "^5.0.0" + }, + "peerDependenciesMeta": { + "@rspack/core": { + "optional": true + }, + "webpack": { + "optional": true + } + } + }, + "node_modules/css-minimizer-webpack-plugin": { + "version": "3.4.1", + "resolved": "https://registry.npmjs.org/css-minimizer-webpack-plugin/-/css-minimizer-webpack-plugin-3.4.1.tgz", + "integrity": "sha512-1u6D71zeIfgngN2XNRJefc/hY7Ybsxd74Jm4qngIXyUEk7fss3VUzuHxLAq/R8NAba4QU9OUSaMZlbpRc7bM4Q==", + "license": "MIT", + "dependencies": { + "cssnano": "^5.0.6", + "jest-worker": "^27.0.2", + "postcss": "^8.3.5", + "schema-utils": "^4.0.0", + "serialize-javascript": "^6.0.0", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.0.0" + }, + "peerDependenciesMeta": { + "@parcel/css": { + "optional": true + }, + "clean-css": { + "optional": true + }, + "csso": { + "optional": true + }, + "esbuild": { + "optional": true + } + } + }, + "node_modules/css-minimizer-webpack-plugin/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/css-prefers-color-scheme": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/css-prefers-color-scheme/-/css-prefers-color-scheme-6.0.3.tgz", + "integrity": "sha512-4BqMbZksRkJQx2zAjrokiGMd07RqOa2IxIrrN10lyBe9xhn9DEvjUK79J6jkeiv9D9hQFXKb6g1jwU62jziJZA==", + "license": "CC0-1.0", + "bin": { + "css-prefers-color-scheme": "dist/cli.cjs" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/css-select": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-4.3.0.tgz", + "integrity": "sha512-wPpOYtnsVontu2mODhA19JrqWxNsfdatRKd64kmpRbQgh1KtItko5sTnEpPdpSaJszTOhEMlF/RPz28qj4HqhQ==", + "license": "BSD-2-Clause", + "dependencies": { + "boolbase": "^1.0.0", + "css-what": "^6.0.1", + "domhandler": "^4.3.1", + "domutils": "^2.8.0", + "nth-check": "^2.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/css-select-base-adapter": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/css-select-base-adapter/-/css-select-base-adapter-0.1.1.tgz", + "integrity": "sha512-jQVeeRG70QI08vSTwf1jHxp74JoZsr2XSgETae8/xC8ovSnL2WF87GTLO86Sbwdt2lK4Umg4HnnwMO4YF3Ce7w==", + "license": "MIT" + }, + "node_modules/css-to-react-native": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/css-to-react-native/-/css-to-react-native-3.2.0.tgz", + "integrity": "sha512-e8RKaLXMOFii+02mOlqwjbD00KSEKqblnpO9e++1aXS1fPQOpS1YoqdVHBqPjHNoxeF2mimzVqawm2KCbEdtHQ==", + "license": "MIT", + "dependencies": { + "camelize": "^1.0.0", + "css-color-keywords": "^1.0.0", + "postcss-value-parser": "^4.0.2" + } + }, + "node_modules/css-tree": { + "version": "1.0.0-alpha.37", + "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-1.0.0-alpha.37.tgz", + "integrity": "sha512-DMxWJg0rnz7UgxKT0Q1HU/L9BeJI0M6ksor0OgqOnF+aRCDWg/N2641HmVyU9KVIu0OVVWOb2IpC9A+BJRnejg==", + "license": "MIT", + "dependencies": { + "mdn-data": "2.0.4", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/css-tree/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "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==", + "license": "BSD-2-Clause", + "engines": { + "node": ">= 6" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/css.escape": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/css.escape/-/css.escape-1.5.1.tgz", + "integrity": "sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==", + "dev": true, + "license": "MIT" + }, + "node_modules/cssdb": { + "version": "7.11.2", + "resolved": "https://registry.npmjs.org/cssdb/-/cssdb-7.11.2.tgz", + "integrity": "sha512-lhQ32TFkc1X4eTefGfYPvgovRSzIMofHkigfH8nWtyRL4XJLsRhJFreRvEgKzept7x1rjBuy3J/MurXLaFxW/A==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + { + "type": "github", + "url": "https://github.com/sponsors/csstools" + } + ], + "license": "CC0-1.0" + }, + "node_modules/cssesc": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz", + "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==", + "license": "MIT", + "bin": { + "cssesc": "bin/cssesc" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/cssnano": { + "version": "5.1.15", + "resolved": "https://registry.npmjs.org/cssnano/-/cssnano-5.1.15.tgz", + "integrity": "sha512-j+BKgDcLDQA+eDifLx0EO4XSA56b7uut3BQFH+wbSaSTuGLuiyTa/wbRYthUXX8LC9mLg+WWKe8h+qJuwTAbHw==", + "license": "MIT", + "dependencies": { + "cssnano-preset-default": "^5.2.14", + "lilconfig": "^2.0.3", + "yaml": "^1.10.2" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/cssnano" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/cssnano-preset-default": { + "version": "5.2.14", + "resolved": "https://registry.npmjs.org/cssnano-preset-default/-/cssnano-preset-default-5.2.14.tgz", + "integrity": "sha512-t0SFesj/ZV2OTylqQVOrFgEh5uanxbO6ZAdeCrNsUQ6fVuXwYTxJPNAGvGTxHbD68ldIJNec7PyYZDBrfDQ+6A==", + "license": "MIT", + "dependencies": { + "css-declaration-sorter": "^6.3.1", + "cssnano-utils": "^3.1.0", + "postcss-calc": "^8.2.3", + "postcss-colormin": "^5.3.1", + "postcss-convert-values": "^5.1.3", + "postcss-discard-comments": "^5.1.2", + "postcss-discard-duplicates": "^5.1.0", + "postcss-discard-empty": "^5.1.1", + "postcss-discard-overridden": "^5.1.0", + "postcss-merge-longhand": "^5.1.7", + "postcss-merge-rules": "^5.1.4", + "postcss-minify-font-values": "^5.1.0", + "postcss-minify-gradients": "^5.1.1", + "postcss-minify-params": "^5.1.4", + "postcss-minify-selectors": "^5.2.1", + "postcss-normalize-charset": "^5.1.0", + "postcss-normalize-display-values": "^5.1.0", + "postcss-normalize-positions": "^5.1.1", + "postcss-normalize-repeat-style": "^5.1.1", + "postcss-normalize-string": "^5.1.0", + "postcss-normalize-timing-functions": "^5.1.0", + "postcss-normalize-unicode": "^5.1.1", + "postcss-normalize-url": "^5.1.0", + "postcss-normalize-whitespace": "^5.1.1", + "postcss-ordered-values": "^5.1.3", + "postcss-reduce-initial": "^5.1.2", + "postcss-reduce-transforms": "^5.1.0", + "postcss-svgo": "^5.1.0", + "postcss-unique-selectors": "^5.1.1" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/cssnano-utils": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/cssnano-utils/-/cssnano-utils-3.1.0.tgz", + "integrity": "sha512-JQNR19/YZhz4psLX/rQ9M83e3z2Wf/HdJbryzte4a3NSuafyp9w/I4U+hx5C2S9g41qlstH7DEWnZaaj83OuEA==", + "license": "MIT", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/csso": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/csso/-/csso-4.2.0.tgz", + "integrity": "sha512-wvlcdIbf6pwKEk7vHj8/Bkc0B4ylXZruLvOgs9doS5eOsOpuodOV2zJChSpkp+pRpYQLQMeF04nr3Z68Sta9jA==", + "license": "MIT", + "dependencies": { + "css-tree": "^1.1.2" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/csso/node_modules/css-tree": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-1.1.3.tgz", + "integrity": "sha512-tRpdppF7TRazZrjJ6v3stzv93qxRcSsFmW6cX0Zm2NVKpxE1WV1HblnghVv9TreireHkqI/VDEsfolRF1p6y7Q==", + "license": "MIT", + "dependencies": { + "mdn-data": "2.0.14", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/csso/node_modules/mdn-data": { + "version": "2.0.14", + "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.14.tgz", + "integrity": "sha512-dn6wd0uw5GsdswPFfsgMp5NSB0/aDe6fK94YJV/AJDYXL6HVLWBsxeq7js7Ad+mU2K9LAlwpk6kN2D5mwCPVow==", + "license": "CC0-1.0" + }, + "node_modules/csso/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/cssom": { + "version": "0.4.4", + "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.4.4.tgz", + "integrity": "sha512-p3pvU7r1MyyqbTk+WbNJIgJjG2VmTIaB10rI93LzVPrmDJKkzKYMtxxyAvQXR/NS6otuzveI7+7BBq3SjBS2mw==", + "license": "MIT" + }, + "node_modules/cssstyle": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-2.3.0.tgz", + "integrity": "sha512-AZL67abkUzIuvcHqk7c09cezpGNcxUxU4Ioi/05xHk4DQeTkWmGYftIE6ctU6AEt+Gn4n1lDStOtj7FKycP71A==", + "license": "MIT", + "dependencies": { + "cssom": "~0.3.6" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/cssstyle/node_modules/cssom": { + "version": "0.3.8", + "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.3.8.tgz", + "integrity": "sha512-b0tGHbfegbhPJpxpiBPU2sCkigAqtM9O121le6bbOlgyV+NyGyCmVfJ6QW9eRjz8CpNfWEOYBIMIGRYkLwsIYg==", + "license": "MIT" + }, + "node_modules/csstype": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz", + "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==", + "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==", + "license": "MIT", + "engines": { + "node": ">=0.10" + } + }, + "node_modules/cytoscape-cose-bilkent": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/cytoscape-cose-bilkent/-/cytoscape-cose-bilkent-4.1.0.tgz", + "integrity": "sha512-wgQlVIUJF13Quxiv5e1gstZ08rnZj2XaLHGoFMYXz7SkNfCDOOteKBE6SYRfA9WxxI/iBc3ajfDoc6hb/MRAHQ==", + "license": "MIT", + "dependencies": { + "cose-base": "^1.0.0" + }, + "peerDependencies": { + "cytoscape": "^3.2.0" + } + }, + "node_modules/cytoscape-fcose": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/cytoscape-fcose/-/cytoscape-fcose-2.2.0.tgz", + "integrity": "sha512-ki1/VuRIHFCzxWNrsshHYPs6L7TvLu3DL+TyIGEsRcvVERmxokbf5Gdk7mFxZnTdiGtnA4cfSmjZJMviqSuZrQ==", + "license": "MIT", + "dependencies": { + "cose-base": "^2.2.0" + }, + "peerDependencies": { + "cytoscape": "^3.2.0" + } + }, + "node_modules/cytoscape-fcose/node_modules/cose-base": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/cose-base/-/cose-base-2.2.0.tgz", + "integrity": "sha512-AzlgcsCbUMymkADOJtQm3wO9S3ltPfYOFD5033keQn9NJzIbtnZj+UdBJe7DYml/8TdbtHJW3j58SOnKhWY/5g==", + "license": "MIT", + "dependencies": { + "layout-base": "^2.0.0" + } + }, + "node_modules/cytoscape-fcose/node_modules/layout-base": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/layout-base/-/layout-base-2.0.1.tgz", + "integrity": "sha512-dp3s92+uNI1hWIpPGH3jK2kxE2lMjdXdr+DH8ynZHpd6PUlH6x6cbuXnoMmiNumznqaNO31xu9e79F0uuZ0JFg==", + "license": "MIT" + }, + "node_modules/d3": { + "version": "7.9.0", + "resolved": "https://registry.npmjs.org/d3/-/d3-7.9.0.tgz", + "integrity": "sha512-e1U46jVP+w7Iut8Jt8ri1YsPOvFpg46k+K8TpCb0P+zjCkjkPnV7WzfDJzMHy1LnA+wj5pLT1wjO901gLXeEhA==", + "license": "ISC", + "dependencies": { + "d3-array": "3", + "d3-axis": "3", + "d3-brush": "3", + "d3-chord": "3", + "d3-color": "3", + "d3-contour": "4", + "d3-delaunay": "6", + "d3-dispatch": "3", + "d3-drag": "3", + "d3-dsv": "3", + "d3-ease": "3", + "d3-fetch": "3", + "d3-force": "3", + "d3-format": "3", + "d3-geo": "3", + "d3-hierarchy": "3", + "d3-interpolate": "3", + "d3-path": "3", + "d3-polygon": "3", + "d3-quadtree": "3", + "d3-random": "3", + "d3-scale": "4", + "d3-scale-chromatic": "3", + "d3-selection": "3", + "d3-shape": "3", + "d3-time": "3", + "d3-time-format": "4", + "d3-timer": "3", + "d3-transition": "3", + "d3-zoom": "3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-array": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-3.2.4.tgz", + "integrity": "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==", + "license": "ISC", + "dependencies": { + "internmap": "1 - 2" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-axis": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-axis/-/d3-axis-3.0.0.tgz", + "integrity": "sha512-IH5tgjV4jE/GhHkRV0HiVYPDtvfjHQlQfJHs0usq7M30XcSBvOotpmH1IgkcXsO/5gEQZD43B//fc7SRT5S+xw==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-brush": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-brush/-/d3-brush-3.0.0.tgz", + "integrity": "sha512-ALnjWlVYkXsVIGlOsuWH1+3udkYFI48Ljihfnh8FZPF2QS9o+PzGLBslO0PjzVoHLZ2KCVgAM8NVkXPJB2aNnQ==", + "license": "ISC", + "dependencies": { + "d3-dispatch": "1 - 3", + "d3-drag": "2 - 3", + "d3-interpolate": "1 - 3", + "d3-selection": "3", + "d3-transition": "3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-chord": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-chord/-/d3-chord-3.0.1.tgz", + "integrity": "sha512-VE5S6TNa+j8msksl7HwjxMHDM2yNK3XCkusIlpX5kwauBfXuyLAtNg9jCp/iHH61tgI4sb6R/EIMWCqEIdjT/g==", + "license": "ISC", + "dependencies": { + "d3-path": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-color": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz", + "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-contour": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/d3-contour/-/d3-contour-4.0.2.tgz", + "integrity": "sha512-4EzFTRIikzs47RGmdxbeUvLWtGedDUNkTcmzoeyg4sP/dvCexO47AaQL7VKy/gul85TOxw+IBgA8US2xwbToNA==", + "license": "ISC", + "dependencies": { + "d3-array": "^3.2.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-delaunay": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/d3-delaunay/-/d3-delaunay-6.0.4.tgz", + "integrity": "sha512-mdjtIZ1XLAM8bm/hx3WwjfHt6Sggek7qH043O8KEjDXN40xi3vx/6pYSVTwLjEgiXQTbvaouWKynLBiUZ6SK6A==", + "license": "ISC", + "dependencies": { + "delaunator": "5" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-dispatch": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-dispatch/-/d3-dispatch-3.0.1.tgz", + "integrity": "sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-drag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-drag/-/d3-drag-3.0.0.tgz", + "integrity": "sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg==", + "license": "ISC", + "dependencies": { + "d3-dispatch": "1 - 3", + "d3-selection": "3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-dsv": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-dsv/-/d3-dsv-3.0.1.tgz", + "integrity": "sha512-UG6OvdI5afDIFP9w4G0mNq50dSOsXHJaRE8arAS5o9ApWnIElp8GZw1Dun8vP8OyHOZ/QJUKUJwxiiCCnUwm+Q==", + "license": "ISC", + "dependencies": { + "commander": "7", + "iconv-lite": "0.6", + "rw": "1" + }, + "bin": { + "csv2json": "bin/dsv2json.js", + "csv2tsv": "bin/dsv2dsv.js", + "dsv2dsv": "bin/dsv2dsv.js", + "dsv2json": "bin/dsv2json.js", + "json2csv": "bin/json2dsv.js", + "json2dsv": "bin/json2dsv.js", + "json2tsv": "bin/json2dsv.js", + "tsv2csv": "bin/dsv2dsv.js", + "tsv2json": "bin/dsv2json.js" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-ease": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz", + "integrity": "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-fetch": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-fetch/-/d3-fetch-3.0.1.tgz", + "integrity": "sha512-kpkQIM20n3oLVBKGg6oHrUchHM3xODkTzjMoj7aWQFq5QEM+R6E4WkzT5+tojDY7yjez8KgCBRoj4aEr99Fdqw==", + "license": "ISC", + "dependencies": { + "d3-dsv": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-force": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-force/-/d3-force-3.0.0.tgz", + "integrity": "sha512-zxV/SsA+U4yte8051P4ECydjD/S+qeYtnaIyAs9tgHCqfguma/aAQDjo85A9Z6EKhBirHRJHXIgJUlffT4wdLg==", + "license": "ISC", + "dependencies": { + "d3-dispatch": "1 - 3", + "d3-quadtree": "1 - 3", + "d3-timer": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-format": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-3.1.0.tgz", + "integrity": "sha512-YyUI6AEuY/Wpt8KWLgZHsIU86atmikuoOmCfommt0LYHiQSPjvX2AcFc38PX0CBpr2RCyZhjex+NS/LPOv6YqA==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-geo": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/d3-geo/-/d3-geo-3.1.1.tgz", + "integrity": "sha512-637ln3gXKXOwhalDzinUgY83KzNWZRKbYubaG+fGVuc/dxO64RRljtCTnf5ecMyE1RIdtqpkVcq0IbtU2S8j2Q==", + "license": "ISC", + "dependencies": { + "d3-array": "2.5.0 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-hierarchy": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/d3-hierarchy/-/d3-hierarchy-3.1.2.tgz", + "integrity": "sha512-FX/9frcub54beBdugHjDCdikxThEqjnR93Qt7PvQTOHxyiNCAlvMrHhclk3cD5VeAaq9fxmfRp+CnWw9rEMBuA==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-interpolate": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz", + "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==", + "license": "ISC", + "dependencies": { + "d3-color": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-path": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-3.1.0.tgz", + "integrity": "sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-polygon": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-polygon/-/d3-polygon-3.0.1.tgz", + "integrity": "sha512-3vbA7vXYwfe1SYhED++fPUQlWSYTTGmFmQiany/gdbiWgU/iEyQzyymwL9SkJjFFuCS4902BSzewVGsHHmHtXg==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-quadtree": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-quadtree/-/d3-quadtree-3.0.1.tgz", + "integrity": "sha512-04xDrxQTDTCFwP5H6hRhsRcb9xxv2RzkcsygFzmkSIOJy3PeRJP7sNk3VRIbKXcog561P9oU0/rVH6vDROAgUw==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-random": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-random/-/d3-random-3.0.1.tgz", + "integrity": "sha512-FXMe9GfxTxqd5D6jFsQ+DJ8BJS4E/fT5mqqdjovykEB2oFbTMDVdg1MGFxfQW+FBOGoB++k8swBrgwSHT1cUXQ==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-sankey": { + "version": "0.12.3", + "resolved": "https://registry.npmjs.org/d3-sankey/-/d3-sankey-0.12.3.tgz", + "integrity": "sha512-nQhsBRmM19Ax5xEIPLMY9ZmJ/cDvd1BG3UVvt5h3WRxKg5zGRbvnteTyWAbzeSvlh3tW7ZEmq4VwR5mB3tutmQ==", + "license": "BSD-3-Clause", + "dependencies": { + "d3-array": "1 - 2", + "d3-shape": "^1.2.0" + } + }, + "node_modules/d3-sankey/node_modules/d3-array": { + "version": "2.12.1", + "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-2.12.1.tgz", + "integrity": "sha512-B0ErZK/66mHtEsR1TkPEEkwdy+WDesimkM5gpZr5Dsg54BiTA5RXtYW5qTLIAcekaS9xfZrzBLF/OAkB3Qn1YQ==", + "license": "BSD-3-Clause", + "dependencies": { + "internmap": "^1.0.0" + } + }, + "node_modules/d3-sankey/node_modules/d3-path": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-1.0.9.tgz", + "integrity": "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg==", + "license": "BSD-3-Clause" + }, + "node_modules/d3-sankey/node_modules/d3-shape": { + "version": "1.3.7", + "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-1.3.7.tgz", + "integrity": "sha512-EUkvKjqPFUAZyOlhY5gzCxCeI0Aep04LwIRpsZ/mLFelJiUfnK56jo5JMDSE7yyP2kLSb6LtF+S5chMk7uqPqw==", + "license": "BSD-3-Clause", + "dependencies": { + "d3-path": "1" + } + }, + "node_modules/d3-sankey/node_modules/internmap": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/internmap/-/internmap-1.0.1.tgz", + "integrity": "sha512-lDB5YccMydFBtasVtxnZ3MRBHuaoE8GKsppq+EchKL2U4nK/DmEpPHNH8MZe5HkMtpSiTSOZwfN0tzYjO/lJEw==", + "license": "ISC" + }, + "node_modules/d3-scale": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/d3-scale/-/d3-scale-4.0.2.tgz", + "integrity": "sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==", + "license": "ISC", + "dependencies": { + "d3-array": "2.10.0 - 3", + "d3-format": "1 - 3", + "d3-interpolate": "1.2.0 - 3", + "d3-time": "2.1.1 - 3", + "d3-time-format": "2 - 4" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-scale-chromatic": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-scale-chromatic/-/d3-scale-chromatic-3.1.0.tgz", + "integrity": "sha512-A3s5PWiZ9YCXFye1o246KoscMWqf8BsD9eRiJ3He7C9OBaxKhAd5TFCdEx/7VbKtxxTsu//1mMJFrEt572cEyQ==", + "license": "ISC", + "dependencies": { + "d3-color": "1 - 3", + "d3-interpolate": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-selection": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz", + "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-shape": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-3.2.0.tgz", + "integrity": "sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA==", + "license": "ISC", + "dependencies": { + "d3-path": "^3.1.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-time": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-time/-/d3-time-3.1.0.tgz", + "integrity": "sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==", + "license": "ISC", + "dependencies": { + "d3-array": "2 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-time-format": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/d3-time-format/-/d3-time-format-4.1.0.tgz", + "integrity": "sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==", + "license": "ISC", + "dependencies": { + "d3-time": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-timer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz", + "integrity": "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-transition": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-transition/-/d3-transition-3.0.1.tgz", + "integrity": "sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w==", + "license": "ISC", + "dependencies": { + "d3-color": "1 - 3", + "d3-dispatch": "1 - 3", + "d3-ease": "1 - 3", + "d3-interpolate": "1 - 3", + "d3-timer": "1 - 3" + }, + "engines": { + "node": ">=12" + }, + "peerDependencies": { + "d3-selection": "2 - 3" + } + }, + "node_modules/d3-zoom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-zoom/-/d3-zoom-3.0.0.tgz", + "integrity": "sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw==", + "license": "ISC", + "dependencies": { + "d3-dispatch": "1 - 3", + "d3-drag": "2 - 3", + "d3-interpolate": "1 - 3", + "d3-selection": "2 - 3", + "d3-transition": "2 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/dagre-d3-es": { + "version": "7.0.11", + "resolved": "https://registry.npmjs.org/dagre-d3-es/-/dagre-d3-es-7.0.11.tgz", + "integrity": "sha512-tvlJLyQf834SylNKax8Wkzco/1ias1OPw8DcUMDE7oUIoSEW25riQVuiu/0OWEFqT0cxHT3Pa9/D82Jr47IONw==", + "license": "MIT", + "dependencies": { + "d3": "^7.9.0", + "lodash-es": "^4.17.21" + } + }, + "node_modules/damerau-levenshtein": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/damerau-levenshtein/-/damerau-levenshtein-1.0.8.tgz", + "integrity": "sha512-sdQSFB7+llfUcQHUQO3+B8ERRj0Oa4w9POWMI/puGtuf7gFywGmkaLCElnudfTiKZV+NvHqL0ifzdrI8Ro7ESA==", + "license": "BSD-2-Clause" + }, + "node_modules/data-urls": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-2.0.0.tgz", + "integrity": "sha512-X5eWTSXO/BJmpdIKCRuKUgSCgAN0OwliVK3yPKbwIWU1Tdw5BRajxlzMidvh+gwko9AfQ9zIj52pzF91Q3YAvQ==", + "license": "MIT", + "dependencies": { + "abab": "^2.0.3", + "whatwg-mimetype": "^2.3.0", + "whatwg-url": "^8.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/data-view-buffer": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/data-view-buffer/-/data-view-buffer-1.0.2.tgz", + "integrity": "sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "es-errors": "^1.3.0", + "is-data-view": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/data-view-byte-length": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/data-view-byte-length/-/data-view-byte-length-1.0.2.tgz", + "integrity": "sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "es-errors": "^1.3.0", + "is-data-view": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/inspect-js" + } + }, + "node_modules/data-view-byte-offset": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/data-view-byte-offset/-/data-view-byte-offset-1.0.1.tgz", + "integrity": "sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "is-data-view": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/date-fns": { + "version": "2.30.0", + "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-2.30.0.tgz", + "integrity": "sha512-fnULvOpxnC5/Vg3NCiWelDsLiUc9bRwAPs/+LfTLNvetFCtCTN+yQz15C/fs4AwX1R9K5GLtLfn8QW+dWisaAw==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.21.0" + }, + "engines": { + "node": ">=0.11" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/date-fns" + } + }, + "node_modules/dayjs": { + "version": "1.11.13", + "resolved": "https://registry.npmjs.org/dayjs/-/dayjs-1.11.13.tgz", + "integrity": "sha512-oaMBel6gjolK862uaPQOVTA7q3TZhuSvuMQAAglQDOWYO9A91IrAOUJEyKVlqJlHE0vq5p5UXxzdPfMH/x6xNg==", + "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==", + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "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==", + "license": "MIT" + }, + "node_modules/decode-named-character-reference": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.1.0.tgz", + "integrity": "sha512-Wy+JTSbFThEOXQIR2L6mxJvEs+veIzpmqD7ynWxMXGpnk3smkHQOp6forLdHsKpAMW9iJpaBBIxz285t1n1C3w==", + "license": "MIT", + "dependencies": { + "character-entities": "^2.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/dedent": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/dedent/-/dedent-0.7.0.tgz", + "integrity": "sha512-Q6fKUPqnAHAyhiUgFU7BUzLiv0kd8saH9al7tnu5Q/okj6dnupxyTgFIBjVzJATdfIAm9NAsvXNzjaKa+bxVyA==", + "license": "MIT" + }, + "node_modules/deep-equal": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-2.2.3.tgz", + "integrity": "sha512-ZIwpnevOurS8bpT4192sqAowWM76JDKSHYzMLty3BZGSswgq6pBaH3DhCSW5xVAZICZyKdOBPjwww5wfgT/6PA==", + "dev": true, + "license": "MIT", + "dependencies": { + "array-buffer-byte-length": "^1.0.0", + "call-bind": "^1.0.5", + "es-get-iterator": "^1.1.3", + "get-intrinsic": "^1.2.2", + "is-arguments": "^1.1.1", + "is-array-buffer": "^3.0.2", + "is-date-object": "^1.0.5", + "is-regex": "^1.1.4", + "is-shared-array-buffer": "^1.0.2", + "isarray": "^2.0.5", + "object-is": "^1.1.5", + "object-keys": "^1.1.1", + "object.assign": "^4.1.4", + "regexp.prototype.flags": "^1.5.1", + "side-channel": "^1.0.4", + "which-boxed-primitive": "^1.0.2", + "which-collection": "^1.0.1", + "which-typed-array": "^1.1.13" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/deep-is": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz", + "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==", + "license": "MIT" + }, + "node_modules/deepmerge": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz", + "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/default-gateway": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/default-gateway/-/default-gateway-6.0.3.tgz", + "integrity": "sha512-fwSOJsbbNzZ/CUFpqFBqYfYNLj1NbMPm8MMCIzHjC83iSJRBEGmDUxU+WP661BaBQImeC2yHwXtz+P/O9o+XEg==", + "license": "BSD-2-Clause", + "dependencies": { + "execa": "^5.0.0" + }, + "engines": { + "node": ">= 10" + } + }, + "node_modules/define-data-property": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz", + "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==", + "license": "MIT", + "dependencies": { + "es-define-property": "^1.0.0", + "es-errors": "^1.3.0", + "gopd": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/define-lazy-prop": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz", + "integrity": "sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/define-properties": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz", + "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==", + "license": "MIT", + "dependencies": { + "define-data-property": "^1.0.1", + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/delaunator": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/delaunator/-/delaunator-5.0.1.tgz", + "integrity": "sha512-8nvh+XBe96aCESrGOqMp/84b13H9cdKbG5P2ejQCh4d4sK9RL4371qou9drQjMhvnPmhWl5hnmqbEE0fXr9Xnw==", + "license": "ISC", + "dependencies": { + "robust-predicates": "^3.0.2" + } + }, + "node_modules/delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==", + "license": "MIT", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/depd": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", + "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/dequal": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz", + "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/destroy": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz", + "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==", + "license": "MIT", + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/detect-newline": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/detect-newline/-/detect-newline-3.1.0.tgz", + "integrity": "sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/detect-node": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/detect-node/-/detect-node-2.1.0.tgz", + "integrity": "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==", + "license": "MIT" + }, + "node_modules/detect-port-alt": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/detect-port-alt/-/detect-port-alt-1.1.6.tgz", + "integrity": "sha512-5tQykt+LqfJFBEYaDITx7S7cR7mJ/zQmLXZ2qt5w04ainYZw6tBf9dBunMjVeVOdYVRUzUOE4HkY5J7+uttb5Q==", + "license": "MIT", + "dependencies": { + "address": "^1.0.1", + "debug": "^2.6.0" + }, + "bin": { + "detect": "bin/detect-port", + "detect-port": "bin/detect-port" + }, + "engines": { + "node": ">= 4.2.1" + } + }, + "node_modules/detect-port-alt/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/detect-port-alt/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, + "node_modules/devlop": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz", + "integrity": "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==", + "license": "MIT", + "dependencies": { + "dequal": "^2.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/didyoumean": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz", + "integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==", + "license": "Apache-2.0" + }, + "node_modules/diff-sequences": { + "version": "29.6.3", + "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-29.6.3.tgz", + "integrity": "sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/dir-glob": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/dir-glob/-/dir-glob-3.0.1.tgz", + "integrity": "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==", + "license": "MIT", + "dependencies": { + "path-type": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/dlv": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz", + "integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==", + "license": "MIT" + }, + "node_modules/dns-packet": { + "version": "5.6.1", + "resolved": "https://registry.npmjs.org/dns-packet/-/dns-packet-5.6.1.tgz", + "integrity": "sha512-l4gcSouhcgIKRvyy99RNVOgxXiicE+2jZoNmaNmZ6JXiGajBOJAesk1OBlJuM5k2c+eudGdLxDqXuPCKIj6kpw==", + "license": "MIT", + "dependencies": { + "@leichtgewicht/ip-codec": "^2.0.1" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/doctrine": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz", + "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==", + "license": "Apache-2.0", + "dependencies": { + "esutils": "^2.0.2" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/dom-accessibility-api": { + "version": "0.5.16", + "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz", + "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==", + "dev": true, + "license": "MIT" + }, + "node_modules/dom-converter": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/dom-converter/-/dom-converter-0.2.0.tgz", + "integrity": "sha512-gd3ypIPfOMr9h5jIKq8E3sHOTCjeirnl0WK5ZdS1AW0Odt0b1PaWaHdJ4Qk4klv+YB9aJBS7mESXjFoDQPu6DA==", + "license": "MIT", + "dependencies": { + "utila": "~0.4" + } + }, + "node_modules/dom-lib": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/dom-lib/-/dom-lib-3.3.2.tgz", + "integrity": "sha512-ux0wcf6lggOCcJ6O3Q3mewbCOM/CL9f6+NXmxaWsF0/AKCvFNbfdmmqNnMG7cMVupCr9VeFEYWspSAD9WT/6gA==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.20.0" + } + }, + "node_modules/dom-serializer": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-1.4.1.tgz", + "integrity": "sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==", + "license": "MIT", + "dependencies": { + "domelementtype": "^2.0.1", + "domhandler": "^4.2.0", + "entities": "^2.0.0" + }, + "funding": { + "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1" + } + }, + "node_modules/domelementtype": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz", + "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/fb55" + } + ], + "license": "BSD-2-Clause" + }, + "node_modules/domexception": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/domexception/-/domexception-2.0.1.tgz", + "integrity": "sha512-yxJ2mFy/sibVQlu5qHjOkf9J3K6zgmCxgJ94u2EdvDOV09H+32LtRswEcUsmUWN72pVLOEnTSRaIVVzVQgS0dg==", + "deprecated": "Use your platform's native DOMException instead", + "license": "MIT", + "dependencies": { + "webidl-conversions": "^5.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/domexception/node_modules/webidl-conversions": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-5.0.0.tgz", + "integrity": "sha512-VlZwKPCkYKxQgeSbH5EyngOmRp7Ww7I9rQLERETtf5ofd9pGeswWiOtogpEO850jziPRarreGxn5QIiTqpb2wA==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=8" + } + }, + "node_modules/domhandler": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-4.3.1.tgz", + "integrity": "sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==", + "license": "BSD-2-Clause", + "dependencies": { + "domelementtype": "^2.2.0" + }, + "engines": { + "node": ">= 4" + }, + "funding": { + "url": "https://github.com/fb55/domhandler?sponsor=1" + } + }, + "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==", + "license": "(MPL-2.0 OR Apache-2.0)", + "optionalDependencies": { + "@types/trusted-types": "^2.0.7" + } + }, + "node_modules/domutils": { + "version": "2.8.0", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.8.0.tgz", + "integrity": "sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==", + "license": "BSD-2-Clause", + "dependencies": { + "dom-serializer": "^1.0.1", + "domelementtype": "^2.2.0", + "domhandler": "^4.2.0" + }, + "funding": { + "url": "https://github.com/fb55/domutils?sponsor=1" + } + }, + "node_modules/dot-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/dot-case/-/dot-case-3.0.4.tgz", + "integrity": "sha512-Kv5nKlh6yRrdrGvxeJ2e5y2eRUpkUosIW4A2AS38zwSz27zu7ufDwQPi5Jhs3XAlGNetl3bmnGhQsMtkKJnj3w==", + "license": "MIT", + "dependencies": { + "no-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/dotenv": { + "version": "10.0.0", + "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-10.0.0.tgz", + "integrity": "sha512-rlBi9d8jpv9Sf1klPjNfFAuWDjKLwTIJJ/VxtoTwIR6hnZxcEOQCZg2oIL3MWBYw5GpUDKOEnND7LXTbIpQ03Q==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=10" + } + }, + "node_modules/dotenv-expand": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/dotenv-expand/-/dotenv-expand-5.1.0.tgz", + "integrity": "sha512-YXQl1DSa4/PQyRfgrv6aoNjhasp/p4qs9FjJ4q4cQk+8m4r6k4ZSiEyytKG8f8W9gi8WsQtIObNmKd+tMzNTmA==", + "license": "BSD-2-Clause" + }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/duplexer": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.2.tgz", + "integrity": "sha512-jtD6YG370ZCIi/9GTaJKQxWTZD045+4R4hTk/x1UyoqadyJ9x9CgSi1RlVDQF8U2sxLLSnFkCaMihqljHIWgMg==", + "license": "MIT" + }, + "node_modules/eastasianwidth": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz", + "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==", + "license": "MIT" + }, + "node_modules/ee-first": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz", + "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==", + "license": "MIT" + }, + "node_modules/ejs": { + "version": "3.1.10", + "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.10.tgz", + "integrity": "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==", + "license": "Apache-2.0", + "dependencies": { + "jake": "^10.8.5" + }, + "bin": { + "ejs": "bin/cli.js" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/electron-to-chromium": { + "version": "1.5.149", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.149.tgz", + "integrity": "sha512-UyiO82eb9dVOx8YO3ajDf9jz2kKyt98DEITRdeLPstOEuTlLzDA4Gyq5K9he71TQziU5jUVu2OAu5N48HmQiyQ==", + "license": "ISC" + }, + "node_modules/emittery": { + "version": "0.8.1", + "resolved": "https://registry.npmjs.org/emittery/-/emittery-0.8.1.tgz", + "integrity": "sha512-uDfvUjVrfGJJhymx/kz6prltenw1u7WrCg1oa94zYY8xxVpLLUu045LAT0dhDZdXG58/EpPL/5kA180fQ/qudg==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sindresorhus/emittery?sponsor=1" + } + }, + "node_modules/emoji-regex": { + "version": "9.2.2", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz", + "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==", + "license": "MIT" + }, + "node_modules/emojis-list": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/emojis-list/-/emojis-list-3.0.0.tgz", + "integrity": "sha512-/kyM18EfinwXZbno9FyUGeFh87KC8HRQBQGildHZbEuRyWFOmv1U10o9BBp8XVZDVNNuQKyIGIu5ZYAAXJ0V2Q==", + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/encodeurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz", + "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/enhanced-resolve": { + "version": "5.18.1", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.18.1.tgz", + "integrity": "sha512-ZSW3ma5GkcQBIpwZTSRAI8N71Uuwgs93IezB7mf7R60tC8ZbJideoDNKjHn2O9KIlx6rkGTTEk1xUCK2E1Y2Yg==", + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.4", + "tapable": "^2.2.0" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/entities": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-2.2.0.tgz", + "integrity": "sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==", + "license": "BSD-2-Clause", + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "is-arrayish": "^0.2.1" + } + }, + "node_modules/error-stack-parser": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/error-stack-parser/-/error-stack-parser-2.1.4.tgz", + "integrity": "sha512-Sk5V6wVazPhq5MhpO+AUxJn5x7XSXGl1R93Vn7i+zS15KDVxQijejNCrz8340/2bgLBjR9GtEG8ZVKONDjcqGQ==", + "license": "MIT", + "dependencies": { + "stackframe": "^1.3.4" + } + }, + "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==", + "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", + "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-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-symbol-description": "^1.1.0", + "globalthis": "^1.0.4", + "gopd": "^1.2.0", + "has-property-descriptors": "^1.0.2", + "has-proto": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "internal-slot": "^1.1.0", + "is-array-buffer": "^3.0.5", + "is-callable": "^1.2.7", + "is-data-view": "^1.0.2", + "is-regex": "^1.2.1", + "is-shared-array-buffer": "^1.0.4", + "is-string": "^1.1.1", + "is-typed-array": "^1.1.15", + "is-weakref": "^1.1.0", + "math-intrinsics": "^1.1.0", + "object-inspect": "^1.13.3", + "object-keys": "^1.1.1", + "object.assign": "^4.1.7", + "own-keys": "^1.0.1", + "regexp.prototype.flags": "^1.5.3", + "safe-array-concat": "^1.1.3", + "safe-push-apply": "^1.0.0", + "safe-regex-test": "^1.1.0", + "set-proto": "^1.0.0", + "string.prototype.trim": "^1.2.10", + "string.prototype.trimend": "^1.0.9", + "string.prototype.trimstart": "^1.0.8", + "typed-array-buffer": "^1.0.3", + "typed-array-byte-length": "^1.0.3", + "typed-array-byte-offset": "^1.0.4", + "typed-array-length": "^1.0.7", + "unbox-primitive": "^1.1.0", + "which-typed-array": "^1.1.18" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/es-array-method-boxes-properly": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/es-array-method-boxes-properly/-/es-array-method-boxes-properly-1.0.0.tgz", + "integrity": "sha512-wd6JXUmyHmt8T5a2xreUwKcGPq6f1f+WwIJkijUqiGcJz1qqnZgP6XIK+QyIWU5lT7imeNxUll48bziG+TSYcA==", + "license": "MIT" + }, + "node_modules/es-define-property": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-get-iterator": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/es-get-iterator/-/es-get-iterator-1.1.3.tgz", + "integrity": "sha512-sPZmqHBe6JIiTfN5q2pEi//TwxmAFHwj/XEuYjTuse78i8KxaqMTTzxPoFKuzRpDpTJ+0NAbpfenkmH2rePtuw==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.1.3", + "has-symbols": "^1.0.3", + "is-arguments": "^1.1.1", + "is-map": "^2.0.2", + "is-set": "^2.0.2", + "is-string": "^1.0.7", + "isarray": "^2.0.5", + "stop-iteration-iterator": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/es-iterator-helpers": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/es-iterator-helpers/-/es-iterator-helpers-1.2.1.tgz", + "integrity": "sha512-uDn+FE1yrDzyC0pCo961B2IHbdM8y/ACZsKD4dG6WqrjV53BADjwa7D+1aom2rsNVfLyDgU/eigvlJGJ08OQ4w==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.6", + "es-errors": "^1.3.0", + "es-set-tostringtag": "^2.0.3", + "function-bind": "^1.1.2", + "get-intrinsic": "^1.2.6", + "globalthis": "^1.0.4", + "gopd": "^1.2.0", + "has-property-descriptors": "^1.0.2", + "has-proto": "^1.2.0", + "has-symbols": "^1.1.0", + "internal-slot": "^1.1.0", + "iterator.prototype": "^1.1.4", + "safe-array-concat": "^1.1.3" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-module-lexer": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz", + "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==", + "license": "MIT" + }, + "node_modules/es-object-atoms": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz", + "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-set-tostringtag": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz", + "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-shim-unscopables": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/es-shim-unscopables/-/es-shim-unscopables-1.1.0.tgz", + "integrity": "sha512-d9T8ucsEhh8Bi1woXCf+TIKDIROLG5WCkxg8geBCbvk22kzwC5G2OnXVMO6FUsvQlgUUXQ2itephWDLqDzbeCw==", + "license": "MIT", + "dependencies": { + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-to-primitive": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.3.0.tgz", + "integrity": "sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g==", + "license": "MIT", + "dependencies": { + "is-callable": "^1.2.7", + "is-date-object": "^1.0.5", + "is-symbol": "^1.0.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-html": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz", + "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==", + "license": "MIT" + }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/escodegen": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-2.1.0.tgz", + "integrity": "sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==", + "license": "BSD-2-Clause", + "dependencies": { + "esprima": "^4.0.1", + "estraverse": "^5.2.0", + "esutils": "^2.0.2" + }, + "bin": { + "escodegen": "bin/escodegen.js", + "esgenerate": "bin/esgenerate.js" + }, + "engines": { + "node": ">=6.0" + }, + "optionalDependencies": { + "source-map": "~0.6.1" + } + }, + "node_modules/escodegen/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "license": "BSD-3-Clause", + "optional": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/eslint": { + "version": "8.57.1", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.57.1.tgz", + "integrity": "sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA==", + "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.", + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.2.0", + "@eslint-community/regexpp": "^4.6.1", + "@eslint/eslintrc": "^2.1.4", + "@eslint/js": "8.57.1", + "@humanwhocodes/config-array": "^0.13.0", + "@humanwhocodes/module-importer": "^1.0.1", + "@nodelib/fs.walk": "^1.2.8", + "@ungap/structured-clone": "^1.2.0", + "ajv": "^6.12.4", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.2", + "debug": "^4.3.2", + "doctrine": "^3.0.0", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^7.2.2", + "eslint-visitor-keys": "^3.4.3", + "espree": "^9.6.1", + "esquery": "^1.4.2", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^6.0.1", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "globals": "^13.19.0", + "graphemer": "^1.4.0", + "ignore": "^5.2.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "is-path-inside": "^3.0.3", + "js-yaml": "^4.1.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "levn": "^0.4.1", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.2", + "natural-compare": "^1.4.0", + "optionator": "^0.9.3", + "strip-ansi": "^6.0.1", + "text-table": "^0.2.0" + }, + "bin": { + "eslint": "bin/eslint.js" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-config-react-app": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/eslint-config-react-app/-/eslint-config-react-app-7.0.1.tgz", + "integrity": "sha512-K6rNzvkIeHaTd8m/QEh1Zko0KI7BACWkkneSs6s9cKZC/J27X3eZR6Upt1jkmZ/4FK+XUOPPxMEN7+lbUXfSlA==", + "license": "MIT", + "dependencies": { + "@babel/core": "^7.16.0", + "@babel/eslint-parser": "^7.16.3", + "@rushstack/eslint-patch": "^1.1.0", + "@typescript-eslint/eslint-plugin": "^5.5.0", + "@typescript-eslint/parser": "^5.5.0", + "babel-preset-react-app": "^10.0.1", + "confusing-browser-globals": "^1.0.11", + "eslint-plugin-flowtype": "^8.0.3", + "eslint-plugin-import": "^2.25.3", + "eslint-plugin-jest": "^25.3.0", + "eslint-plugin-jsx-a11y": "^6.5.1", + "eslint-plugin-react": "^7.27.1", + "eslint-plugin-react-hooks": "^4.3.0", + "eslint-plugin-testing-library": "^5.0.1" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "eslint": "^8.0.0" + } + }, + "node_modules/eslint-import-resolver-node": { + "version": "0.3.9", + "resolved": "https://registry.npmjs.org/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.9.tgz", + "integrity": "sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==", + "license": "MIT", + "dependencies": { + "debug": "^3.2.7", + "is-core-module": "^2.13.0", + "resolve": "^1.22.4" + } + }, + "node_modules/eslint-import-resolver-node/node_modules/debug": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", + "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", + "license": "MIT", + "dependencies": { + "ms": "^2.1.1" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "debug": "^3.2.7" + }, + "engines": { + "node": ">=4" + }, + "peerDependenciesMeta": { + "eslint": { + "optional": true + } + } + }, + "node_modules/eslint-module-utils/node_modules/debug": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", + "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", + "license": "MIT", + "dependencies": { + "ms": "^2.1.1" + } + }, + "node_modules/eslint-plugin-flowtype": { + "version": "8.0.3", + "resolved": "https://registry.npmjs.org/eslint-plugin-flowtype/-/eslint-plugin-flowtype-8.0.3.tgz", + "integrity": "sha512-dX8l6qUL6O+fYPtpNRideCFSpmWOUVx5QcaGLVqe/vlDiBSe4vYljDWDETwnyFzpl7By/WVIu6rcrniCgH9BqQ==", + "license": "BSD-3-Clause", + "dependencies": { + "lodash": "^4.17.21", + "string-natural-compare": "^3.0.1" + }, + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "@babel/plugin-syntax-flow": "^7.14.5", + "@babel/plugin-transform-react-jsx": "^7.14.9", + "eslint": "^8.1.0" + } + }, + "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==", + "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", + "debug": "^3.2.7", + "doctrine": "^2.1.0", + "eslint-import-resolver-node": "^0.3.9", + "eslint-module-utils": "^2.12.0", + "hasown": "^2.0.2", + "is-core-module": "^2.15.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", + "semver": "^6.3.1", + "string.prototype.trimend": "^1.0.8", + "tsconfig-paths": "^3.15.0" + }, + "engines": { + "node": ">=4" + }, + "peerDependencies": { + "eslint": "^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 || ^9" + } + }, + "node_modules/eslint-plugin-import/node_modules/debug": { + "version": "3.2.7", + "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz", + "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==", + "license": "MIT", + "dependencies": { + "ms": "^2.1.1" + } + }, + "node_modules/eslint-plugin-import/node_modules/doctrine": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz", + "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==", + "license": "Apache-2.0", + "dependencies": { + "esutils": "^2.0.2" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/eslint-plugin-import/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/eslint-plugin-jest": { + "version": "25.7.0", + "resolved": "https://registry.npmjs.org/eslint-plugin-jest/-/eslint-plugin-jest-25.7.0.tgz", + "integrity": "sha512-PWLUEXeeF7C9QGKqvdSbzLOiLTx+bno7/HC9eefePfEb257QFHg7ye3dh80AZVkaa/RQsBB1Q/ORQvg2X7F0NQ==", + "license": "MIT", + "dependencies": { + "@typescript-eslint/experimental-utils": "^5.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || >=16.0.0" + }, + "peerDependencies": { + "@typescript-eslint/eslint-plugin": "^4.0.0 || ^5.0.0", + "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" + }, + "peerDependenciesMeta": { + "@typescript-eslint/eslint-plugin": { + "optional": true + }, + "jest": { + "optional": true + } + } + }, + "node_modules/eslint-plugin-jsx-a11y": { + "version": "6.10.2", + "resolved": "https://registry.npmjs.org/eslint-plugin-jsx-a11y/-/eslint-plugin-jsx-a11y-6.10.2.tgz", + "integrity": "sha512-scB3nz4WmG75pV8+3eRUQOHZlNSUhFNq37xnpgRkCCELU3XMvXAxLk1eqWWyE22Ki4Q01Fnsw9BA3cJHDPgn2Q==", + "license": "MIT", + "dependencies": { + "aria-query": "^5.3.2", + "array-includes": "^3.1.8", + "array.prototype.flatmap": "^1.3.2", + "ast-types-flow": "^0.0.8", + "axe-core": "^4.10.0", + "axobject-query": "^4.1.0", + "damerau-levenshtein": "^1.0.8", + "emoji-regex": "^9.2.2", + "hasown": "^2.0.2", + "jsx-ast-utils": "^3.3.5", + "language-tags": "^1.0.9", + "minimatch": "^3.1.2", + "object.fromentries": "^2.0.8", + "safe-regex-test": "^1.0.3", + "string.prototype.includes": "^2.0.1" + }, + "engines": { + "node": ">=4.0" + }, + "peerDependencies": { + "eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9" + } + }, + "node_modules/eslint-plugin-jsx-a11y/node_modules/aria-query": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.2.tgz", + "integrity": "sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==", + "license": "Apache-2.0", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/eslint-plugin-react": { + "version": "7.37.5", + "resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.37.5.tgz", + "integrity": "sha512-Qteup0SqU15kdocexFNAJMvCJEfa2xUKNV4CC1xsVMrIIqEy3SQ/rqyxCWNzfrd3/ldy6HMlD2e0JDVpDg2qIA==", + "license": "MIT", + "dependencies": { + "array-includes": "^3.1.8", + "array.prototype.findlast": "^1.2.5", + "array.prototype.flatmap": "^1.3.3", + "array.prototype.tosorted": "^1.1.4", + "doctrine": "^2.1.0", + "es-iterator-helpers": "^1.2.1", + "estraverse": "^5.3.0", + "hasown": "^2.0.2", + "jsx-ast-utils": "^2.4.1 || ^3.0.0", + "minimatch": "^3.1.2", + "object.entries": "^1.1.9", + "object.fromentries": "^2.0.8", + "object.values": "^1.2.1", + "prop-types": "^15.8.1", + "resolve": "^2.0.0-next.5", + "semver": "^6.3.1", + "string.prototype.matchall": "^4.0.12", + "string.prototype.repeat": "^1.0.0" + }, + "engines": { + "node": ">=4" + }, + "peerDependencies": { + "eslint": "^3 || ^4 || ^5 || ^6 || ^7 || ^8 || ^9.7" + } + }, + "node_modules/eslint-plugin-react-hooks": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-4.6.2.tgz", + "integrity": "sha512-QzliNJq4GinDBcD8gPB5v0wh6g8q3SUi6EFF0x8N/BL9PoVs0atuGc47ozMRyOWAKdwaZ5OnbOEa3WR+dSGKuQ==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0" + } + }, + "node_modules/eslint-plugin-react/node_modules/doctrine": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz", + "integrity": "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==", + "license": "Apache-2.0", + "dependencies": { + "esutils": "^2.0.2" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/eslint-plugin-react/node_modules/resolve": { + "version": "2.0.0-next.5", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-2.0.0-next.5.tgz", + "integrity": "sha512-U7WjGVG9sH8tvjW5SmGbQuui75FiyjAX72HX15DwBBwF9dNiQZRQAg9nnPhYy+TUnE0+VcrttuvNI8oSxZcocA==", + "license": "MIT", + "dependencies": { + "is-core-module": "^2.13.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/eslint-plugin-react/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/eslint-plugin-testing-library": { + "version": "5.11.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-testing-library/-/eslint-plugin-testing-library-5.11.1.tgz", + "integrity": "sha512-5eX9e1Kc2PqVRed3taaLnAAqPZGEX75C+M/rXzUAI3wIg/ZxzUm1OVAwfe/O+vE+6YXOLetSe9g5GKD2ecXipw==", + "license": "MIT", + "dependencies": { + "@typescript-eslint/utils": "^5.58.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0", + "npm": ">=6" + }, + "peerDependencies": { + "eslint": "^7.5.0 || ^8.0.0" + } + }, + "node_modules/eslint-scope": { + "version": "7.2.2", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz", + "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==", + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-visitor-keys": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz", + "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==", + "license": "Apache-2.0", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-webpack-plugin": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/eslint-webpack-plugin/-/eslint-webpack-plugin-3.2.0.tgz", + "integrity": "sha512-avrKcGncpPbPSUHX6B3stNGzkKFto3eL+DKM4+VyMrVnhPc3vRczVlCq3uhuFOdRvDHTVXuzwk1ZKUrqDQHQ9w==", + "license": "MIT", + "dependencies": { + "@types/eslint": "^7.29.0 || ^8.4.1", + "jest-worker": "^28.0.2", + "micromatch": "^4.0.5", + "normalize-path": "^3.0.0", + "schema-utils": "^4.0.0" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "eslint": "^7.0.0 || ^8.0.0", + "webpack": "^5.0.0" + } + }, + "node_modules/eslint-webpack-plugin/node_modules/jest-worker": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-28.1.3.tgz", + "integrity": "sha512-CqRA220YV/6jCo8VWvAt1KKx6eek1VIHMPeLEbpcfSfkEeWyBNppynM/o6q+Wmw+sOhos2ml34wZbSX3G13//g==", + "license": "MIT", + "dependencies": { + "@types/node": "*", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/eslint-webpack-plugin/node_modules/supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/eslint/node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "license": "Python-2.0" + }, + "node_modules/eslint/node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "license": "MIT", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint/node_modules/globals": { + "version": "13.24.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz", + "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==", + "license": "MIT", + "dependencies": { + "type-fest": "^0.20.2" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint/node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/eslint/node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint/node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint/node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint/node_modules/type-fest": { + "version": "0.20.2", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz", + "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==", + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/espree": { + "version": "9.6.1", + "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz", + "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==", + "license": "BSD-2-Clause", + "dependencies": { + "acorn": "^8.9.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^3.4.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/esprima": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz", + "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==", + "license": "BSD-2-Clause", + "bin": { + "esparse": "bin/esparse.js", + "esvalidate": "bin/esvalidate.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/esquery": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.6.0.tgz", + "integrity": "sha512-ca9pw9fomFcKPvFLXhBKUK90ZvGibiGOvRJNbjljY7s7uq/5YO4BOzcYtJqExdx99rF6aAcnRxHmcUHcz6sQsg==", + "license": "BSD-3-Clause", + "dependencies": { + "estraverse": "^5.1.0" + }, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/esrecurse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz", + "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==", + "license": "BSD-2-Clause", + "dependencies": { + "estraverse": "^5.2.0" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estraverse": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz", + "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estree-util-is-identifier-name": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/estree-util-is-identifier-name/-/estree-util-is-identifier-name-3.0.0.tgz", + "integrity": "sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg==", + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/estree-walker": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-1.0.1.tgz", + "integrity": "sha512-1fMXF3YP4pZZVozF8j/ZLfvnR8NSIljt56UhbZ5PeeDmmGHpgpdwQt7ITlGvYaQukCvuBRMLEiKiYC+oeIg4cg==", + "license": "MIT" + }, + "node_modules/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/etag": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz", + "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/eventemitter3": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-4.0.7.tgz", + "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==", + "license": "MIT" + }, + "node_modules/events": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz", + "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==", + "license": "MIT", + "engines": { + "node": ">=0.8.x" + } + }, + "node_modules/execa": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/execa/-/execa-5.1.1.tgz", + "integrity": "sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==", + "license": "MIT", + "dependencies": { + "cross-spawn": "^7.0.3", + "get-stream": "^6.0.0", + "human-signals": "^2.1.0", + "is-stream": "^2.0.0", + "merge-stream": "^2.0.0", + "npm-run-path": "^4.0.1", + "onetime": "^5.1.2", + "signal-exit": "^3.0.3", + "strip-final-newline": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sindresorhus/execa?sponsor=1" + } + }, + "node_modules/exit": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/exit/-/exit-0.1.2.tgz", + "integrity": "sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==", + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/expect": { + "version": "29.7.0", + "resolved": "https://registry.npmjs.org/expect/-/expect-29.7.0.tgz", + "integrity": "sha512-2Zks0hf1VLFYI1kbh0I5jP3KHHyCHpkfyHBzsSXRFgl/Bg9mWYfMW8oD+PdMPlEwy5HNsR9JutYy6pMeOh61nw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/expect-utils": "^29.7.0", + "jest-get-type": "^29.6.3", + "jest-matcher-utils": "^29.7.0", + "jest-message-util": "^29.7.0", + "jest-util": "^29.7.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/express": { + "version": "4.21.2", + "resolved": "https://registry.npmjs.org/express/-/express-4.21.2.tgz", + "integrity": "sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==", + "license": "MIT", + "dependencies": { + "accepts": "~1.3.8", + "array-flatten": "1.1.1", + "body-parser": "1.20.3", + "content-disposition": "0.5.4", + "content-type": "~1.0.4", + "cookie": "0.7.1", + "cookie-signature": "1.0.6", + "debug": "2.6.9", + "depd": "2.0.0", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "1.3.1", + "fresh": "0.5.2", + "http-errors": "2.0.0", + "merge-descriptors": "1.0.3", + "methods": "~1.1.2", + "on-finished": "2.4.1", + "parseurl": "~1.3.3", + "path-to-regexp": "0.1.12", + "proxy-addr": "~2.0.7", + "qs": "6.13.0", + "range-parser": "~1.2.1", + "safe-buffer": "5.2.1", + "send": "0.19.0", + "serve-static": "1.16.2", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "type-is": "~1.6.18", + "utils-merge": "1.0.1", + "vary": "~1.1.2" + }, + "engines": { + "node": ">= 0.10.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + } + }, + "node_modules/express/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/express/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "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==", + "license": "MIT" + }, + "node_modules/extend": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz", + "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==", + "license": "MIT" + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "license": "MIT" + }, + "node_modules/fast-glob": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz", + "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==", + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.2", + "merge2": "^1.3.0", + "micromatch": "^4.0.8" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/fast-glob/node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz", + "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==", + "license": "MIT" + }, + "node_modules/fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==", + "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==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/fastify" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/fastify" + } + ], + "license": "BSD-3-Clause" + }, + "node_modules/fastq": { + "version": "1.19.1", + "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz", + "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==", + "license": "ISC", + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/fault": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/fault/-/fault-1.0.4.tgz", + "integrity": "sha512-CJ0HCB5tL5fYTEA7ToAq5+kTwd++Borf1/bifxd9iT70QcXr4MRrO3Llf8Ifs70q+SJcGHFtnIE/Nw6giCtECA==", + "license": "MIT", + "dependencies": { + "format": "^0.2.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/faye-websocket": { + "version": "0.11.4", + "resolved": "https://registry.npmjs.org/faye-websocket/-/faye-websocket-0.11.4.tgz", + "integrity": "sha512-CzbClwlXAuiRQAlUyfqPgvPoNKTckTPGfwZV4ZdAhVcP2lh9KUxJg2b5GkE7XbjKQ3YJnQ9z6D9ntLAlB+tP8g==", + "license": "Apache-2.0", + "dependencies": { + "websocket-driver": ">=0.5.1" + }, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/fb-watchman": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/fb-watchman/-/fb-watchman-2.0.2.tgz", + "integrity": "sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==", + "license": "Apache-2.0", + "dependencies": { + "bser": "2.1.1" + } + }, + "node_modules/file-entry-cache": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz", + "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==", + "license": "MIT", + "dependencies": { + "flat-cache": "^3.0.4" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/file-loader": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/file-loader/-/file-loader-6.2.0.tgz", + "integrity": "sha512-qo3glqyTa61Ytg4u73GultjHGjdRyig3tG6lPtyX/jOEJvHif9uB0/OCI2Kif6ctF3caQTW2G5gym21oAsI4pw==", + "license": "MIT", + "dependencies": { + "loader-utils": "^2.0.0", + "schema-utils": "^3.0.0" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^4.0.0 || ^5.0.0" + } + }, + "node_modules/file-loader/node_modules/schema-utils": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz", + "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==", + "license": "MIT", + "dependencies": { + "@types/json-schema": "^7.0.8", + "ajv": "^6.12.5", + "ajv-keywords": "^3.5.2" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/file-selector": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/file-selector/-/file-selector-2.1.2.tgz", + "integrity": "sha512-QgXo+mXTe8ljeqUFaX3QVHc5osSItJ/Km+xpocx0aSqWGMSCf6qYs/VnzZgS864Pjn5iceMRFigeAV7AfTlaig==", + "license": "MIT", + "dependencies": { + "tslib": "^2.7.0" + }, + "engines": { + "node": ">= 12" + } + }, + "node_modules/filelist": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/filelist/-/filelist-1.0.4.tgz", + "integrity": "sha512-w1cEuf3S+DrLCQL7ET6kz+gmlJdbq9J7yXCSjK/OZCPA+qEN1WyF4ZAf0YYJa4/shHJra2t/d/r8SV4Ji+x+8Q==", + "license": "Apache-2.0", + "dependencies": { + "minimatch": "^5.0.1" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/filelist/node_modules/minimatch": { + "version": "5.1.6", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz", + "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==", + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/filesize": { + "version": "8.0.7", + "resolved": "https://registry.npmjs.org/filesize/-/filesize-8.0.7.tgz", + "integrity": "sha512-pjmC+bkIF8XI7fWaH8KxHcZL3DPybs1roSKP4rKDvy20tAWwIObE4+JIseG2byfGKhud5ZnM4YSGKBz7Sh0ndQ==", + "license": "BSD-3-Clause", + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/fill-range": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", + "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", + "license": "MIT", + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/finalhandler": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz", + "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "on-finished": "2.4.1", + "parseurl": "~1.3.3", + "statuses": "2.0.1", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/finalhandler/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/finalhandler/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, + "node_modules/find-cache-dir": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/find-cache-dir/-/find-cache-dir-3.3.2.tgz", + "integrity": "sha512-wXZV5emFEjrridIgED11OoUKLxiYjAcqot/NJdAkOhlJ+vGzwhOAfcG5OX1jP+S0PcjEn8bdMJv+g2jwQ3Onig==", + "license": "MIT", + "dependencies": { + "commondir": "^1.0.1", + "make-dir": "^3.0.2", + "pkg-dir": "^4.1.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/avajs/find-cache-dir?sponsor=1" + } + }, + "node_modules/find-up": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-4.1.0.tgz", + "integrity": "sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw==", + "license": "MIT", + "dependencies": { + "locate-path": "^5.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/flat-cache": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz", + "integrity": "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==", + "license": "MIT", + "dependencies": { + "flatted": "^3.2.9", + "keyv": "^4.5.3", + "rimraf": "^3.0.2" + }, + "engines": { + "node": "^10.12.0 || >=12.0.0" + } + }, + "node_modules/flatted": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.3.tgz", + "integrity": "sha512-GX+ysw4PBCz0PzosHDepZGANEuFCMLrnRTiEy9McGjmkCQYwRq4A/X786G/fjM/+OjsWSU1ZrY5qyARZmO/uwg==", + "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==", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "license": "MIT", + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, + "node_modules/for-each": { + "version": "0.3.5", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.5.tgz", + "integrity": "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg==", + "license": "MIT", + "dependencies": { + "is-callable": "^1.2.7" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/foreground-child": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz", + "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==", + "license": "ISC", + "dependencies": { + "cross-spawn": "^7.0.6", + "signal-exit": "^4.0.1" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/foreground-child/node_modules/signal-exit": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", + "license": "ISC", + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/fork-ts-checker-webpack-plugin": { + "version": "6.5.3", + "resolved": "https://registry.npmjs.org/fork-ts-checker-webpack-plugin/-/fork-ts-checker-webpack-plugin-6.5.3.tgz", + "integrity": "sha512-SbH/l9ikmMWycd5puHJKTkZJKddF4iRLyW3DeZ08HTI7NGyLS38MXd/KGgeWumQO7YNQbW2u/NtPT2YowbPaGQ==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.8.3", + "@types/json-schema": "^7.0.5", + "chalk": "^4.1.0", + "chokidar": "^3.4.2", + "cosmiconfig": "^6.0.0", + "deepmerge": "^4.2.2", + "fs-extra": "^9.0.0", + "glob": "^7.1.6", + "memfs": "^3.1.2", + "minimatch": "^3.0.4", + "schema-utils": "2.7.0", + "semver": "^7.3.2", + "tapable": "^1.0.0" + }, + "engines": { + "node": ">=10", + "yarn": ">=1.0.0" + }, + "peerDependencies": { + "eslint": ">= 6", + "typescript": ">= 2.7", + "vue-template-compiler": "*", + "webpack": ">= 4" + }, + "peerDependenciesMeta": { + "eslint": { + "optional": true + }, + "vue-template-compiler": { + "optional": true + } + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/cosmiconfig": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-6.0.0.tgz", + "integrity": "sha512-xb3ZL6+L8b9JLLCx3ZdoZy4+2ECphCMo2PwqgP1tlfVq6M6YReyzBJtvWWtbDSpNr9hn96pkCiZqUcFEc+54Qg==", + "license": "MIT", + "dependencies": { + "@types/parse-json": "^4.0.0", + "import-fresh": "^3.1.0", + "parse-json": "^5.0.0", + "path-type": "^4.0.0", + "yaml": "^1.7.2" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/fs-extra": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz", + "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==", + "license": "MIT", + "dependencies": { + "at-least-node": "^1.0.0", + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/schema-utils": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-2.7.0.tgz", + "integrity": "sha512-0ilKFI6QQF5nxDZLFn2dMjvc4hjg/Wkg7rHd3jK6/A4a1Hl9VFdQWvgB1UMGoU94pad1P/8N7fMcEnLnSiju8A==", + "license": "MIT", + "dependencies": { + "@types/json-schema": "^7.0.4", + "ajv": "^6.12.2", + "ajv-keywords": "^3.4.1" + }, + "engines": { + "node": ">= 8.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/tapable": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-1.1.3.tgz", + "integrity": "sha512-4WK/bYZmj8xLr+HUCODHGF1ZFzsYffasLUgEiMBY4fgtltdO6B4WJtlSbPaDTLpYTcGVwM2qLnFTICEcNxs3kA==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "es-set-tostringtag": "^2.1.0", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/format": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/format/-/format-0.2.2.tgz", + "integrity": "sha512-wzsgA6WOq+09wrU1tsJ09udeR/YZRaeArL9e1wPbFg3GG2yDnC2ldKpxs4xunpFF9DgqCqOIra3bc1HWrJ37Ww==", + "engines": { + "node": ">=0.4.x" + } + }, + "node_modules/forwarded": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz", + "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fraction.js": { + "version": "4.3.7", + "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-4.3.7.tgz", + "integrity": "sha512-ZsDfxO51wGAXREY55a7la9LScWpwv9RxIrYABrlvOFBlH/ShPnrtsXeuUIfXKKOVicNxQ+o8JTbJvjS4M89yew==", + "license": "MIT", + "engines": { + "node": "*" + }, + "funding": { + "type": "patreon", + "url": "https://github.com/sponsors/rawify" + } + }, + "node_modules/fresh": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz", + "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fs-extra": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz", + "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==", + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "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==", + "license": "Unlicense" + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "license": "ISC" + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/function.prototype.name": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.8.tgz", + "integrity": "sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "define-properties": "^1.2.1", + "functions-have-names": "^1.2.3", + "hasown": "^2.0.2", + "is-callable": "^1.2.7" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/functions-have-names": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/functions-have-names/-/functions-have-names-1.2.3.tgz", + "integrity": "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "license": "ISC", + "engines": { + "node": "6.* || 8.* || >= 10.*" + } + }, + "node_modules/get-intrinsic": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz", + "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==", + "license": "MIT", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "function-bind": "^1.1.2", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-own-enumerable-property-symbols": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/get-own-enumerable-property-symbols/-/get-own-enumerable-property-symbols-3.0.2.tgz", + "integrity": "sha512-I0UBV/XOz1XkIJHEUDMZAbzCThU/H8DxmSfmdGcKPnVhu2VfFqr34jr9777IyaTYvxjedWhqVIilEDsCdP5G6g==", + "license": "ISC" + }, + "node_modules/get-package-type": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz", + "integrity": "sha512-pjzuKtY64GYfWizNAJ0fr9VqttZkNiK2iS430LtIHzjBEr6bX8Am2zm4sW4Ro5wjWW5cAlRL1qAMTcXbjNAO2Q==", + "license": "MIT", + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/get-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz", + "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==", + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/get-stream": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz", + "integrity": "sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/get-symbol-description": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.1.0.tgz", + "integrity": "sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "deprecated": "Glob versions prior to v9 are no longer supported", + "license": "ISC", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob-parent": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", + "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==", + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/glob-to-regexp": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/glob-to-regexp/-/glob-to-regexp-0.4.1.tgz", + "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==", + "license": "BSD-2-Clause" + }, + "node_modules/global-modules": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/global-modules/-/global-modules-2.0.0.tgz", + "integrity": "sha512-NGbfmJBp9x8IxyJSd1P+otYK8vonoJactOogrVfFRIAEY1ukil8RSKDz2Yo7wh1oihl51l/r6W4epkeKJHqL8A==", + "license": "MIT", + "dependencies": { + "global-prefix": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/global-prefix": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-3.0.0.tgz", + "integrity": "sha512-awConJSVCHVGND6x3tmMaKcQvwXLhjdkmomy2W+Goaui8YPgYgXJZewhg3fWC+DlfqqQuWg8AwqjGTD2nAPVWg==", + "license": "MIT", + "dependencies": { + "ini": "^1.3.5", + "kind-of": "^6.0.2", + "which": "^1.3.1" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/global-prefix/node_modules/which": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", + "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "which": "bin/which" + } + }, + "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/globalthis": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz", + "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==", + "license": "MIT", + "dependencies": { + "define-properties": "^1.2.1", + "gopd": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/globby": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/globby/-/globby-11.1.0.tgz", + "integrity": "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==", + "license": "MIT", + "dependencies": { + "array-union": "^2.1.0", + "dir-glob": "^3.0.1", + "fast-glob": "^3.2.9", + "ignore": "^5.2.0", + "merge2": "^1.4.1", + "slash": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/gopd": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", + "license": "ISC" + }, + "node_modules/graphemer": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz", + "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==", + "license": "MIT" + }, + "node_modules/gzip-size": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/gzip-size/-/gzip-size-6.0.0.tgz", + "integrity": "sha512-ax7ZYomf6jqPTQ4+XCpUGyXKHk5WweS+e05MBO4/y3WJ5RkmPXNKvX+bx1behVILVwr6JSQvZAku021CHPXG3Q==", + "license": "MIT", + "dependencies": { + "duplexer": "^0.1.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/hachure-fill": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/hachure-fill/-/hachure-fill-0.5.2.tgz", + "integrity": "sha512-3GKBOn+m2LX9iq+JC1064cSFprJY4jL1jCXTcpnfER5HYE2l/4EfWSGzkPa/ZDBmYI0ZOEj5VHV/eKnPGkHuOg==", + "license": "MIT" + }, + "node_modules/handle-thing": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/handle-thing/-/handle-thing-2.0.1.tgz", + "integrity": "sha512-9Qn4yBxelxoh2Ow62nP+Ka/kMnOXRi8BXnRaUwezLNhqelnN49xKz4F/dPP8OYLxLxq6JDtZb2i9XznUQbNPTg==", + "license": "MIT" + }, + "node_modules/harmony-reflect": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/harmony-reflect/-/harmony-reflect-1.6.2.tgz", + "integrity": "sha512-HIp/n38R9kQjDEziXyDTuW3vvoxxyxjxFzXLrBr18uB47GnSt+G9D29fqrpM5ZkspMcPICud3XsBJQ4Y2URg8g==", + "license": "(Apache-2.0 OR MPL-1.1)" + }, + "node_modules/has-bigints": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.1.0.tgz", + "integrity": "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/has-property-descriptors": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz", + "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==", + "license": "MIT", + "dependencies": { + "es-define-property": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-proto": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.2.0.tgz", + "integrity": "sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==", + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz", + "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==", + "license": "MIT", + "dependencies": { + "has-symbols": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hasown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz", + "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/hast-util-parse-selector": { + "version": "2.2.5", + "resolved": "https://registry.npmjs.org/hast-util-parse-selector/-/hast-util-parse-selector-2.2.5.tgz", + "integrity": "sha512-7j6mrk/qqkSehsM92wQjdIgWM2/BW61u/53G6xmC8i1OmEdKLHbk419QKQUjz6LglWsfqoiHmyMRkP1BGjecNQ==", + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-to-jsx-runtime": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/hast-util-to-jsx-runtime/-/hast-util-to-jsx-runtime-2.3.6.tgz", + "integrity": "sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==", + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0", + "@types/hast": "^3.0.0", + "@types/unist": "^3.0.0", + "comma-separated-tokens": "^2.0.0", + "devlop": "^1.0.0", + "estree-util-is-identifier-name": "^3.0.0", + "hast-util-whitespace": "^3.0.0", + "mdast-util-mdx-expression": "^2.0.0", + "mdast-util-mdx-jsx": "^3.0.0", + "mdast-util-mdxjs-esm": "^2.0.0", + "property-information": "^7.0.0", + "space-separated-tokens": "^2.0.0", + "style-to-js": "^1.0.0", + "unist-util-position": "^5.0.0", + "vfile-message": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-whitespace": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz", + "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hastscript": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/hastscript/-/hastscript-6.0.0.tgz", + "integrity": "sha512-nDM6bvd7lIqDUiYEiu5Sl/+6ReP0BMk/2f4U/Rooccxkj0P5nm+acM5PrGJ/t5I8qPGiqZSE6hVAwZEdZIvP4w==", + "license": "MIT", + "dependencies": { + "@types/hast": "^2.0.0", + "comma-separated-tokens": "^1.0.0", + "hast-util-parse-selector": "^2.0.0", + "property-information": "^5.0.0", + "space-separated-tokens": "^1.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hastscript/node_modules/@types/hast": { + "version": "2.3.10", + "resolved": "https://registry.npmjs.org/@types/hast/-/hast-2.3.10.tgz", + "integrity": "sha512-McWspRw8xx8J9HurkVBfYj0xKoE25tOFlHGdx4MJ5xORQrMGZNqJhVQWaIbm6Oyla5kYOXtDiopzKRJzEOkwJw==", + "license": "MIT", + "dependencies": { + "@types/unist": "^2" + } + }, + "node_modules/hastscript/node_modules/@types/unist": { + "version": "2.0.11", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz", + "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==", + "license": "MIT" + }, + "node_modules/hastscript/node_modules/comma-separated-tokens": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-1.0.8.tgz", + "integrity": "sha512-GHuDRO12Sypu2cV70d1dkA2EUmXHgntrzbpvOB+Qy+49ypNfGgFQIC2fhhXbnyrJRynDCAARsT7Ou0M6hirpfw==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/hastscript/node_modules/property-information": { + "version": "5.6.0", + "resolved": "https://registry.npmjs.org/property-information/-/property-information-5.6.0.tgz", + "integrity": "sha512-YUHSPk+A30YPv+0Qf8i9Mbfe/C0hdPXk1s1jPVToV8pk8BQtpw10ct89Eo7OWkutrwqvT0eicAxlOg3dOAu8JA==", + "license": "MIT", + "dependencies": { + "xtend": "^4.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/hastscript/node_modules/space-separated-tokens": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-1.1.5.tgz", + "integrity": "sha512-q/JSVd1Lptzhf5bkYm4ob4iWPjx0KiRe3sRFBNrVqbJkFaBm5vbbowy1mymoPNLRa52+oadOhJ+K49wsSeSjTA==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/he": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/he/-/he-1.2.0.tgz", + "integrity": "sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==", + "license": "MIT", + "bin": { + "he": "bin/he" + } + }, + "node_modules/highlight.js": { + "version": "10.7.3", + "resolved": "https://registry.npmjs.org/highlight.js/-/highlight.js-10.7.3.tgz", + "integrity": "sha512-tzcUFauisWKNHaRkN4Wjl/ZA07gENAjFl3J/c480dprkGTg5EQstgaNFqBfUqCq54kZRIEcreTsAgF/m2quD7A==", + "license": "BSD-3-Clause", + "engines": { + "node": "*" + } + }, + "node_modules/highlightjs-vue": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/highlightjs-vue/-/highlightjs-vue-1.0.0.tgz", + "integrity": "sha512-PDEfEF102G23vHmPhLyPboFCD+BkMGu+GuJe2d9/eH4FsCwvgBpnc9n0pGE+ffKdph38s6foEZiEjdgHdzp+IA==", + "license": "CC0-1.0" + }, + "node_modules/hoopy": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/hoopy/-/hoopy-0.1.4.tgz", + "integrity": "sha512-HRcs+2mr52W0K+x8RzcLzuPPmVIKMSv97RGHy0Ea9y/mpcaK+xTrjICA04KAHi4GRzxliNqNJEFYWHghy3rSfQ==", + "license": "MIT", + "engines": { + "node": ">= 6.0.0" + } + }, + "node_modules/hpack.js": { + "version": "2.1.6", + "resolved": "https://registry.npmjs.org/hpack.js/-/hpack.js-2.1.6.tgz", + "integrity": "sha512-zJxVehUdMGIKsRaNt7apO2Gqp0BdqW5yaiGHXXmbpvxgBYVZnAql+BJb4RO5ad2MgpbZKn5G6nMnegrH1FcNYQ==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.1", + "obuf": "^1.0.0", + "readable-stream": "^2.0.1", + "wbuf": "^1.1.0" + } + }, + "node_modules/hpack.js/node_modules/isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==", + "license": "MIT" + }, + "node_modules/hpack.js/node_modules/readable-stream": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz", + "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==", + "license": "MIT", + "dependencies": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.3", + "isarray": "~1.0.0", + "process-nextick-args": "~2.0.0", + "safe-buffer": "~5.1.1", + "string_decoder": "~1.1.1", + "util-deprecate": "~1.0.1" + } + }, + "node_modules/hpack.js/node_modules/safe-buffer": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz", + "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==", + "license": "MIT" + }, + "node_modules/hpack.js/node_modules/string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "license": "MIT", + "dependencies": { + "safe-buffer": "~5.1.0" + } + }, + "node_modules/html-encoding-sniffer": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-2.0.1.tgz", + "integrity": "sha512-D5JbOMBIR/TVZkubHT+OyT2705QvogUW4IBn6nHd756OwieSF9aDYFj4dv6HHEVGYbHaLETa3WggZYWWMyy3ZQ==", + "license": "MIT", + "dependencies": { + "whatwg-encoding": "^1.0.5" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/html-entities": { + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/html-entities/-/html-entities-2.6.0.tgz", + "integrity": "sha512-kig+rMn/QOVRvr7c86gQ8lWXq+Hkv6CbAH1hLu+RG338StTpE8Z0b44SDVaqVu7HGKf27frdmUYEs9hTUX/cLQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/mdevils" + }, + { + "type": "patreon", + "url": "https://patreon.com/mdevils" + } + ], + "license": "MIT" + }, + "node_modules/html-escaper": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz", + "integrity": "sha512-H2iMtd0I4Mt5eYiapRdIDjp+XzelXQ0tFE4JS7YFwFevXXMmOp9myNrUvCg0D6ws8iqkRPBfKHgbwig1SmlLfg==", + "license": "MIT" + }, + "node_modules/html-minifier-terser": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz", + "integrity": "sha512-YXxSlJBZTP7RS3tWnQw74ooKa6L9b9i9QYXY21eUEvhZ3u9XLfv6OnFsQq6RxkhHygsaUMvYsZRV5rU/OVNZxw==", + "license": "MIT", + "dependencies": { + "camel-case": "^4.1.2", + "clean-css": "^5.2.2", + "commander": "^8.3.0", + "he": "^1.2.0", + "param-case": "^3.0.4", + "relateurl": "^0.2.7", + "terser": "^5.10.0" + }, + "bin": { + "html-minifier-terser": "cli.js" + }, + "engines": { + "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-url-attributes": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/html-url-attributes/-/html-url-attributes-3.0.1.tgz", + "integrity": "sha512-ol6UPyBWqsrO6EJySPz2O7ZSr856WDrEzM5zMqp+FJJLGMW35cLYmmZnl0vztAZxRUoNZJFTCohfjuIJ8I4QBQ==", + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@types/html-minifier-terser": "^6.0.0", + "html-minifier-terser": "^6.0.2", + "lodash": "^4.17.21", + "pretty-error": "^4.0.0", + "tapable": "^2.0.0" + }, + "engines": { + "node": ">=10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/html-webpack-plugin" + }, + "peerDependencies": { + "@rspack/core": "0.x || 1.x", + "webpack": "^5.20.0" + }, + "peerDependenciesMeta": { + "@rspack/core": { + "optional": true + }, + "webpack": { + "optional": true + } + } + }, + "node_modules/htmlparser2": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-6.1.0.tgz", + "integrity": "sha512-gyyPk6rgonLFEDGoeRgQNaEUvdJ4ktTmmUh/h2t7s+M8oPpIPxgNACWa+6ESR57kXstwqPiCut0V8NRpcwgU7A==", + "funding": [ + "https://github.com/fb55/htmlparser2?sponsor=1", + { + "type": "github", + "url": "https://github.com/sponsors/fb55" + } + ], + "license": "MIT", + "dependencies": { + "domelementtype": "^2.0.1", + "domhandler": "^4.0.0", + "domutils": "^2.5.2", + "entities": "^2.0.0" + } + }, + "node_modules/http-deceiver": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/http-deceiver/-/http-deceiver-1.2.7.tgz", + "integrity": "sha512-LmpOGxTfbpgtGVxJrj5k7asXHCgNZp5nLfp+hWc8QQRqtb7fUy6kRY3BO1h9ddF6yIPYUARgxGOwB42DnxIaNw==", + "license": "MIT" + }, + "node_modules/http-errors": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz", + "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==", + "license": "MIT", + "dependencies": { + "depd": "2.0.0", + "inherits": "2.0.4", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "toidentifier": "1.0.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/http-parser-js": { + "version": "0.5.10", + "resolved": "https://registry.npmjs.org/http-parser-js/-/http-parser-js-0.5.10.tgz", + "integrity": "sha512-Pysuw9XpUq5dVc/2SMHpuTY01RFl8fttgcyunjL7eEMhGM3cI4eOmiCycJDVCo/7O7ClfQD3SaI6ftDzqOXYMA==", + "license": "MIT" + }, + "node_modules/http-proxy": { + "version": "1.18.1", + "resolved": "https://registry.npmjs.org/http-proxy/-/http-proxy-1.18.1.tgz", + "integrity": "sha512-7mz/721AbnJwIVbnaSv1Cz3Am0ZLT/UBwkC92VlxhXv/k/BBQfM2fXElQNC27BVGr0uwUpplYPQM9LnaBMR5NQ==", + "license": "MIT", + "dependencies": { + "eventemitter3": "^4.0.0", + "follow-redirects": "^1.0.0", + "requires-port": "^1.0.0" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/http-proxy-agent": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-4.0.1.tgz", + "integrity": "sha512-k0zdNgqWTGA6aeIRVpvfVob4fL52dTfaehylg0Y4UvSySvOq/Y+BOyPrgpUrA7HylqvU8vIZGsRuXmspskV0Tg==", + "license": "MIT", + "dependencies": { + "@tootallnate/once": "1", + "agent-base": "6", + "debug": "4" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/http-proxy-middleware": { + "version": "2.0.9", + "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-2.0.9.tgz", + "integrity": "sha512-c1IyJYLYppU574+YI7R4QyX2ystMtVXZwIdzazUIPIJsHuWNd+mho2j+bKoHftndicGj9yh+xjd+l0yj7VeT1Q==", + "license": "MIT", + "dependencies": { + "@types/http-proxy": "^1.17.8", + "http-proxy": "^1.18.1", + "is-glob": "^4.0.1", + "is-plain-obj": "^3.0.0", + "micromatch": "^4.0.2" + }, + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "@types/express": "^4.17.13" + }, + "peerDependenciesMeta": { + "@types/express": { + "optional": true + } + } + }, + "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", + "integrity": "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==", + "license": "MIT", + "dependencies": { + "agent-base": "6", + "debug": "4" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/human-signals": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-2.1.0.tgz", + "integrity": "sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==", + "license": "Apache-2.0", + "engines": { + "node": ">=10.17.0" + } + }, + "node_modules/iconv-lite": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", + "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/icss-utils": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/icss-utils/-/icss-utils-5.1.0.tgz", + "integrity": "sha512-soFhflCVWLfRNOPU3iv5Z9VUdT44xFRbzjLsEzSr5AQmgqPMTHdU3PMT1Cf1ssx8fLNJDA1juftYl+PUcv3MqA==", + "license": "ISC", + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/idb": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/idb/-/idb-7.1.1.tgz", + "integrity": "sha512-gchesWBzyvGHRO9W8tzUWFDycow5gwjvFKfyV9FF32Y7F50yZMp7mP+T2mJIWFx49zicqyC4uefHM17o6xKIVQ==", + "license": "ISC" + }, + "node_modules/identity-obj-proxy": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/identity-obj-proxy/-/identity-obj-proxy-3.0.0.tgz", + "integrity": "sha512-00n6YnVHKrinT9t0d9+5yZC6UBNJANpYEQvL2LlX6Ab9lnmxzIRcEmTPuyGScvl1+jKuCICX1Z0Ab1pPKKdikA==", + "license": "MIT", + "dependencies": { + "harmony-reflect": "^1.4.6" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/ignore": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", + "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/immer": { + "version": "9.0.21", + "resolved": "https://registry.npmjs.org/immer/-/immer-9.0.21.tgz", + "integrity": "sha512-bc4NBHqOqSfRW7POMkHd51LvClaeMXpm8dx0e8oE2GORbq5aRK7Bxl4FyzVLdGtLmvLKL7BTDBG5ACQm4HWjTA==", + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/immer" + } + }, + "node_modules/import-fresh": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz", + "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==", + "license": "MIT", + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/import-fresh/node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/import-local": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/import-local/-/import-local-3.2.0.tgz", + "integrity": "sha512-2SPlun1JUPWoM6t3F0dw0FkCF/jWY8kttcY4f599GLTSjh2OCuuhdTkJQsEcZzBqbXZGKMK2OqW1oZsjtf/gQA==", + "license": "MIT", + "dependencies": { + "pkg-dir": "^4.2.0", + "resolve-cwd": "^3.0.0" + }, + "bin": { + "import-local-fixture": "fixtures/cli.js" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "license": "MIT", + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/indent-string": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz", + "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.", + "license": "ISC", + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "license": "ISC" + }, + "node_modules/ini": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz", + "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==", + "license": "ISC" + }, + "node_modules/inline-style-parser": { + "version": "0.2.4", + "resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.2.4.tgz", + "integrity": "sha512-0aO8FkhNZlj/ZIbNi7Lxxr12obT7cL1moPfE4tg1LkX7LlLfC6DeX4l2ZEud1ukP9jNQyNnfzQVqwbwmAATY4Q==", + "license": "MIT" + }, + "node_modules/internal-slot": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz", + "integrity": "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "hasown": "^2.0.2", + "side-channel": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/internmap": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/internmap/-/internmap-2.0.3.tgz", + "integrity": "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==", + "license": "ISC", + "engines": { + "node": ">=12" + } + }, + "node_modules/ipaddr.js": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-2.2.0.tgz", + "integrity": "sha512-Ag3wB2o37wslZS19hZqorUnrnzSkpOVy+IiiDEiTqNubEYpYuHWIf6K4psgN2ZWKExS4xhVCrRVfb/wfW8fWJA==", + "license": "MIT", + "engines": { + "node": ">= 10" + } + }, + "node_modules/is-alphabetical": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-2.0.1.tgz", + "integrity": "sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/is-alphanumerical": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-2.0.1.tgz", + "integrity": "sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==", + "license": "MIT", + "dependencies": { + "is-alphabetical": "^2.0.0", + "is-decimal": "^2.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/is-arguments": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/is-arguments/-/is-arguments-1.2.0.tgz", + "integrity": "sha512-7bVbi0huj/wrIAOzb8U1aszg9kdi3KN/CyU19CTI7tAoZYEZoL9yCDXpbXN+uPsuWnP02cyug1gleqq+TU+YCA==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-array-buffer": { + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.5.tgz", + "integrity": "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "get-intrinsic": "^1.2.6" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", + "license": "MIT" + }, + "node_modules/is-async-function": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-async-function/-/is-async-function-2.1.1.tgz", + "integrity": "sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ==", + "license": "MIT", + "dependencies": { + "async-function": "^1.0.0", + "call-bound": "^1.0.3", + "get-proto": "^1.0.1", + "has-tostringtag": "^1.0.2", + "safe-regex-test": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-bigint": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.1.0.tgz", + "integrity": "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==", + "license": "MIT", + "dependencies": { + "has-bigints": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-binary-path": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", + "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "license": "MIT", + "dependencies": { + "binary-extensions": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-boolean-object": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.2.2.tgz", + "integrity": "sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-callable": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.7.tgz", + "integrity": "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-core-module": { + "version": "2.16.1", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz", + "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==", + "license": "MIT", + "dependencies": { + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-data-view": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.2.tgz", + "integrity": "sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "get-intrinsic": "^1.2.6", + "is-typed-array": "^1.1.13" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-date-object": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.1.0.tgz", + "integrity": "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-decimal": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-2.0.1.tgz", + "integrity": "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/is-docker": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/is-docker/-/is-docker-2.2.1.tgz", + "integrity": "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==", + "license": "MIT", + "bin": { + "is-docker": "cli.js" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-finalizationregistry": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.1.1.tgz", + "integrity": "sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-generator-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-generator-fn/-/is-generator-fn-2.1.0.tgz", + "integrity": "sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "get-proto": "^1.0.0", + "has-tostringtag": "^1.0.2", + "safe-regex-test": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-hexadecimal": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-2.0.1.tgz", + "integrity": "sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/is-map": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/is-map/-/is-map-2.0.3.tgz", + "integrity": "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-module": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-module/-/is-module-1.0.0.tgz", + "integrity": "sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g==", + "license": "MIT" + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "license": "MIT", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-number-object": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.1.1.tgz", + "integrity": "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-obj": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz", + "integrity": "sha512-l4RyHgRqGN4Y3+9JHVrNqO+tN0rV5My76uW5/nuO4K1b6vw5G8d/cmFjP9tRfEsdhZNt0IFdZuK/c2Vr4Nb+Qg==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-path-inside": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz", + "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-plain-obj": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz", + "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "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", + "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==", + "license": "MIT" + }, + "node_modules/is-regex": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz", + "integrity": "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "gopd": "^1.2.0", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-regexp": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-regexp/-/is-regexp-1.0.0.tgz", + "integrity": "sha512-7zjFAPO4/gwyQAAgRRmqeEeyIICSdmCqa3tsVHMdBzaXXRiqopZL4Cyghg/XulGWrtABTpbnYYzzIRffLkP4oA==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-root": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-root/-/is-root-2.1.0.tgz", + "integrity": "sha512-AGOriNp96vNBd3HtU+RzFEc75FfR5ymiYv8E553I71SCeXBiMsVDUtdio1OEFvrPyLIQ9tVR5RxXIFe5PUFjMg==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/is-set": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/is-set/-/is-set-2.0.3.tgz", + "integrity": "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-shared-array-buffer": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-shared-array-buffer/-/is-shared-array-buffer-1.0.4.tgz", + "integrity": "sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-stream": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz", + "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==", + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-string": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.1.1.tgz", + "integrity": "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-symbol": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.1.1.tgz", + "integrity": "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "has-symbols": "^1.1.0", + "safe-regex-test": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-typed-array": { + "version": "1.1.15", + "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz", + "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==", + "license": "MIT", + "dependencies": { + "which-typed-array": "^1.1.16" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-typedarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", + "integrity": "sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==", + "license": "MIT" + }, + "node_modules/is-weakmap": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.2.tgz", + "integrity": "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-weakref": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.1.1.tgz", + "integrity": "sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-weakset": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.4.tgz", + "integrity": "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "get-intrinsic": "^1.2.6" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-wsl": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-2.2.0.tgz", + "integrity": "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==", + "license": "MIT", + "dependencies": { + "is-docker": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/isarray": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz", + "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==", + "license": "MIT" + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "license": "ISC" + }, + "node_modules/istanbul-lib-coverage": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz", + "integrity": "sha512-O8dpsF+r0WV/8MNRKfnmrtCWhuKjxrq2w+jpzBL5UZKTi2LeVWnWOmWRxFlesJONmc+wLAGvKQZEOanko0LFTg==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-instrument": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-5.2.1.tgz", + "integrity": "sha512-pzqtp31nLv/XFOzXGuvhCb8qhjmTVo5vjVk19XE4CRlSWz0KoeJ3bw9XsA7nOp9YBf4qHjwBxkDzKcME/J29Yg==", + "license": "BSD-3-Clause", + "dependencies": { + "@babel/core": "^7.12.3", + "@babel/parser": "^7.14.7", + "@istanbuljs/schema": "^0.1.2", + "istanbul-lib-coverage": "^3.2.0", + "semver": "^6.3.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/istanbul-lib-instrument/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/istanbul-lib-report": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-3.0.1.tgz", + "integrity": "sha512-GCfE1mtsHGOELCU8e/Z7YWzpmybrx/+dSTfLrvY8qRmaY6zXTKWn6WQIjaAFw069icm6GVMNkgu0NzI4iPZUNw==", + "license": "BSD-3-Clause", + "dependencies": { + "istanbul-lib-coverage": "^3.0.0", + "make-dir": "^4.0.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/istanbul-lib-report/node_modules/make-dir": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-4.0.0.tgz", + "integrity": "sha512-hXdUTZYIVOt1Ex//jAQi+wTZZpUpwBj/0QsOzqegb3rGMMeJiSEu5xLHnYfBrRV4RH2+OCSOO95Is/7x1WJ4bw==", + "license": "MIT", + "dependencies": { + "semver": "^7.5.3" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/istanbul-lib-source-maps": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/istanbul-lib-source-maps/-/istanbul-lib-source-maps-4.0.1.tgz", + "integrity": "sha512-n3s8EwkdFIJCG3BPKBYvskgXGoy88ARzvegkitk60NxRdwltLOTaH7CUiMRXvwYorl0Q712iEjcWB+fK/MrWVw==", + "license": "BSD-3-Clause", + "dependencies": { + "debug": "^4.1.1", + "istanbul-lib-coverage": "^3.0.0", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/istanbul-lib-source-maps/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "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==", + "license": "BSD-3-Clause", + "dependencies": { + "html-escaper": "^2.0.0", + "istanbul-lib-report": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/iterator.prototype": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/iterator.prototype/-/iterator.prototype-1.1.5.tgz", + "integrity": "sha512-H0dkQoCa3b2VEeKQBOxFph+JAbcrQdE7KC0UkqwpLmv2EC4P41QXP+rqo9wYodACiG5/WM5s9oDApTU8utwj9g==", + "license": "MIT", + "dependencies": { + "define-data-property": "^1.1.4", + "es-object-atoms": "^1.0.0", + "get-intrinsic": "^1.2.6", + "get-proto": "^1.0.0", + "has-symbols": "^1.1.0", + "set-function-name": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/jackspeak": { + "version": "3.4.3", + "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz", + "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==", + "license": "BlueOak-1.0.0", + "dependencies": { + "@isaacs/cliui": "^8.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + }, + "optionalDependencies": { + "@pkgjs/parseargs": "^0.11.0" + } + }, + "node_modules/jake": { + "version": "10.9.2", + "resolved": "https://registry.npmjs.org/jake/-/jake-10.9.2.tgz", + "integrity": "sha512-2P4SQ0HrLQ+fw6llpLnOaGAvN2Zu6778SJMrCUwns4fOoG9ayrTiZk3VV8sCPkVZF8ab0zksVpS8FDY5pRCNBA==", + "license": "Apache-2.0", + "dependencies": { + "async": "^3.2.3", + "chalk": "^4.0.2", + "filelist": "^1.0.4", + "minimatch": "^3.1.2" + }, + "bin": { + "jake": "bin/cli.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/jest": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest/-/jest-27.5.1.tgz", + "integrity": "sha512-Yn0mADZB89zTtjkPJEXwrac3LHudkQMR+Paqa8uxJHCBr9agxztUifWCyiYrjhMPBoUVBjyny0I7XH6ozDr7QQ==", + "license": "MIT", + "dependencies": { + "@jest/core": "^27.5.1", + "import-local": "^3.0.2", + "jest-cli": "^27.5.1" + }, + "bin": { + "jest": "bin/jest.js" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + } + }, + "node_modules/jest-changed-files": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-changed-files/-/jest-changed-files-27.5.1.tgz", + "integrity": "sha512-buBLMiByfWGCoMsLLzGUUSpAmIAGnbR2KJoMN10ziLhOLvP4e0SlypHnAel8iqQXTrcbmfEY9sSqae5sgUsTvw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "execa": "^5.0.0", + "throat": "^6.0.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-changed-files/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-changed-files/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-circus": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-circus/-/jest-circus-27.5.1.tgz", + "integrity": "sha512-D95R7x5UtlMA5iBYsOHFFbMD/GVA4R/Kdq15f7xYWUfWHBto9NYRsOvnSauTgdF+ogCpJ4tyKOXhUifxS65gdw==", + "license": "MIT", + "dependencies": { + "@jest/environment": "^27.5.1", + "@jest/test-result": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "co": "^4.6.0", + "dedent": "^0.7.0", + "expect": "^27.5.1", + "is-generator-fn": "^2.0.0", + "jest-each": "^27.5.1", + "jest-matcher-utils": "^27.5.1", + "jest-message-util": "^27.5.1", + "jest-runtime": "^27.5.1", + "jest-snapshot": "^27.5.1", + "jest-util": "^27.5.1", + "pretty-format": "^27.5.1", + "slash": "^3.0.0", + "stack-utils": "^2.0.3", + "throat": "^6.0.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-circus/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-circus/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-circus/node_modules/diff-sequences": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-27.5.1.tgz", + "integrity": "sha512-k1gCAXAsNgLwEL+Y8Wvl+M6oEFj5bgazfZULpS5CneoPPXRaCCW7dm+q21Ky2VEE5X+VeRDBVg1Pcvvsr4TtNQ==", + "license": "MIT", + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-circus/node_modules/expect": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/expect/-/expect-27.5.1.tgz", + "integrity": "sha512-E1q5hSUG2AmYQwQJ041nvgpkODHQvB+RKlB4IYdru6uJsyFTRyZAP463M+1lINorwbqAmUggi6+WwkD8lCS/Dw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "jest-get-type": "^27.5.1", + "jest-matcher-utils": "^27.5.1", + "jest-message-util": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-circus/node_modules/jest-diff": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-27.5.1.tgz", + "integrity": "sha512-m0NvkX55LDt9T4mctTEgnZk3fmEg3NRYutvMPWM/0iPnkFj2wIeF45O1718cMSOFO1vINkqmxqD8vE37uTEbqw==", + "license": "MIT", + "dependencies": { + "chalk": "^4.0.0", + "diff-sequences": "^27.5.1", + "jest-get-type": "^27.5.1", + "pretty-format": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-circus/node_modules/jest-get-type": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-27.5.1.tgz", + "integrity": "sha512-2KY95ksYSaK7DMBWQn6dQz3kqAf3BB64y2udeG+hv4KfSOb9qwcYQstTJc1KCbsix+wLZWZYN8t7nwX3GOBLRw==", + "license": "MIT", + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-circus/node_modules/jest-matcher-utils": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-27.5.1.tgz", + "integrity": "sha512-z2uTx/T6LBaCoNWNFWwChLBKYxTMcGBRjAt+2SbP929/Fflb9aa5LGma654Rz8z9HLxsrUaYzxE9T/EFIL/PAw==", + "license": "MIT", + "dependencies": { + "chalk": "^4.0.0", + "jest-diff": "^27.5.1", + "jest-get-type": "^27.5.1", + "pretty-format": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-circus/node_modules/jest-message-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-27.5.1.tgz", + "integrity": "sha512-rMyFe1+jnyAAf+NHwTclDz0eAaLkVDdKVHHBFWsBWHnnh5YeJMNWWsv7AbFYXfK3oTqvL7VTWkhNLu1jX24D+g==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^27.5.1", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^27.5.1", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-circus/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-cli": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-cli/-/jest-cli-27.5.1.tgz", + "integrity": "sha512-Hc6HOOwYq4/74/c62dEE3r5elx8wjYqxY0r0G/nFrLDPMFRu6RA/u8qINOIkvhxG7mMQ5EJsOGfRpI8L6eFUVw==", + "license": "MIT", + "dependencies": { + "@jest/core": "^27.5.1", + "@jest/test-result": "^27.5.1", + "@jest/types": "^27.5.1", + "chalk": "^4.0.0", + "exit": "^0.1.2", + "graceful-fs": "^4.2.9", + "import-local": "^3.0.2", + "jest-config": "^27.5.1", + "jest-util": "^27.5.1", + "jest-validate": "^27.5.1", + "prompts": "^2.0.1", + "yargs": "^16.2.0" + }, + "bin": { + "jest": "bin/jest.js" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + } + }, + "node_modules/jest-cli/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-cli/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-cli/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-config": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-config/-/jest-config-27.5.1.tgz", + "integrity": "sha512-5sAsjm6tGdsVbW9ahcChPAFCk4IlkQUknH5AvKjuLTSlcO/wCZKyFdn7Rg0EkC+OGgWODEy2hDpWB1PgzH0JNA==", + "license": "MIT", + "dependencies": { + "@babel/core": "^7.8.0", + "@jest/test-sequencer": "^27.5.1", + "@jest/types": "^27.5.1", + "babel-jest": "^27.5.1", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "deepmerge": "^4.2.2", + "glob": "^7.1.1", + "graceful-fs": "^4.2.9", + "jest-circus": "^27.5.1", + "jest-environment-jsdom": "^27.5.1", + "jest-environment-node": "^27.5.1", + "jest-get-type": "^27.5.1", + "jest-jasmine2": "^27.5.1", + "jest-regex-util": "^27.5.1", + "jest-resolve": "^27.5.1", + "jest-runner": "^27.5.1", + "jest-util": "^27.5.1", + "jest-validate": "^27.5.1", + "micromatch": "^4.0.4", + "parse-json": "^5.2.0", + "pretty-format": "^27.5.1", + "slash": "^3.0.0", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + }, + "peerDependencies": { + "ts-node": ">=9.0.0" + }, + "peerDependenciesMeta": { + "ts-node": { + "optional": true + } + } + }, + "node_modules/jest-config/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-config/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-config/node_modules/jest-get-type": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-27.5.1.tgz", + "integrity": "sha512-2KY95ksYSaK7DMBWQn6dQz3kqAf3BB64y2udeG+hv4KfSOb9qwcYQstTJc1KCbsix+wLZWZYN8t7nwX3GOBLRw==", + "license": "MIT", + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-config/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-diff": { + "version": "29.7.0", + "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-29.7.0.tgz", + "integrity": "sha512-LMIgiIrhigmPrs03JHpxUh2yISK3vLFPkAodPeo0+BuF7wA2FoQbkEg1u8gBYBThncu7e1oEDUfIXVuTqLRUjw==", + "dev": true, + "license": "MIT", + "dependencies": { + "chalk": "^4.0.0", + "diff-sequences": "^29.6.3", + "jest-get-type": "^29.6.3", + "pretty-format": "^29.7.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-diff/node_modules/ansi-styles": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz", + "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-diff/node_modules/pretty-format": { + "version": "29.7.0", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-29.7.0.tgz", + "integrity": "sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/schemas": "^29.6.3", + "ansi-styles": "^5.0.0", + "react-is": "^18.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-diff/node_modules/react-is": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz", + "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==", + "dev": true, + "license": "MIT" + }, + "node_modules/jest-docblock": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-docblock/-/jest-docblock-27.5.1.tgz", + "integrity": "sha512-rl7hlABeTsRYxKiUfpHrQrG4e2obOiTQWfMEH3PxPjOtdsfLQO4ReWSZaQ7DETm4xu07rl4q/h4zcKXyU0/OzQ==", + "license": "MIT", + "dependencies": { + "detect-newline": "^3.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-each": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-each/-/jest-each-27.5.1.tgz", + "integrity": "sha512-1Ff6p+FbhT/bXQnEouYy00bkNSY7OUpfIcmdl8vZ31A1UUaurOLPA8a8BbJOF2RDUElwJhmeaV7LnagI+5UwNQ==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "chalk": "^4.0.0", + "jest-get-type": "^27.5.1", + "jest-util": "^27.5.1", + "pretty-format": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-each/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-each/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-each/node_modules/jest-get-type": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-27.5.1.tgz", + "integrity": "sha512-2KY95ksYSaK7DMBWQn6dQz3kqAf3BB64y2udeG+hv4KfSOb9qwcYQstTJc1KCbsix+wLZWZYN8t7nwX3GOBLRw==", + "license": "MIT", + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-each/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-environment-jsdom": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-environment-jsdom/-/jest-environment-jsdom-27.5.1.tgz", + "integrity": "sha512-TFBvkTC1Hnnnrka/fUb56atfDtJ9VMZ94JkjTbggl1PEpwrYtUBKMezB3inLmWqQsXYLcMwNoDQwoBTAvFfsfw==", + "license": "MIT", + "dependencies": { + "@jest/environment": "^27.5.1", + "@jest/fake-timers": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "jest-mock": "^27.5.1", + "jest-util": "^27.5.1", + "jsdom": "^16.6.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-environment-jsdom/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-environment-jsdom/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-environment-jsdom/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-environment-node": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-environment-node/-/jest-environment-node-27.5.1.tgz", + "integrity": "sha512-Jt4ZUnxdOsTGwSRAfKEnE6BcwsSPNOijjwifq5sDFSA2kesnXTvNqKHYgM0hDq3549Uf/KzdXNYn4wMZJPlFLw==", + "license": "MIT", + "dependencies": { + "@jest/environment": "^27.5.1", + "@jest/fake-timers": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "jest-mock": "^27.5.1", + "jest-util": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-environment-node/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-environment-node/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-environment-node/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-get-type": { + "version": "29.6.3", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-29.6.3.tgz", + "integrity": "sha512-zrteXnqYxfQh7l5FHyL38jL39di8H8rHoecLH3JNxH3BwOrBsNeabdap5e0I23lD4HHI8W5VFBZqG4Eaq5LNcw==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-haste-map": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-haste-map/-/jest-haste-map-27.5.1.tgz", + "integrity": "sha512-7GgkZ4Fw4NFbMSDSpZwXeBiIbx+t/46nJ2QitkOjvwPYyZmqttu2TDSimMHP1EkPOi4xUZAN1doE5Vd25H4Jng==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/graceful-fs": "^4.1.2", + "@types/node": "*", + "anymatch": "^3.0.3", + "fb-watchman": "^2.0.0", + "graceful-fs": "^4.2.9", + "jest-regex-util": "^27.5.1", + "jest-serializer": "^27.5.1", + "jest-util": "^27.5.1", + "jest-worker": "^27.5.1", + "micromatch": "^4.0.4", + "walker": "^1.0.7" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + }, + "optionalDependencies": { + "fsevents": "^2.3.2" + } + }, + "node_modules/jest-haste-map/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-haste-map/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-haste-map/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-jasmine2": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-jasmine2/-/jest-jasmine2-27.5.1.tgz", + "integrity": "sha512-jtq7VVyG8SqAorDpApwiJJImd0V2wv1xzdheGHRGyuT7gZm6gG47QEskOlzsN1PG/6WNaCo5pmwMHDf3AkG2pQ==", + "license": "MIT", + "dependencies": { + "@jest/environment": "^27.5.1", + "@jest/source-map": "^27.5.1", + "@jest/test-result": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "co": "^4.6.0", + "expect": "^27.5.1", + "is-generator-fn": "^2.0.0", + "jest-each": "^27.5.1", + "jest-matcher-utils": "^27.5.1", + "jest-message-util": "^27.5.1", + "jest-runtime": "^27.5.1", + "jest-snapshot": "^27.5.1", + "jest-util": "^27.5.1", + "pretty-format": "^27.5.1", + "throat": "^6.0.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-jasmine2/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-jasmine2/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-jasmine2/node_modules/diff-sequences": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-27.5.1.tgz", + "integrity": "sha512-k1gCAXAsNgLwEL+Y8Wvl+M6oEFj5bgazfZULpS5CneoPPXRaCCW7dm+q21Ky2VEE5X+VeRDBVg1Pcvvsr4TtNQ==", + "license": "MIT", + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-jasmine2/node_modules/expect": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/expect/-/expect-27.5.1.tgz", + "integrity": "sha512-E1q5hSUG2AmYQwQJ041nvgpkODHQvB+RKlB4IYdru6uJsyFTRyZAP463M+1lINorwbqAmUggi6+WwkD8lCS/Dw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "jest-get-type": "^27.5.1", + "jest-matcher-utils": "^27.5.1", + "jest-message-util": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-jasmine2/node_modules/jest-diff": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-27.5.1.tgz", + "integrity": "sha512-m0NvkX55LDt9T4mctTEgnZk3fmEg3NRYutvMPWM/0iPnkFj2wIeF45O1718cMSOFO1vINkqmxqD8vE37uTEbqw==", + "license": "MIT", + "dependencies": { + "chalk": "^4.0.0", + "diff-sequences": "^27.5.1", + "jest-get-type": "^27.5.1", + "pretty-format": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-jasmine2/node_modules/jest-get-type": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-27.5.1.tgz", + "integrity": "sha512-2KY95ksYSaK7DMBWQn6dQz3kqAf3BB64y2udeG+hv4KfSOb9qwcYQstTJc1KCbsix+wLZWZYN8t7nwX3GOBLRw==", + "license": "MIT", + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-jasmine2/node_modules/jest-matcher-utils": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-27.5.1.tgz", + "integrity": "sha512-z2uTx/T6LBaCoNWNFWwChLBKYxTMcGBRjAt+2SbP929/Fflb9aa5LGma654Rz8z9HLxsrUaYzxE9T/EFIL/PAw==", + "license": "MIT", + "dependencies": { + "chalk": "^4.0.0", + "jest-diff": "^27.5.1", + "jest-get-type": "^27.5.1", + "pretty-format": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-jasmine2/node_modules/jest-message-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-27.5.1.tgz", + "integrity": "sha512-rMyFe1+jnyAAf+NHwTclDz0eAaLkVDdKVHHBFWsBWHnnh5YeJMNWWsv7AbFYXfK3oTqvL7VTWkhNLu1jX24D+g==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^27.5.1", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^27.5.1", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-jasmine2/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-leak-detector": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-leak-detector/-/jest-leak-detector-27.5.1.tgz", + "integrity": "sha512-POXfWAMvfU6WMUXftV4HolnJfnPOGEu10fscNCA76KBpRRhcMN2c8d3iT2pxQS3HLbA+5X4sOUPzYO2NUyIlHQ==", + "license": "MIT", + "dependencies": { + "jest-get-type": "^27.5.1", + "pretty-format": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-leak-detector/node_modules/jest-get-type": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-27.5.1.tgz", + "integrity": "sha512-2KY95ksYSaK7DMBWQn6dQz3kqAf3BB64y2udeG+hv4KfSOb9qwcYQstTJc1KCbsix+wLZWZYN8t7nwX3GOBLRw==", + "license": "MIT", + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-matcher-utils": { + "version": "29.7.0", + "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-29.7.0.tgz", + "integrity": "sha512-sBkD+Xi9DtcChsI3L3u0+N0opgPYnCRPtGcQYrgXmR+hmt/fYfWAL0xRXYU8eWOdfuLgBe0YCW3AFtnRLagq/g==", + "dev": true, + "license": "MIT", + "dependencies": { + "chalk": "^4.0.0", + "jest-diff": "^29.7.0", + "jest-get-type": "^29.6.3", + "pretty-format": "^29.7.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-matcher-utils/node_modules/ansi-styles": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz", + "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-matcher-utils/node_modules/pretty-format": { + "version": "29.7.0", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-29.7.0.tgz", + "integrity": "sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/schemas": "^29.6.3", + "ansi-styles": "^5.0.0", + "react-is": "^18.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-matcher-utils/node_modules/react-is": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz", + "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==", + "dev": true, + "license": "MIT" + }, + "node_modules/jest-message-util": { + "version": "29.7.0", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-29.7.0.tgz", + "integrity": "sha512-GBEV4GRADeP+qtB2+6u61stea8mGcOT4mCtrYISZwfu9/ISHFJ/5zOMXYbpBE9RsS5+Gb63DW4FgmnKJ79Kf6w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^29.6.3", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^29.7.0", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-message-util/node_modules/ansi-styles": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz", + "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-message-util/node_modules/pretty-format": { + "version": "29.7.0", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-29.7.0.tgz", + "integrity": "sha512-Pdlw/oPxN+aXdmM9R00JVC9WVFoCLTKJvDVLgmJ+qAffBMxsV85l/Lu7sNx4zSzPyoL2euImuEwHhOXdEgNFZQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/schemas": "^29.6.3", + "ansi-styles": "^5.0.0", + "react-is": "^18.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-message-util/node_modules/react-is": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz", + "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==", + "dev": true, + "license": "MIT" + }, + "node_modules/jest-mock": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-mock/-/jest-mock-27.5.1.tgz", + "integrity": "sha512-K4jKbY1d4ENhbrG2zuPWaQBvDly+iZ2yAW+T1fATN78hc0sInwn7wZB8XtlNnvHug5RMwV897Xm4LqmPM4e2Og==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-mock/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-mock/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-pnp-resolver": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/jest-pnp-resolver/-/jest-pnp-resolver-1.2.3.tgz", + "integrity": "sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w==", + "license": "MIT", + "engines": { + "node": ">=6" + }, + "peerDependencies": { + "jest-resolve": "*" + }, + "peerDependenciesMeta": { + "jest-resolve": { + "optional": true + } + } + }, + "node_modules/jest-regex-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-27.5.1.tgz", + "integrity": "sha512-4bfKq2zie+x16okqDXjXn9ql2B0dScQu+vcwe4TvFVhkVyuWLqpZrZtXxLLWoXYgn0E87I6r6GRYHF7wFZBUvg==", + "license": "MIT", + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-resolve": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-resolve/-/jest-resolve-27.5.1.tgz", + "integrity": "sha512-FFDy8/9E6CV83IMbDpcjOhumAQPDyETnU2KZ1O98DwTnz8AOBsW/Xv3GySr1mOZdItLR+zDZ7I/UdTFbgSOVCw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^27.5.1", + "jest-pnp-resolver": "^1.2.2", + "jest-util": "^27.5.1", + "jest-validate": "^27.5.1", + "resolve": "^1.20.0", + "resolve.exports": "^1.1.0", + "slash": "^3.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-resolve-dependencies": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-resolve-dependencies/-/jest-resolve-dependencies-27.5.1.tgz", + "integrity": "sha512-QQOOdY4PE39iawDn5rzbIePNigfe5B9Z91GDD1ae/xNDlu9kaat8QQ5EKnNmVWPV54hUdxCVwwj6YMgR2O7IOg==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "jest-regex-util": "^27.5.1", + "jest-snapshot": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-resolve-dependencies/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-resolve-dependencies/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-resolve/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-resolve/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-resolve/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-runner": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-runner/-/jest-runner-27.5.1.tgz", + "integrity": "sha512-g4NPsM4mFCOwFKXO4p/H/kWGdJp9V8kURY2lX8Me2drgXqG7rrZAx5kv+5H7wtt/cdFIjhqYx1HrlqWHaOvDaQ==", + "license": "MIT", + "dependencies": { + "@jest/console": "^27.5.1", + "@jest/environment": "^27.5.1", + "@jest/test-result": "^27.5.1", + "@jest/transform": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "emittery": "^0.8.1", + "graceful-fs": "^4.2.9", + "jest-docblock": "^27.5.1", + "jest-environment-jsdom": "^27.5.1", + "jest-environment-node": "^27.5.1", + "jest-haste-map": "^27.5.1", + "jest-leak-detector": "^27.5.1", + "jest-message-util": "^27.5.1", + "jest-resolve": "^27.5.1", + "jest-runtime": "^27.5.1", + "jest-util": "^27.5.1", + "jest-worker": "^27.5.1", + "source-map-support": "^0.5.6", + "throat": "^6.0.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-runner/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-runner/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-runner/node_modules/jest-message-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-27.5.1.tgz", + "integrity": "sha512-rMyFe1+jnyAAf+NHwTclDz0eAaLkVDdKVHHBFWsBWHnnh5YeJMNWWsv7AbFYXfK3oTqvL7VTWkhNLu1jX24D+g==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^27.5.1", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^27.5.1", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-runner/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-runtime": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-runtime/-/jest-runtime-27.5.1.tgz", + "integrity": "sha512-o7gxw3Gf+H2IGt8fv0RiyE1+r83FJBRruoA+FXrlHw6xEyBsU8ugA6IPfTdVyA0w8HClpbK+DGJxH59UrNMx8A==", + "license": "MIT", + "dependencies": { + "@jest/environment": "^27.5.1", + "@jest/fake-timers": "^27.5.1", + "@jest/globals": "^27.5.1", + "@jest/source-map": "^27.5.1", + "@jest/test-result": "^27.5.1", + "@jest/transform": "^27.5.1", + "@jest/types": "^27.5.1", + "chalk": "^4.0.0", + "cjs-module-lexer": "^1.0.0", + "collect-v8-coverage": "^1.0.0", + "execa": "^5.0.0", + "glob": "^7.1.3", + "graceful-fs": "^4.2.9", + "jest-haste-map": "^27.5.1", + "jest-message-util": "^27.5.1", + "jest-mock": "^27.5.1", + "jest-regex-util": "^27.5.1", + "jest-resolve": "^27.5.1", + "jest-snapshot": "^27.5.1", + "jest-util": "^27.5.1", + "slash": "^3.0.0", + "strip-bom": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-runtime/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-runtime/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-runtime/node_modules/jest-message-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-27.5.1.tgz", + "integrity": "sha512-rMyFe1+jnyAAf+NHwTclDz0eAaLkVDdKVHHBFWsBWHnnh5YeJMNWWsv7AbFYXfK3oTqvL7VTWkhNLu1jX24D+g==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^27.5.1", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^27.5.1", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-runtime/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-serializer": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-serializer/-/jest-serializer-27.5.1.tgz", + "integrity": "sha512-jZCyo6iIxO1aqUxpuBlwTDMkzOAJS4a3eYz3YzgxxVQFwLeSA7Jfq5cbqCY+JLvTDrWirgusI/0KwxKMgrdf7w==", + "license": "MIT", + "dependencies": { + "@types/node": "*", + "graceful-fs": "^4.2.9" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-snapshot": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-snapshot/-/jest-snapshot-27.5.1.tgz", + "integrity": "sha512-yYykXI5a0I31xX67mgeLw1DZ0bJB+gpq5IpSuCAoyDi0+BhgU/RIrL+RTzDmkNTchvDFWKP8lp+w/42Z3us5sA==", + "license": "MIT", + "dependencies": { + "@babel/core": "^7.7.2", + "@babel/generator": "^7.7.2", + "@babel/plugin-syntax-typescript": "^7.7.2", + "@babel/traverse": "^7.7.2", + "@babel/types": "^7.0.0", + "@jest/transform": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/babel__traverse": "^7.0.4", + "@types/prettier": "^2.1.5", + "babel-preset-current-node-syntax": "^1.0.0", + "chalk": "^4.0.0", + "expect": "^27.5.1", + "graceful-fs": "^4.2.9", + "jest-diff": "^27.5.1", + "jest-get-type": "^27.5.1", + "jest-haste-map": "^27.5.1", + "jest-matcher-utils": "^27.5.1", + "jest-message-util": "^27.5.1", + "jest-util": "^27.5.1", + "natural-compare": "^1.4.0", + "pretty-format": "^27.5.1", + "semver": "^7.3.2" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-snapshot/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-snapshot/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-snapshot/node_modules/diff-sequences": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-27.5.1.tgz", + "integrity": "sha512-k1gCAXAsNgLwEL+Y8Wvl+M6oEFj5bgazfZULpS5CneoPPXRaCCW7dm+q21Ky2VEE5X+VeRDBVg1Pcvvsr4TtNQ==", + "license": "MIT", + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-snapshot/node_modules/expect": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/expect/-/expect-27.5.1.tgz", + "integrity": "sha512-E1q5hSUG2AmYQwQJ041nvgpkODHQvB+RKlB4IYdru6uJsyFTRyZAP463M+1lINorwbqAmUggi6+WwkD8lCS/Dw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "jest-get-type": "^27.5.1", + "jest-matcher-utils": "^27.5.1", + "jest-message-util": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-snapshot/node_modules/jest-diff": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-diff/-/jest-diff-27.5.1.tgz", + "integrity": "sha512-m0NvkX55LDt9T4mctTEgnZk3fmEg3NRYutvMPWM/0iPnkFj2wIeF45O1718cMSOFO1vINkqmxqD8vE37uTEbqw==", + "license": "MIT", + "dependencies": { + "chalk": "^4.0.0", + "diff-sequences": "^27.5.1", + "jest-get-type": "^27.5.1", + "pretty-format": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-snapshot/node_modules/jest-get-type": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-27.5.1.tgz", + "integrity": "sha512-2KY95ksYSaK7DMBWQn6dQz3kqAf3BB64y2udeG+hv4KfSOb9qwcYQstTJc1KCbsix+wLZWZYN8t7nwX3GOBLRw==", + "license": "MIT", + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-snapshot/node_modules/jest-matcher-utils": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-matcher-utils/-/jest-matcher-utils-27.5.1.tgz", + "integrity": "sha512-z2uTx/T6LBaCoNWNFWwChLBKYxTMcGBRjAt+2SbP929/Fflb9aa5LGma654Rz8z9HLxsrUaYzxE9T/EFIL/PAw==", + "license": "MIT", + "dependencies": { + "chalk": "^4.0.0", + "jest-diff": "^27.5.1", + "jest-get-type": "^27.5.1", + "pretty-format": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-snapshot/node_modules/jest-message-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-27.5.1.tgz", + "integrity": "sha512-rMyFe1+jnyAAf+NHwTclDz0eAaLkVDdKVHHBFWsBWHnnh5YeJMNWWsv7AbFYXfK3oTqvL7VTWkhNLu1jX24D+g==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^27.5.1", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^27.5.1", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-snapshot/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-util": { + "version": "29.7.0", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-29.7.0.tgz", + "integrity": "sha512-z6EbKajIpqGKU56y5KBUgy1dt1ihhQJgWzUlZHArA/+X2ad7Cb5iF+AK1EWVL/Bo7Rz9uurpqw6SiBCefUbCGA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jest/types": "^29.6.3", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-validate": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-validate/-/jest-validate-27.5.1.tgz", + "integrity": "sha512-thkNli0LYTmOI1tDB3FI1S1RTp/Bqyd9pTarJwL87OIBFuqEb5Apv5EaApEudYg4g86e3CT6kM0RowkhtEnCBQ==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "camelcase": "^6.2.0", + "chalk": "^4.0.0", + "jest-get-type": "^27.5.1", + "leven": "^3.1.0", + "pretty-format": "^27.5.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-validate/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-validate/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-validate/node_modules/jest-get-type": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-get-type/-/jest-get-type-27.5.1.tgz", + "integrity": "sha512-2KY95ksYSaK7DMBWQn6dQz3kqAf3BB64y2udeG+hv4KfSOb9qwcYQstTJc1KCbsix+wLZWZYN8t7nwX3GOBLRw==", + "license": "MIT", + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-watch-typeahead": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/jest-watch-typeahead/-/jest-watch-typeahead-1.1.0.tgz", + "integrity": "sha512-Va5nLSJTN7YFtC2jd+7wsoe1pNe5K4ShLux/E5iHEwlB9AxaxmggY7to9KUqKojhaJw3aXqt5WAb4jGPOolpEw==", + "license": "MIT", + "dependencies": { + "ansi-escapes": "^4.3.1", + "chalk": "^4.0.0", + "jest-regex-util": "^28.0.0", + "jest-watcher": "^28.0.0", + "slash": "^4.0.0", + "string-length": "^5.0.1", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "peerDependencies": { + "jest": "^27.0.0 || ^28.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/@jest/console": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/@jest/console/-/console-28.1.3.tgz", + "integrity": "sha512-QPAkP5EwKdK/bxIr6C1I4Vs0rm2nHiANzj/Z5X2JQkrZo6IqvC4ldZ9K95tF0HdidhA8Bo6egxSzUFPYKcEXLw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^28.1.3", + "@types/node": "*", + "chalk": "^4.0.0", + "jest-message-util": "^28.1.3", + "jest-util": "^28.1.3", + "slash": "^3.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/@jest/console/node_modules/slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-watch-typeahead/node_modules/@jest/schemas": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-28.1.3.tgz", + "integrity": "sha512-/l/VWsdt/aBXgjshLWOFyFt3IVdYypu5y2Wn2rOO1un6nkqIn8SLXzgIMYXFyYsRWDyF5EthmKJMIdJvk08grg==", + "license": "MIT", + "dependencies": { + "@sinclair/typebox": "^0.24.1" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/@jest/test-result": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/@jest/test-result/-/test-result-28.1.3.tgz", + "integrity": "sha512-kZAkxnSE+FqE8YjW8gNuoVkkC9I7S1qmenl8sGcDOLropASP+BkcGKwhXoyqQuGOGeYY0y/ixjrd/iERpEXHNg==", + "license": "MIT", + "dependencies": { + "@jest/console": "^28.1.3", + "@jest/types": "^28.1.3", + "@types/istanbul-lib-coverage": "^2.0.0", + "collect-v8-coverage": "^1.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/@jest/types": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-28.1.3.tgz", + "integrity": "sha512-RyjiyMUZrKz/c+zlMFO1pm70DcIlST8AeWTkoUdZevew44wcNZQHsEVOiCVtgVnlFFD82FPaXycys58cf2muVQ==", + "license": "MIT", + "dependencies": { + "@jest/schemas": "^28.1.3", + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^17.0.8", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/@sinclair/typebox": { + "version": "0.24.51", + "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.24.51.tgz", + "integrity": "sha512-1P1OROm/rdubP5aFDSZQILU0vrLCJ4fvHt6EoqHEM+2D/G5MK3bIaymUKLit8Js9gbns5UyJnkP/TZROLw4tUA==", + "license": "MIT" + }, + "node_modules/jest-watch-typeahead/node_modules/ansi-styles": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz", + "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/jest-watch-typeahead/node_modules/emittery": { + "version": "0.10.2", + "resolved": "https://registry.npmjs.org/emittery/-/emittery-0.10.2.tgz", + "integrity": "sha512-aITqOwnLanpHLNXZJENbOgjUBeHocD+xsSJmNrjovKBW5HbSpW3d1pEls7GFQPUWXiwG9+0P4GtHfEqC/4M0Iw==", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sindresorhus/emittery?sponsor=1" + } + }, + "node_modules/jest-watch-typeahead/node_modules/jest-message-util": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/jest-message-util/-/jest-message-util-28.1.3.tgz", + "integrity": "sha512-PFdn9Iewbt575zKPf1286Ht9EPoJmYT7P0kY+RibeYZ2XtOr53pDLEFoTWXbd1h4JiGiWpTBC84fc8xMXQMb7g==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.12.13", + "@jest/types": "^28.1.3", + "@types/stack-utils": "^2.0.0", + "chalk": "^4.0.0", + "graceful-fs": "^4.2.9", + "micromatch": "^4.0.4", + "pretty-format": "^28.1.3", + "slash": "^3.0.0", + "stack-utils": "^2.0.3" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/jest-message-util/node_modules/slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-watch-typeahead/node_modules/jest-regex-util": { + "version": "28.0.2", + "resolved": "https://registry.npmjs.org/jest-regex-util/-/jest-regex-util-28.0.2.tgz", + "integrity": "sha512-4s0IgyNIy0y9FK+cjoVYoxamT7Zeo7MhzqRGx7YDYmaQn1wucY9rotiGkBzzcMXTtjrCAP/f7f+E0F7+fxPNdw==", + "license": "MIT", + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/jest-util": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-28.1.3.tgz", + "integrity": "sha512-XdqfpHwpcSRko/C35uLYFM2emRAltIIKZiJ9eAmhjsj0CqZMa0p1ib0R5fWIqGhn1a103DebTbpqIaP1qCQ6tQ==", + "license": "MIT", + "dependencies": { + "@jest/types": "^28.1.3", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/jest-watcher": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/jest-watcher/-/jest-watcher-28.1.3.tgz", + "integrity": "sha512-t4qcqj9hze+jviFPUN3YAtAEeFnr/azITXQEMARf5cMwKY2SMBRnCQTXLixTl20OR6mLh9KLMrgVJgJISym+1g==", + "license": "MIT", + "dependencies": { + "@jest/test-result": "^28.1.3", + "@jest/types": "^28.1.3", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "emittery": "^0.10.2", + "jest-util": "^28.1.3", + "string-length": "^4.0.1" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/jest-watcher/node_modules/string-length": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/string-length/-/string-length-4.0.2.tgz", + "integrity": "sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==", + "license": "MIT", + "dependencies": { + "char-regex": "^1.0.2", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/jest-watch-typeahead/node_modules/jest-watcher/node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/jest-watch-typeahead/node_modules/pretty-format": { + "version": "28.1.3", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-28.1.3.tgz", + "integrity": "sha512-8gFb/To0OmxHR9+ZTb14Df2vNxdGCX8g1xWGUTqUw5TiZvcQf5sHKObd5UcPyLLyowNwDAMTF3XWOG1B6mxl1Q==", + "license": "MIT", + "dependencies": { + "@jest/schemas": "^28.1.3", + "ansi-regex": "^5.0.1", + "ansi-styles": "^5.0.0", + "react-is": "^18.0.0" + }, + "engines": { + "node": "^12.13.0 || ^14.15.0 || ^16.10.0 || >=17.0.0" + } + }, + "node_modules/jest-watch-typeahead/node_modules/react-is": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz", + "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==", + "license": "MIT" + }, + "node_modules/jest-watch-typeahead/node_modules/slash": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-4.0.0.tgz", + "integrity": "sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew==", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/jest-watch-typeahead/node_modules/string-length": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/string-length/-/string-length-5.0.1.tgz", + "integrity": "sha512-9Ep08KAMUn0OadnVaBuRdE2l615CQ508kr0XMadjClfYpdCyvrbFp6Taebo8yyxokQ4viUd/xPPUA4FGgUa0ow==", + "license": "MIT", + "dependencies": { + "char-regex": "^2.0.0", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12.20" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/jest-watch-typeahead/node_modules/string-length/node_modules/char-regex": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/char-regex/-/char-regex-2.0.2.tgz", + "integrity": "sha512-cbGOjAptfM2LVmWhwRFHEKTPkLwNddVmuqYZQt895yXwAsWsXObCG+YN4DGQ/JBtT4GP1a1lPPdio2z413LmTg==", + "license": "MIT", + "engines": { + "node": ">=12.20" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "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==", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/jest-watcher": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-watcher/-/jest-watcher-27.5.1.tgz", + "integrity": "sha512-z676SuD6Z8o8qbmEGhoEUFOM1+jfEiL3DXHK/xgEiG2EyNYfFG60jluWcupY6dATjfEsKQuibReS1djInQnoVw==", + "license": "MIT", + "dependencies": { + "@jest/test-result": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "jest-util": "^27.5.1", + "string-length": "^4.0.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-watcher/node_modules/@jest/types": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/@jest/types/-/types-27.5.1.tgz", + "integrity": "sha512-Cx46iJ9QpwQTjIdq5VJu2QTMMs3QlEjI0x1QbBP5W1+nMzyc2XmimiRR/CbX9TO0cPTeUlxWMOu8mslYsJ8DEw==", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^16.0.0", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-watcher/node_modules/@types/yargs": { + "version": "16.0.9", + "resolved": "https://registry.npmjs.org/@types/yargs/-/yargs-16.0.9.tgz", + "integrity": "sha512-tHhzvkFXZQeTECenFoRljLBYPZJ7jAVxqqtEI0qTLOmuultnFp4I9yKE17vTuhf7BkhCu7I4XuemPgikDVuYqA==", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/jest-watcher/node_modules/jest-util": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-util/-/jest-util-27.5.1.tgz", + "integrity": "sha512-Kv2o/8jNvX1MQ0KGtw480E/w4fBCDOnH6+6DmeKi6LZUIlKA5kwY0YNdlzaWTiVgxqAqik11QyxDOKk543aKXw==", + "license": "MIT", + "dependencies": { + "@jest/types": "^27.5.1", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/jest-worker": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-27.5.1.tgz", + "integrity": "sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==", + "license": "MIT", + "dependencies": { + "@types/node": "*", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" + }, + "engines": { + "node": ">= 10.13.0" + } + }, + "node_modules/jest-worker/node_modules/supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/jiti": { + "version": "1.21.7", + "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz", + "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==", + "license": "MIT", + "bin": { + "jiti": "bin/jiti.js" + } + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "license": "MIT" + }, + "node_modules/js-yaml": { + "version": "3.14.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz", + "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==", + "license": "MIT", + "dependencies": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsdom": { + "version": "16.7.0", + "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-16.7.0.tgz", + "integrity": "sha512-u9Smc2G1USStM+s/x1ru5Sxrl6mPYCbByG1U/hUmqaVsm4tbNyS7CicOSRyuGQYZhTu0h84qkZZQ/I+dzizSVw==", + "license": "MIT", + "dependencies": { + "abab": "^2.0.5", + "acorn": "^8.2.4", + "acorn-globals": "^6.0.0", + "cssom": "^0.4.4", + "cssstyle": "^2.3.0", + "data-urls": "^2.0.0", + "decimal.js": "^10.2.1", + "domexception": "^2.0.1", + "escodegen": "^2.0.0", + "form-data": "^3.0.0", + "html-encoding-sniffer": "^2.0.1", + "http-proxy-agent": "^4.0.1", + "https-proxy-agent": "^5.0.0", + "is-potential-custom-element-name": "^1.0.1", + "nwsapi": "^2.2.0", + "parse5": "6.0.1", + "saxes": "^5.0.1", + "symbol-tree": "^3.2.4", + "tough-cookie": "^4.0.0", + "w3c-hr-time": "^1.0.2", + "w3c-xmlserializer": "^2.0.0", + "webidl-conversions": "^6.1.0", + "whatwg-encoding": "^1.0.5", + "whatwg-mimetype": "^2.3.0", + "whatwg-url": "^8.5.0", + "ws": "^7.4.6", + "xml-name-validator": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "canvas": "^2.5.0" + }, + "peerDependenciesMeta": { + "canvas": { + "optional": true + } + } + }, + "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==", + "license": "MIT", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "es-set-tostringtag": "^2.1.0", + "mime-types": "^2.1.35" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/json-buffer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", + "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==", + "license": "MIT" + }, + "node_modules/json-parse-even-better-errors": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", + "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", + "license": "MIT" + }, + "node_modules/json-schema": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.4.0.tgz", + "integrity": "sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==", + "license": "(AFL-2.1 OR BSD-3-Clause)" + }, + "node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==", + "license": "MIT" + }, + "node_modules/json-stable-stringify-without-jsonify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz", + "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==", + "license": "MIT" + }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "license": "MIT", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/jsonfile": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz", + "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==", + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/jsonpath": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/jsonpath/-/jsonpath-1.1.1.tgz", + "integrity": "sha512-l6Cg7jRpixfbgoWgkrl77dgEj8RPvND0wMH6TwQmi9Qs4TFfS9u5cUFnbeKTwj5ga5Y3BTGGNI28k117LJ009w==", + "license": "MIT", + "dependencies": { + "esprima": "1.2.2", + "static-eval": "2.0.2", + "underscore": "1.12.1" + } + }, + "node_modules/jsonpath/node_modules/esprima": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-1.2.2.tgz", + "integrity": "sha512-+JpPZam9w5DuJ3Q67SqsMGtiHKENSMRVoxvArfJZK01/BfLEObtZ6orJa/MtoGNR/rfMgp5837T41PAmTwAv/A==", + "bin": { + "esparse": "bin/esparse.js", + "esvalidate": "bin/esvalidate.js" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/jsonpointer": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/jsonpointer/-/jsonpointer-5.0.1.tgz", + "integrity": "sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/jsx-ast-utils": { + "version": "3.3.5", + "resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-3.3.5.tgz", + "integrity": "sha512-ZZow9HBI5O6EPgSJLUb8n2NKgmVWTwCvHGwFuJlMjvLFqlGG6pjirPhtdsseaLZjSibD8eegzmYpUZwoIlj2cQ==", + "license": "MIT", + "dependencies": { + "array-includes": "^3.1.6", + "array.prototype.flat": "^1.3.1", + "object.assign": "^4.1.4", + "object.values": "^1.1.6" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/jwt-decode": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/jwt-decode/-/jwt-decode-3.1.2.tgz", + "integrity": "sha512-UfpWE/VZn0iP50d8cz9NrZLM9lSWhcJ+0Gt/nm4by88UL+J1SiKN8/5dkjMmbEzwL2CAe+67GsegCbIKtbp75A==", + "license": "MIT" + }, + "node_modules/katex": { + "version": "0.16.22", + "resolved": "https://registry.npmjs.org/katex/-/katex-0.16.22.tgz", + "integrity": "sha512-XCHRdUw4lf3SKBaJe4EvgqIuWwkPSo9XoeO8GjQW94Bp7TWv9hNhzZjZ+OH9yf1UmLygb7DIT5GSFQiyt16zYg==", + "funding": [ + "https://opencollective.com/katex", + "https://github.com/sponsors/katex" + ], + "license": "MIT", + "dependencies": { + "commander": "^8.3.0" + }, + "bin": { + "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", + "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==", + "license": "MIT", + "dependencies": { + "json-buffer": "3.0.1" + } + }, + "node_modules/khroma": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/khroma/-/khroma-2.1.0.tgz", + "integrity": "sha512-Ls993zuzfayK269Svk9hzpeGUKob/sIgZzyHYdjQoAdQetRKpOLj+k/QQQ/6Qi0Yz65mlROrfd+Ev+1+7dz9Kw==" + }, + "node_modules/kind-of": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", + "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/kleur": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz", + "integrity": "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/klona": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/klona/-/klona-2.0.6.tgz", + "integrity": "sha512-dhG34DXATL5hSxJbIexCft8FChFXtmskoZYnoPWjXQuebWYCNkVeV3KkGegCK9CP1oswI/vQibS2GY7Em/sJJA==", + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/kolorist": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/kolorist/-/kolorist-1.8.0.tgz", + "integrity": "sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ==", + "license": "MIT" + }, + "node_modules/langium": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/langium/-/langium-3.3.1.tgz", + "integrity": "sha512-QJv/h939gDpvT+9SiLVlY7tZC3xB2qK57v0J04Sh9wpMb6MP1q8gB21L3WIo8T5P1MSMg3Ep14L7KkDCFG3y4w==", + "license": "MIT", + "dependencies": { + "chevrotain": "~11.0.3", + "chevrotain-allstar": "~0.3.0", + "vscode-languageserver": "~9.0.1", + "vscode-languageserver-textdocument": "~1.0.11", + "vscode-uri": "~3.0.8" + }, + "engines": { + "node": ">=16.0.0" + } + }, + "node_modules/language-subtag-registry": { + "version": "0.3.23", + "resolved": "https://registry.npmjs.org/language-subtag-registry/-/language-subtag-registry-0.3.23.tgz", + "integrity": "sha512-0K65Lea881pHotoGEa5gDlMxt3pctLi2RplBb7Ezh4rRdLEOtgi7n4EwK9lamnUCkKBqaeKRVebTq6BAxSkpXQ==", + "license": "CC0-1.0" + }, + "node_modules/language-tags": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/language-tags/-/language-tags-1.0.9.tgz", + "integrity": "sha512-MbjN408fEndfiQXbFQ1vnd+1NoLDsnQW41410oQBXiyXDMYH5z505juWa4KUE1LqxRC7DgOgZDbKLxHIwm27hA==", + "license": "MIT", + "dependencies": { + "language-subtag-registry": "^0.3.20" + }, + "engines": { + "node": ">=0.10" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "picocolors": "^1.0.0", + "shell-quote": "^1.8.1" + } + }, + "node_modules/layout-base": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/layout-base/-/layout-base-1.0.2.tgz", + "integrity": "sha512-8h2oVEZNktL4BH2JCOI90iD1yXwL6iNW7KcCKT2QZgQJR2vbqDsldCTPRU9NifTCqHZci57XvQQ15YTu+sTYPg==", + "license": "MIT" + }, + "node_modules/leven": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/leven/-/leven-3.1.0.tgz", + "integrity": "sha512-qsda+H8jTaUaN/x5vzW2rzc+8Rw4TAQ/4KjB46IwK5VH+IlVeeeje/EoZRpiXvIqjFgK84QffqPztGI3VBLG1A==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/levn": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz", + "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==", + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/lilconfig": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-2.1.0.tgz", + "integrity": "sha512-utWOt/GHzuUxnLKxB6dk81RoOeoNeHgbrXiuGk4yyF5qlRz+iIVWu56E2fqGHFrXz0QNUhLB/8nKqvRH66JKGQ==", + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/lines-and-columns": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", + "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", + "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==", + "license": "MIT", + "engines": { + "node": ">=6.11.5" + } + }, + "node_modules/loader-utils": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-2.0.4.tgz", + "integrity": "sha512-xXqpXoINfFhgua9xiqD8fPFHgkoq1mmmpE92WlDbm9rNRd/EbRb+Gqf908T2DMfuHjjJlksiK2RbHVOdD/MqSw==", + "license": "MIT", + "dependencies": { + "big.js": "^5.2.2", + "emojis-list": "^3.0.0", + "json5": "^2.1.2" + }, + "engines": { + "node": ">=8.9.0" + } + }, + "node_modules/local-pkg": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/local-pkg/-/local-pkg-1.1.1.tgz", + "integrity": "sha512-WunYko2W1NcdfAFpuLUoucsgULmgDBRkdxHxWQ7mK0cQqwPiy8E1enjuRBrhLtZkB5iScJ1XIPdhVEFK8aOLSg==", + "license": "MIT", + "dependencies": { + "mlly": "^1.7.4", + "pkg-types": "^2.0.1", + "quansync": "^0.2.8" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/locate-path": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-5.0.0.tgz", + "integrity": "sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g==", + "license": "MIT", + "dependencies": { + "p-locate": "^4.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/lodash": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", + "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==", + "license": "MIT" + }, + "node_modules/lodash-es": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash-es/-/lodash-es-4.17.21.tgz", + "integrity": "sha512-mKnC+QJ9pWVzv+C4/U3rRsHapFfHvQFoFB92e52xeyGMcX6/OlIl78je1u8vePzYZSkkogMPJ2yjxxsb89cxyw==", + "license": "MIT" + }, + "node_modules/lodash.debounce": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/lodash.debounce/-/lodash.debounce-4.0.8.tgz", + "integrity": "sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==", + "license": "MIT" + }, + "node_modules/lodash.memoize": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz", + "integrity": "sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==", + "license": "MIT" + }, + "node_modules/lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "license": "MIT" + }, + "node_modules/lodash.sortby": { + "version": "4.7.0", + "resolved": "https://registry.npmjs.org/lodash.sortby/-/lodash.sortby-4.7.0.tgz", + "integrity": "sha512-HDWXG8isMntAyRF5vZ7xKuEvOhT4AhlRt/3czTSjvGUxjYCBVRQY48ViDHyfYz9VIoBkW4TMGQNapx+l3RUwdA==", + "license": "MIT" + }, + "node_modules/lodash.uniq": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz", + "integrity": "sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==", + "license": "MIT" + }, + "node_modules/longest-streak": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-3.1.0.tgz", + "integrity": "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/loose-envify": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", + "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", + "license": "MIT", + "dependencies": { + "js-tokens": "^3.0.0 || ^4.0.0" + }, + "bin": { + "loose-envify": "cli.js" + } + }, + "node_modules/lower-case": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/lower-case/-/lower-case-2.0.2.tgz", + "integrity": "sha512-7fm3l3NAF9WfN6W3JOmf5drwpVqX78JtoGJ3A6W0a6ZnldM41w2fV5D490psKFTpMds8TJse/eHLFFsNHHjHgg==", + "license": "MIT", + "dependencies": { + "tslib": "^2.0.3" + } + }, + "node_modules/lowlight": { + "version": "1.20.0", + "resolved": "https://registry.npmjs.org/lowlight/-/lowlight-1.20.0.tgz", + "integrity": "sha512-8Ktj+prEb1RoCPkEOrPMYUN/nCggB7qAWe3a7OpMjWQkh3l2RD5wKRQ+o8Q8YuI9RG/xs95waaI/E6ym/7NsTw==", + "license": "MIT", + "dependencies": { + "fault": "^1.0.0", + "highlight.js": "~10.7.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "license": "ISC", + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/lz-string": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz", + "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==", + "dev": true, + "license": "MIT", + "bin": { + "lz-string": "bin/bin.js" + } + }, + "node_modules/magic-string": { + "version": "0.25.9", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.25.9.tgz", + "integrity": "sha512-RmF0AsMzgt25qzqqLc1+MbHmhdx0ojF2Fvs4XnOqz2ZOBXzzkEwc/dJQZCYHAn7v1jbVOjAZfK8msRn4BxO4VQ==", + "license": "MIT", + "dependencies": { + "sourcemap-codec": "^1.4.8" + } + }, + "node_modules/make-dir": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz", + "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==", + "license": "MIT", + "dependencies": { + "semver": "^6.0.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/make-dir/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/makeerror": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/makeerror/-/makeerror-1.0.12.tgz", + "integrity": "sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==", + "license": "BSD-3-Clause", + "dependencies": { + "tmpl": "1.0.5" + } + }, + "node_modules/markdown-table": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-3.0.4.tgz", + "integrity": "sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/marked": { + "version": "15.0.11", + "resolved": "https://registry.npmjs.org/marked/-/marked-15.0.11.tgz", + "integrity": "sha512-1BEXAU2euRCG3xwgLVT1y0xbJEld1XOrmRJpUwRCcy7rxhSCwMrmEu9LXoPhHSCJG41V7YcQ2mjKRr5BA3ITIA==", + "license": "MIT", + "bin": { + "marked": "bin/marked.js" + }, + "engines": { + "node": ">= 18" + } + }, + "node_modules/math-intrinsics": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz", + "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/mdast-util-find-and-replace": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/mdast-util-find-and-replace/-/mdast-util-find-and-replace-3.0.2.tgz", + "integrity": "sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg==", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "escape-string-regexp": "^5.0.0", + "unist-util-is": "^6.0.0", + "unist-util-visit-parents": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-5.0.0.tgz", + "integrity": "sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mdast-util-from-markdown": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.2.tgz", + "integrity": "sha512-uZhTV/8NBuw0WHkPTrCqDOl0zVe1BIng5ZtHoDk49ME1qqcjYmmLmOf0gELgcRMxN4w2iuIeVso5/6QymSrgmA==", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "@types/unist": "^3.0.0", + "decode-named-character-reference": "^1.0.0", + "devlop": "^1.0.0", + "mdast-util-to-string": "^4.0.0", + "micromark": "^4.0.0", + "micromark-util-decode-numeric-character-reference": "^2.0.0", + "micromark-util-decode-string": "^2.0.0", + "micromark-util-normalize-identifier": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0", + "unist-util-stringify-position": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-gfm": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/mdast-util-gfm/-/mdast-util-gfm-3.1.0.tgz", + "integrity": "sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==", + "license": "MIT", + "dependencies": { + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-gfm-autolink-literal": "^2.0.0", + "mdast-util-gfm-footnote": "^2.0.0", + "mdast-util-gfm-strikethrough": "^2.0.0", + "mdast-util-gfm-table": "^2.0.0", + "mdast-util-gfm-task-list-item": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-gfm-autolink-literal": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/mdast-util-gfm-autolink-literal/-/mdast-util-gfm-autolink-literal-2.0.1.tgz", + "integrity": "sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ==", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "ccount": "^2.0.0", + "devlop": "^1.0.0", + "mdast-util-find-and-replace": "^3.0.0", + "micromark-util-character": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-gfm-footnote": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mdast-util-gfm-footnote/-/mdast-util-gfm-footnote-2.1.0.tgz", + "integrity": "sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ==", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "devlop": "^1.1.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0", + "micromark-util-normalize-identifier": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-gfm-strikethrough": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/mdast-util-gfm-strikethrough/-/mdast-util-gfm-strikethrough-2.0.0.tgz", + "integrity": "sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg==", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-gfm-table": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/mdast-util-gfm-table/-/mdast-util-gfm-table-2.0.0.tgz", + "integrity": "sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg==", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "devlop": "^1.0.0", + "markdown-table": "^3.0.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-gfm-task-list-item": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/mdast-util-gfm-task-list-item/-/mdast-util-gfm-task-list-item-2.0.0.tgz", + "integrity": "sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ==", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "devlop": "^1.0.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-mdx-expression": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/mdast-util-mdx-expression/-/mdast-util-mdx-expression-2.0.1.tgz", + "integrity": "sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==", + "license": "MIT", + "dependencies": { + "@types/estree-jsx": "^1.0.0", + "@types/hast": "^3.0.0", + "@types/mdast": "^4.0.0", + "devlop": "^1.0.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-mdx-jsx": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.2.0.tgz", + "integrity": "sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==", + "license": "MIT", + "dependencies": { + "@types/estree-jsx": "^1.0.0", + "@types/hast": "^3.0.0", + "@types/mdast": "^4.0.0", + "@types/unist": "^3.0.0", + "ccount": "^2.0.0", + "devlop": "^1.1.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0", + "parse-entities": "^4.0.0", + "stringify-entities": "^4.0.0", + "unist-util-stringify-position": "^4.0.0", + "vfile-message": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-mdxjs-esm": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/mdast-util-mdxjs-esm/-/mdast-util-mdxjs-esm-2.0.1.tgz", + "integrity": "sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg==", + "license": "MIT", + "dependencies": { + "@types/estree-jsx": "^1.0.0", + "@types/hast": "^3.0.0", + "@types/mdast": "^4.0.0", + "devlop": "^1.0.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-phrasing": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/mdast-util-phrasing/-/mdast-util-phrasing-4.1.0.tgz", + "integrity": "sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "unist-util-is": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-to-hast": { + "version": "13.2.0", + "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.0.tgz", + "integrity": "sha512-QGYKEuUsYT9ykKBCMOEDLsU5JRObWQusAolFMeko/tYPufNkRffBAQjIE+99jbA87xv6FgmjLtwjh9wBWajwAA==", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/mdast": "^4.0.0", + "@ungap/structured-clone": "^1.0.0", + "devlop": "^1.0.0", + "micromark-util-sanitize-uri": "^2.0.0", + "trim-lines": "^3.0.0", + "unist-util-position": "^5.0.0", + "unist-util-visit": "^5.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-to-markdown": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-2.1.2.tgz", + "integrity": "sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "@types/unist": "^3.0.0", + "longest-streak": "^3.0.0", + "mdast-util-phrasing": "^4.0.0", + "mdast-util-to-string": "^4.0.0", + "micromark-util-classify-character": "^2.0.0", + "micromark-util-decode-string": "^2.0.0", + "unist-util-visit": "^5.0.0", + "zwitch": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-to-string": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-4.0.0.tgz", + "integrity": "sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdn-data": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.4.tgz", + "integrity": "sha512-iV3XNKw06j5Q7mi6h+9vbx23Tv7JkjEVgKHW4pimwyDGWm0OIQntJJ+u1C6mg6mK1EaTv42XQ7w76yuzH7M2cA==", + "license": "CC0-1.0" + }, + "node_modules/media-typer": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz", + "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/memfs": { + "version": "3.5.3", + "resolved": "https://registry.npmjs.org/memfs/-/memfs-3.5.3.tgz", + "integrity": "sha512-UERzLsxzllchadvbPs5aolHh65ISpKpM+ccLbOJ8/vvpBKmAWf+la7dXFy7Mr0ySHbdHrFv5kGFCUHHe6GFEmw==", + "license": "Unlicense", + "dependencies": { + "fs-monkey": "^1.0.4" + }, + "engines": { + "node": ">= 4.0.0" + } + }, + "node_modules/memoize-one": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/memoize-one/-/memoize-one-5.2.1.tgz", + "integrity": "sha512-zYiwtZUcYyXKo/np96AGZAckk+FWWsUdJ3cHGGmld7+AhvcWmQyGCYUh1hc4Q/pkOhb65dQR/pqCyK0cOaHz4Q==", + "license": "MIT" + }, + "node_modules/merge-descriptors": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz", + "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/merge-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", + "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", + "license": "MIT" + }, + "node_modules/merge2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", + "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==", + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/mermaid": { + "version": "11.6.0", + "resolved": "https://registry.npmjs.org/mermaid/-/mermaid-11.6.0.tgz", + "integrity": "sha512-PE8hGUy1LDlWIHWBP05SFdqUHGmRcCcK4IzpOKPE35eOw+G9zZgcnMpyunJVUEOgb//KBORPjysKndw8bFLuRg==", + "license": "MIT", + "dependencies": { + "@braintree/sanitize-url": "^7.0.4", + "@iconify/utils": "^2.1.33", + "@mermaid-js/parser": "^0.4.0", + "@types/d3": "^7.4.3", + "cytoscape": "^3.29.3", + "cytoscape-cose-bilkent": "^4.1.0", + "cytoscape-fcose": "^2.2.0", + "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", + "khroma": "^2.1.0", + "lodash-es": "^4.17.21", + "marked": "^15.0.7", + "roughjs": "^4.6.6", + "stylis": "^4.3.6", + "ts-dedent": "^2.2.0", + "uuid": "^11.1.0" + } + }, + "node_modules/methods": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz", + "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/micromark": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/micromark/-/micromark-4.0.2.tgz", + "integrity": "sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "@types/debug": "^4.0.0", + "debug": "^4.0.0", + "decode-named-character-reference": "^1.0.0", + "devlop": "^1.0.0", + "micromark-core-commonmark": "^2.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-chunked": "^2.0.0", + "micromark-util-combine-extensions": "^2.0.0", + "micromark-util-decode-numeric-character-reference": "^2.0.0", + "micromark-util-encode": "^2.0.0", + "micromark-util-normalize-identifier": "^2.0.0", + "micromark-util-resolve-all": "^2.0.0", + "micromark-util-sanitize-uri": "^2.0.0", + "micromark-util-subtokenize": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-core-commonmark": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/micromark-core-commonmark/-/micromark-core-commonmark-2.0.3.tgz", + "integrity": "sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "decode-named-character-reference": "^1.0.0", + "devlop": "^1.0.0", + "micromark-factory-destination": "^2.0.0", + "micromark-factory-label": "^2.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-factory-title": "^2.0.0", + "micromark-factory-whitespace": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-chunked": "^2.0.0", + "micromark-util-classify-character": "^2.0.0", + "micromark-util-html-tag-name": "^2.0.0", + "micromark-util-normalize-identifier": "^2.0.0", + "micromark-util-resolve-all": "^2.0.0", + "micromark-util-subtokenize": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-gfm": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/micromark-extension-gfm/-/micromark-extension-gfm-3.0.0.tgz", + "integrity": "sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w==", + "license": "MIT", + "dependencies": { + "micromark-extension-gfm-autolink-literal": "^2.0.0", + "micromark-extension-gfm-footnote": "^2.0.0", + "micromark-extension-gfm-strikethrough": "^2.0.0", + "micromark-extension-gfm-table": "^2.0.0", + "micromark-extension-gfm-tagfilter": "^2.0.0", + "micromark-extension-gfm-task-list-item": "^2.0.0", + "micromark-util-combine-extensions": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-autolink-literal": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/micromark-extension-gfm-autolink-literal/-/micromark-extension-gfm-autolink-literal-2.1.0.tgz", + "integrity": "sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw==", + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-sanitize-uri": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-footnote": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/micromark-extension-gfm-footnote/-/micromark-extension-gfm-footnote-2.1.0.tgz", + "integrity": "sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw==", + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-core-commonmark": "^2.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-normalize-identifier": "^2.0.0", + "micromark-util-sanitize-uri": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-strikethrough": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/micromark-extension-gfm-strikethrough/-/micromark-extension-gfm-strikethrough-2.1.0.tgz", + "integrity": "sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw==", + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-util-chunked": "^2.0.0", + "micromark-util-classify-character": "^2.0.0", + "micromark-util-resolve-all": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-table": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/micromark-extension-gfm-table/-/micromark-extension-gfm-table-2.1.1.tgz", + "integrity": "sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg==", + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-tagfilter": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/micromark-extension-gfm-tagfilter/-/micromark-extension-gfm-tagfilter-2.0.0.tgz", + "integrity": "sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg==", + "license": "MIT", + "dependencies": { + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-task-list-item": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/micromark-extension-gfm-task-list-item/-/micromark-extension-gfm-task-list-item-2.1.0.tgz", + "integrity": "sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw==", + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-factory-destination": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-factory-destination/-/micromark-factory-destination-2.0.1.tgz", + "integrity": "sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-label": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-factory-label/-/micromark-factory-label-2.0.1.tgz", + "integrity": "sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-space": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz", + "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-title": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-factory-title/-/micromark-factory-title-2.0.1.tgz", + "integrity": "sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-whitespace": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-factory-whitespace/-/micromark-factory-whitespace-2.0.1.tgz", + "integrity": "sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-character": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz", + "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-chunked": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-chunked/-/micromark-util-chunked-2.0.1.tgz", + "integrity": "sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0" + } + }, + "node_modules/micromark-util-classify-character": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-classify-character/-/micromark-util-classify-character-2.0.1.tgz", + "integrity": "sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-combine-extensions": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-combine-extensions/-/micromark-util-combine-extensions-2.0.1.tgz", + "integrity": "sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-chunked": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-decode-numeric-character-reference": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-2.0.2.tgz", + "integrity": "sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0" + } + }, + "node_modules/micromark-util-decode-string": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-decode-string/-/micromark-util-decode-string-2.0.1.tgz", + "integrity": "sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "decode-named-character-reference": "^1.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-decode-numeric-character-reference": "^2.0.0", + "micromark-util-symbol": "^2.0.0" + } + }, + "node_modules/micromark-util-encode": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz", + "integrity": "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-html-tag-name": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-html-tag-name/-/micromark-util-html-tag-name-2.0.1.tgz", + "integrity": "sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-normalize-identifier": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-2.0.1.tgz", + "integrity": "sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0" + } + }, + "node_modules/micromark-util-resolve-all": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-resolve-all/-/micromark-util-resolve-all-2.0.1.tgz", + "integrity": "sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-sanitize-uri": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz", + "integrity": "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-encode": "^2.0.0", + "micromark-util-symbol": "^2.0.0" + } + }, + "node_modules/micromark-util-subtokenize": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/micromark-util-subtokenize/-/micromark-util-subtokenize-2.1.0.tgz", + "integrity": "sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-util-chunked": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-symbol": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz", + "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-types": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.2.tgz", + "integrity": "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromatch": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", + "license": "MIT", + "dependencies": { + "braces": "^3.0.3", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/mime": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==", + "license": "MIT", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/mime-db": { + "version": "1.52.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz", + "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.35", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz", + "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==", + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mimic-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/min-indent": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz", + "integrity": "sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "schema-utils": "^4.0.0", + "tapable": "^2.2.1" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.0.0" + } + }, + "node_modules/minimalistic-assert": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz", + "integrity": "sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==", + "license": "ISC" + }, + "node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/minimist": { + "version": "1.2.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz", + "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/minipass": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz", + "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==", + "license": "ISC", + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "node_modules/mkdirp": { + "version": "0.5.6", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz", + "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==", + "license": "MIT", + "dependencies": { + "minimist": "^1.2.6" + }, + "bin": { + "mkdirp": "bin/cmd.js" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "acorn": "^8.14.0", + "pathe": "^2.0.1", + "pkg-types": "^1.3.0", + "ufo": "^1.5.4" + } + }, + "node_modules/mlly/node_modules/confbox": { + "version": "0.1.8", + "resolved": "https://registry.npmjs.org/confbox/-/confbox-0.1.8.tgz", + "integrity": "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==", + "license": "MIT" + }, + "node_modules/mlly/node_modules/pkg-types": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-1.3.1.tgz", + "integrity": "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==", + "license": "MIT", + "dependencies": { + "confbox": "^0.1.8", + "mlly": "^1.7.4", + "pathe": "^2.0.1" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/multicast-dns": { + "version": "7.2.5", + "resolved": "https://registry.npmjs.org/multicast-dns/-/multicast-dns-7.2.5.tgz", + "integrity": "sha512-2eznPJP8z2BFLX50tf0LuODrpINqP1RVIm/CObbTcBRITQgmC/TjcREF1NeTBzIcR5XO/ukWo+YHOjBbFwIupg==", + "license": "MIT", + "dependencies": { + "dns-packet": "^5.2.2", + "thunky": "^1.0.2" + }, + "bin": { + "multicast-dns": "cli.js" + } + }, + "node_modules/mz": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz", + "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==", + "license": "MIT", + "dependencies": { + "any-promise": "^1.0.0", + "object-assign": "^4.0.1", + "thenify-all": "^1.0.0" + } + }, + "node_modules/nanoid": { + "version": "3.3.11", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz", + "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/natural-compare": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz", + "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==", + "license": "MIT" + }, + "node_modules/natural-compare-lite": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/natural-compare-lite/-/natural-compare-lite-1.4.0.tgz", + "integrity": "sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==", + "license": "MIT" + }, + "node_modules/negotiator": { + "version": "0.6.4", + "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.4.tgz", + "integrity": "sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/neo-async": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/neo-async/-/neo-async-2.6.2.tgz", + "integrity": "sha512-Yd3UES5mWCSqR+qNT93S3UoYUkqAZ9lLg8a7g9rimsWmYGK8cVToA4/sF3RrshdyV3sAGMXVUmpMYOw+dLpOuw==", + "license": "MIT" + }, + "node_modules/no-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/no-case/-/no-case-3.0.4.tgz", + "integrity": "sha512-fgAN3jGAh+RoxUGZHTSOLJIqUc2wmoBwGR4tbpNAKmmovFoWq0OdRkb0VkldReO2a2iBT/OEulG9XSUc10r3zg==", + "license": "MIT", + "dependencies": { + "lower-case": "^2.0.2", + "tslib": "^2.0.3" + } + }, + "node_modules/node-forge": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/node-forge/-/node-forge-1.3.1.tgz", + "integrity": "sha512-dPEtOeMvF9VMcYV/1Wb8CPoVAXtp6MKMlcbAt4ddqmGqUJ6fQZFXkNZNkNlfevtNkGtaSoXf/vNNNSvgrdXwtA==", + "license": "(BSD-3-Clause OR GPL-2.0)", + "engines": { + "node": ">= 6.13.0" + } + }, + "node_modules/node-int64": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/node-int64/-/node-int64-0.4.0.tgz", + "integrity": "sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==", + "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==", + "license": "MIT" + }, + "node_modules/normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/normalize-range": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/normalize-range/-/normalize-range-0.1.2.tgz", + "integrity": "sha512-bdok/XvKII3nUpklnV6P2hxtMNrCboOjAcyBuQnWEhO665FwrSNRxU+AqpsyvO6LgGYPspN+lu5CLtw4jPRKNA==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/normalize-url": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-6.1.0.tgz", + "integrity": "sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm-run-path": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-4.0.1.tgz", + "integrity": "sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==", + "license": "MIT", + "dependencies": { + "path-key": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/nth-check": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz", + "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==", + "license": "BSD-2-Clause", + "dependencies": { + "boolbase": "^1.0.0" + }, + "funding": { + "url": "https://github.com/fb55/nth-check?sponsor=1" + } + }, + "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==", + "license": "MIT" + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-hash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz", + "integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==", + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/object-inspect": { + "version": "1.13.4", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz", + "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object-is": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/object-is/-/object-is-1.1.6.tgz", + "integrity": "sha512-F8cZ+KfGlSGi09lJT7/Nd6KJZ9ygtvYC0/UYYLI9nmQKLMnydpB9yvbv9K1uSkEu7FU9vYPmVwLg328tX+ot3Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object-keys": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz", + "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/object.assign": { + "version": "4.1.7", + "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.7.tgz", + "integrity": "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.0.0", + "has-symbols": "^1.1.0", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object.entries": { + "version": "1.1.9", + "resolved": "https://registry.npmjs.org/object.entries/-/object.entries-1.1.9.tgz", + "integrity": "sha512-8u/hfXFRBD1O0hPUjioLhoWFHRmt6tKA4/vZPyckBr18l1KE9uHrFaFaUi8MDRTpi4uak2goyPTSNJLXX2k2Hw==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.4", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/object.fromentries": { + "version": "2.0.8", + "resolved": "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.8.tgz", + "integrity": "sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.2", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object.getownpropertydescriptors": { + "version": "2.1.8", + "resolved": "https://registry.npmjs.org/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.8.tgz", + "integrity": "sha512-qkHIGe4q0lSYMv0XI4SsBTJz3WaURhLvd0lKSgtVuOsJ2krg4SgMw3PIRQFMp07yi++UR3se2mkcLqsBNpBb/A==", + "license": "MIT", + "dependencies": { + "array.prototype.reduce": "^1.0.6", + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.2", + "es-object-atoms": "^1.0.0", + "gopd": "^1.0.1", + "safe-array-concat": "^1.1.2" + }, + "engines": { + "node": ">= 0.8" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object.groupby": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/object.groupby/-/object.groupby-1.0.3.tgz", + "integrity": "sha512-+Lhy3TQTuzXI5hevh8sBGqbmurHbbIjAi0Z4S63nthVLmLxfbj4T54a4CfZrXIrt9iP4mVAPYMo/v99taj3wjQ==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/object.values": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.2.1.tgz", + "integrity": "sha512-gXah6aZrcUxjWg2zR2MwouP2eHlCBzdV4pygudehaKXSGW4v2AsRQUK+lwwXhii6KFZcunEnmSUoYp5CXibxtA==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/obuf": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/obuf/-/obuf-1.1.2.tgz", + "integrity": "sha512-PX1wu0AmAdPqOL1mWhqmlOd8kOIZQwGZw6rh7uby9fTc5lhaOWFLX3I6R1hrF9k3zUY40e6igsLGkDXK92LJNg==", + "license": "MIT" + }, + "node_modules/on-finished": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz", + "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==", + "license": "MIT", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "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==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/onetime": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "license": "MIT", + "dependencies": { + "mimic-fn": "^2.1.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/open": { + "version": "8.4.2", + "resolved": "https://registry.npmjs.org/open/-/open-8.4.2.tgz", + "integrity": "sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==", + "license": "MIT", + "dependencies": { + "define-lazy-prop": "^2.0.0", + "is-docker": "^2.1.1", + "is-wsl": "^2.2.0" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/optionator": { + "version": "0.9.4", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz", + "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", + "license": "MIT", + "dependencies": { + "deep-is": "^0.1.3", + "fast-levenshtein": "^2.0.6", + "levn": "^0.4.1", + "prelude-ls": "^1.2.1", + "type-check": "^0.4.0", + "word-wrap": "^1.2.5" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/own-keys": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/own-keys/-/own-keys-1.0.1.tgz", + "integrity": "sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg==", + "license": "MIT", + "dependencies": { + "get-intrinsic": "^1.2.6", + "object-keys": "^1.1.1", + "safe-push-apply": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/p-limit": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz", + "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==", + "license": "MIT", + "dependencies": { + "p-try": "^2.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-4.1.0.tgz", + "integrity": "sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A==", + "license": "MIT", + "dependencies": { + "p-limit": "^2.2.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/p-retry": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/p-retry/-/p-retry-4.6.2.tgz", + "integrity": "sha512-312Id396EbJdvRONlngUx0NydfrIQ5lsYu0znKVUzVvArzEIt08V1qhtyESbGVd1FGX7UKtiFp5uwKZdM8wIuQ==", + "license": "MIT", + "dependencies": { + "@types/retry": "0.12.0", + "retry": "^0.13.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/p-try": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-2.2.0.tgz", + "integrity": "sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/package-json-from-dist": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz", + "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==", + "license": "BlueOak-1.0.0" + }, + "node_modules/package-manager-detector": { + "version": "0.2.11", + "resolved": "https://registry.npmjs.org/package-manager-detector/-/package-manager-detector-0.2.11.tgz", + "integrity": "sha512-BEnLolu+yuz22S56CU1SUKq3XC3PkwD5wv4ikR4MfGvnRVcmzXR9DwSlW2fEamyTPyXHomBJRzgapeuBvRNzJQ==", + "license": "MIT", + "dependencies": { + "quansync": "^0.2.7" + } + }, + "node_modules/param-case": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/param-case/-/param-case-3.0.4.tgz", + "integrity": "sha512-RXlj7zCYokReqWpOPH9oYivUzLYZ5vAPIfEmCTNViosC78F8F0H9y7T7gG2M39ymgutxF5gcFEsyZQSph9Bp3A==", + "license": "MIT", + "dependencies": { + "dot-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "license": "MIT", + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/parse-entities": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-4.0.2.tgz", + "integrity": "sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw==", + "license": "MIT", + "dependencies": { + "@types/unist": "^2.0.0", + "character-entities-legacy": "^3.0.0", + "character-reference-invalid": "^2.0.0", + "decode-named-character-reference": "^1.0.0", + "is-alphanumerical": "^2.0.0", + "is-decimal": "^2.0.0", + "is-hexadecimal": "^2.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/parse-entities/node_modules/@types/unist": { + "version": "2.0.11", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz", + "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==", + "license": "MIT" + }, + "node_modules/parse-json": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz", + "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.0.0", + "error-ex": "^1.3.1", + "json-parse-even-better-errors": "^2.3.0", + "lines-and-columns": "^1.1.6" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/parse5": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-6.0.1.tgz", + "integrity": "sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==", + "license": "MIT" + }, + "node_modules/parseurl": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz", + "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/pascal-case": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/pascal-case/-/pascal-case-3.1.2.tgz", + "integrity": "sha512-uWlGT3YSnK9x3BQJaOdcZwrnV6hPpd8jFH1/ucpiLRPh/2zCVJKS19E4GvYHvaCcACn3foXZ0cLB9Wrx1KGe5g==", + "license": "MIT", + "dependencies": { + "no-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/path-data-parser": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/path-data-parser/-/path-data-parser-0.1.0.tgz", + "integrity": "sha512-NOnmBpt5Y2RWbuv0LMzsayp3lVylAHLPUTut412ZA3l+C4uw4ZVkQbjShYCQ8TCpUMdPapr4YjUqLYD6v68j+w==", + "license": "MIT" + }, + "node_modules/path-exists": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", + "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-key": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", + "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "license": "MIT" + }, + "node_modules/path-scurry": { + "version": "1.11.1", + "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz", + "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==", + "license": "BlueOak-1.0.0", + "dependencies": { + "lru-cache": "^10.2.0", + "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0" + }, + "engines": { + "node": ">=16 || 14 >=14.18" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/path-scurry/node_modules/lru-cache": { + "version": "10.4.3", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz", + "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==", + "license": "ISC" + }, + "node_modules/path-to-regexp": { + "version": "0.1.12", + "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz", + "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==", + "license": "MIT" + }, + "node_modules/path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/pathe": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz", + "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==", + "license": "MIT" + }, + "node_modules/performance-now": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", + "integrity": "sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow==", + "license": "MIT" + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/pirates": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz", + "integrity": "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==", + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/pkg-dir": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/pkg-dir/-/pkg-dir-4.2.0.tgz", + "integrity": "sha512-HRDzbaKjC+AOWVXxAU/x54COGeIv9eb+6CkDSQoNTt4XyWoIJvuPsXizxu/Fr23EiekbtZwmh1IcIG/l/a10GQ==", + "license": "MIT", + "dependencies": { + "find-up": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "confbox": "^0.2.1", + "exsolve": "^1.0.1", + "pathe": "^2.0.3" + } + }, + "node_modules/pkg-up": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/pkg-up/-/pkg-up-3.1.0.tgz", + "integrity": "sha512-nDywThFk1i4BQK4twPQ6TA4RT8bDY96yeuCVBWL3ePARCiEKDRSrNGbFIgUJpLp+XeIR65v8ra7WuJOFUBtkMA==", + "license": "MIT", + "dependencies": { + "find-up": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/pkg-up/node_modules/find-up": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz", + "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==", + "license": "MIT", + "dependencies": { + "locate-path": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/pkg-up/node_modules/locate-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz", + "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==", + "license": "MIT", + "dependencies": { + "p-locate": "^3.0.0", + "path-exists": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/pkg-up/node_modules/p-locate": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz", + "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==", + "license": "MIT", + "dependencies": { + "p-limit": "^2.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/pkg-up/node_modules/path-exists": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz", + "integrity": "sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/points-on-curve": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/points-on-curve/-/points-on-curve-0.2.0.tgz", + "integrity": "sha512-0mYKnYYe9ZcqMCWhUjItv/oHjvgEsfKvnUTg8sAtnHr3GVy7rGkXCb6d5cSyqrWqL4k81b9CPg3urd+T7aop3A==", + "license": "MIT" + }, + "node_modules/points-on-path": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/points-on-path/-/points-on-path-0.2.1.tgz", + "integrity": "sha512-25ClnWWuw7JbWZcgqY/gJ4FQWadKxGWk+3kR/7kD0tCaDtPPMj7oHu2ToLaVhfpnHrZzYby2w6tUA0eOIuUg8g==", + "license": "MIT", + "dependencies": { + "path-data-parser": "0.1.0", + "points-on-curve": "0.2.0" + } + }, + "node_modules/possible-typed-array-names": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz", + "integrity": "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/postcss": { + "version": "8.5.3", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.3.tgz", + "integrity": "sha512-dle9A3yYxlBSrt8Fu+IpjGT8SY8hN0mlaA6GY8t0P5PjIOZemULz/E2Bnm/2dcUOena75OTNkHI76uZBNUUq3A==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.8", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/postcss-attribute-case-insensitive": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/postcss-attribute-case-insensitive/-/postcss-attribute-case-insensitive-5.0.2.tgz", + "integrity": "sha512-XIidXV8fDr0kKt28vqki84fRK8VW8eTuIa4PChv2MqKuT6C9UjmSKzen6KaWhWEoYvwxFCa7n/tC1SZ3tyq4SQ==", + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.0.10" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-browser-comments": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/postcss-browser-comments/-/postcss-browser-comments-4.0.0.tgz", + "integrity": "sha512-X9X9/WN3KIvY9+hNERUqX9gncsgBA25XaeR+jshHz2j8+sYyHktHw1JdKuMjeLpGktXidqDhA7b/qm1mrBDmgg==", + "license": "CC0-1.0", + "engines": { + "node": ">=8" + }, + "peerDependencies": { + "browserslist": ">=4", + "postcss": ">=8" + } + }, + "node_modules/postcss-calc": { + "version": "8.2.4", + "resolved": "https://registry.npmjs.org/postcss-calc/-/postcss-calc-8.2.4.tgz", + "integrity": "sha512-SmWMSJmB8MRnnULldx0lQIyhSNvuDl9HfrZkaqqE/WHAhToYsAvDq+yAsA/kIyINDszOp3Rh0GFoNuH5Ypsm3Q==", + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.0.9", + "postcss-value-parser": "^4.2.0" + }, + "peerDependencies": { + "postcss": "^8.2.2" + } + }, + "node_modules/postcss-clamp": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/postcss-clamp/-/postcss-clamp-4.1.0.tgz", + "integrity": "sha512-ry4b1Llo/9zz+PKC+030KUnPITTJAHeOwjfAyyB60eT0AorGLdzp52s31OsPRHRf8NchkgFoG2y6fCfn1IV1Ow==", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": ">=7.6.0" + }, + "peerDependencies": { + "postcss": "^8.4.6" + } + }, + "node_modules/postcss-color-functional-notation": { + "version": "4.2.4", + "resolved": "https://registry.npmjs.org/postcss-color-functional-notation/-/postcss-color-functional-notation-4.2.4.tgz", + "integrity": "sha512-2yrTAUZUab9s6CpxkxC4rVgFEVaR6/2Pipvi6qcgvnYiVqZcbDHEoBDhrXzyb7Efh2CCfHQNtcqWcIruDTIUeg==", + "license": "CC0-1.0", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-color-hex-alpha": { + "version": "8.0.4", + "resolved": "https://registry.npmjs.org/postcss-color-hex-alpha/-/postcss-color-hex-alpha-8.0.4.tgz", + "integrity": "sha512-nLo2DCRC9eE4w2JmuKgVA3fGL3d01kGq752pVALF68qpGLmx2Qrk91QTKkdUqqp45T1K1XV8IhQpcu1hoAQflQ==", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/postcss-color-rebeccapurple": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/postcss-color-rebeccapurple/-/postcss-color-rebeccapurple-7.1.1.tgz", + "integrity": "sha512-pGxkuVEInwLHgkNxUc4sdg4g3py7zUeCQ9sMfwyHAT+Ezk8a4OaaVZ8lIY5+oNqA/BXXgLyXv0+5wHP68R79hg==", + "license": "CC0-1.0", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-colormin": { + "version": "5.3.1", + "resolved": "https://registry.npmjs.org/postcss-colormin/-/postcss-colormin-5.3.1.tgz", + "integrity": "sha512-UsWQG0AqTFQmpBegeLLc1+c3jIqBNB0zlDGRWR+dQ3pRKJL1oeMzyqmH3o2PIfn9MBdNrVPWhDbT769LxCTLJQ==", + "license": "MIT", + "dependencies": { + "browserslist": "^4.21.4", + "caniuse-api": "^3.0.0", + "colord": "^2.9.1", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-convert-values": { + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/postcss-convert-values/-/postcss-convert-values-5.1.3.tgz", + "integrity": "sha512-82pC1xkJZtcJEfiLw6UXnXVXScgtBrjlO5CBmuDQc+dlb88ZYheFsjTn40+zBVi3DkfF7iezO0nJUPLcJK3pvA==", + "license": "MIT", + "dependencies": { + "browserslist": "^4.21.4", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-custom-media": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/postcss-custom-media/-/postcss-custom-media-8.0.2.tgz", + "integrity": "sha512-7yi25vDAoHAkbhAzX9dHx2yc6ntS4jQvejrNcC+csQJAXjj15e7VcWfMgLqBNAbOvqi5uIa9huOVwdHbf+sKqg==", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.3" + } + }, + "node_modules/postcss-custom-properties": { + "version": "12.1.11", + "resolved": "https://registry.npmjs.org/postcss-custom-properties/-/postcss-custom-properties-12.1.11.tgz", + "integrity": "sha512-0IDJYhgU8xDv1KY6+VgUwuQkVtmYzRwu+dMjnmdMafXYv86SWqfxkc7qdDvWS38vsjaEtv8e0vGOUQrAiMBLpQ==", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-custom-selectors": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/postcss-custom-selectors/-/postcss-custom-selectors-6.0.3.tgz", + "integrity": "sha512-fgVkmyiWDwmD3JbpCmB45SvvlCD6z9CG6Ie6Iere22W5aHea6oWa7EM2bpnv2Fj3I94L3VbtvX9KqwSi5aFzSg==", + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.0.4" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.3" + } + }, + "node_modules/postcss-dir-pseudo-class": { + "version": "6.0.5", + "resolved": "https://registry.npmjs.org/postcss-dir-pseudo-class/-/postcss-dir-pseudo-class-6.0.5.tgz", + "integrity": "sha512-eqn4m70P031PF7ZQIvSgy9RSJ5uI2171O/OO/zcRNYpJbvaeKFUlar1aJ7rmgiQtbm0FSPsRewjpdS0Oew7MPA==", + "license": "CC0-1.0", + "dependencies": { + "postcss-selector-parser": "^6.0.10" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-discard-comments": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/postcss-discard-comments/-/postcss-discard-comments-5.1.2.tgz", + "integrity": "sha512-+L8208OVbHVF2UQf1iDmRcbdjJkuBF6IS29yBDSiWUIzpYaAhtNl6JYnYm12FnkeCwQqF5LeklOu6rAqgfBZqQ==", + "license": "MIT", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-discard-duplicates": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-discard-duplicates/-/postcss-discard-duplicates-5.1.0.tgz", + "integrity": "sha512-zmX3IoSI2aoenxHV6C7plngHWWhUOV3sP1T8y2ifzxzbtnuhk1EdPwm0S1bIUNaJ2eNbWeGLEwzw8huPD67aQw==", + "license": "MIT", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-discard-empty": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-discard-empty/-/postcss-discard-empty-5.1.1.tgz", + "integrity": "sha512-zPz4WljiSuLWsI0ir4Mcnr4qQQ5e1Ukc3i7UfE2XcrwKK2LIPIqE5jxMRxO6GbI3cv//ztXDsXwEWT3BHOGh3A==", + "license": "MIT", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-discard-overridden": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-discard-overridden/-/postcss-discard-overridden-5.1.0.tgz", + "integrity": "sha512-21nOL7RqWR1kasIVdKs8HNqQJhFxLsyRfAnUDm4Fe4t4mCWL9OJiHvlHPjcd8zc5Myu89b/7wZDnOSjFgeWRtw==", + "license": "MIT", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-double-position-gradients": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/postcss-double-position-gradients/-/postcss-double-position-gradients-3.1.2.tgz", + "integrity": "sha512-GX+FuE/uBR6eskOK+4vkXgT6pDkexLokPaz/AbJna9s5Kzp/yl488pKPjhy0obB475ovfT1Wv8ho7U/cHNaRgQ==", + "license": "CC0-1.0", + "dependencies": { + "@csstools/postcss-progressive-custom-properties": "^1.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-env-function": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/postcss-env-function/-/postcss-env-function-4.0.6.tgz", + "integrity": "sha512-kpA6FsLra+NqcFnL81TnsU+Z7orGtDTxcOhl6pwXeEq1yFPpRMkCDpHhrz8CFQDr/Wfm0jLiNQ1OsGGPjlqPwA==", + "license": "CC0-1.0", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/postcss-flexbugs-fixes": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/postcss-flexbugs-fixes/-/postcss-flexbugs-fixes-5.0.2.tgz", + "integrity": "sha512-18f9voByak7bTktR2QgDveglpn9DTbBWPUzSOe9g0N4WR/2eSt6Vrcbf0hmspvMI6YWGywz6B9f7jzpFNJJgnQ==", + "license": "MIT", + "peerDependencies": { + "postcss": "^8.1.4" + } + }, + "node_modules/postcss-focus-visible": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/postcss-focus-visible/-/postcss-focus-visible-6.0.4.tgz", + "integrity": "sha512-QcKuUU/dgNsstIK6HELFRT5Y3lbrMLEOwG+A4s5cA+fx3A3y/JTq3X9LaOj3OC3ALH0XqyrgQIgey/MIZ8Wczw==", + "license": "CC0-1.0", + "dependencies": { + "postcss-selector-parser": "^6.0.9" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/postcss-focus-within": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/postcss-focus-within/-/postcss-focus-within-5.0.4.tgz", + "integrity": "sha512-vvjDN++C0mu8jz4af5d52CB184ogg/sSxAFS+oUJQq2SuCe7T5U2iIsVJtsCp2d6R4j0jr5+q3rPkBVZkXD9fQ==", + "license": "CC0-1.0", + "dependencies": { + "postcss-selector-parser": "^6.0.9" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/postcss-font-variant": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/postcss-font-variant/-/postcss-font-variant-5.0.0.tgz", + "integrity": "sha512-1fmkBaCALD72CK2a9i468mA/+tr9/1cBxRRMXOUaZqO43oWPR5imcyPjXwuv7PXbCid4ndlP5zWhidQVVa3hmA==", + "license": "MIT", + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-gap-properties": { + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/postcss-gap-properties/-/postcss-gap-properties-3.0.5.tgz", + "integrity": "sha512-IuE6gKSdoUNcvkGIqdtjtcMtZIFyXZhmFd5RUlg97iVEvp1BZKV5ngsAjCjrVy+14uhGBQl9tzmi1Qwq4kqVOg==", + "license": "CC0-1.0", + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-image-set-function": { + "version": "4.0.7", + "resolved": "https://registry.npmjs.org/postcss-image-set-function/-/postcss-image-set-function-4.0.7.tgz", + "integrity": "sha512-9T2r9rsvYzm5ndsBE8WgtrMlIT7VbtTfE7b3BQnudUqnBcBo7L758oc+o+pdj/dUV0l5wjwSdjeOH2DZtfv8qw==", + "license": "CC0-1.0", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-import": { + "version": "15.1.0", + "resolved": "https://registry.npmjs.org/postcss-import/-/postcss-import-15.1.0.tgz", + "integrity": "sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.0.0", + "read-cache": "^1.0.0", + "resolve": "^1.1.7" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "postcss": "^8.0.0" + } + }, + "node_modules/postcss-initial": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/postcss-initial/-/postcss-initial-4.0.1.tgz", + "integrity": "sha512-0ueD7rPqX8Pn1xJIjay0AZeIuDoF+V+VvMt/uOnn+4ezUKhZM/NokDeP6DwMNyIoYByuN/94IQnt5FEkaN59xQ==", + "license": "MIT", + "peerDependencies": { + "postcss": "^8.0.0" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "camelcase-css": "^2.0.1" + }, + "engines": { + "node": "^12 || ^14 || >= 16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + "peerDependencies": { + "postcss": "^8.4.21" + } + }, + "node_modules/postcss-lab-function": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/postcss-lab-function/-/postcss-lab-function-4.2.1.tgz", + "integrity": "sha512-xuXll4isR03CrQsmxyz92LJB2xX9n+pZJ5jE9JgcnmsCammLyKdlzrBin+25dy6wIjfhJpKBAN80gsTlCgRk2w==", + "license": "CC0-1.0", + "dependencies": { + "@csstools/postcss-progressive-custom-properties": "^1.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "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", + "integrity": "sha512-WbbYpmAaKcux/P66bZ40bpWsBucjx/TTgVVzRZ9yUO8yQfVBlameJ0ZGVaPfH64hNSBh63a+ICP5nqOpBA0w+Q==", + "license": "MIT", + "dependencies": { + "cosmiconfig": "^7.0.0", + "klona": "^2.0.5", + "semver": "^7.3.5" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "postcss": "^7.0.0 || ^8.0.1", + "webpack": "^5.0.0" + } + }, + "node_modules/postcss-logical": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/postcss-logical/-/postcss-logical-5.0.4.tgz", + "integrity": "sha512-RHXxplCeLh9VjinvMrZONq7im4wjWGlRJAqmAVLXyZaXwfDWP73/oq4NdIp+OZwhQUMj0zjqDfM5Fj7qby+B4g==", + "license": "CC0-1.0", + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.4" + } + }, + "node_modules/postcss-media-minmax": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/postcss-media-minmax/-/postcss-media-minmax-5.0.0.tgz", + "integrity": "sha512-yDUvFf9QdFZTuCUg0g0uNSHVlJ5X1lSzDZjPSFaiCWvjgsvu8vEVxtahPrLMinIDEEGnx6cBe6iqdx5YWz08wQ==", + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-merge-longhand": { + "version": "5.1.7", + "resolved": "https://registry.npmjs.org/postcss-merge-longhand/-/postcss-merge-longhand-5.1.7.tgz", + "integrity": "sha512-YCI9gZB+PLNskrK0BB3/2OzPnGhPkBEwmwhfYk1ilBHYVAZB7/tkTHFBAnCrvBBOmeYyMYw3DMjT55SyxMBzjQ==", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0", + "stylehacks": "^5.1.1" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-merge-rules": { + "version": "5.1.4", + "resolved": "https://registry.npmjs.org/postcss-merge-rules/-/postcss-merge-rules-5.1.4.tgz", + "integrity": "sha512-0R2IuYpgU93y9lhVbO/OylTtKMVcHb67zjWIfCiKR9rWL3GUk1677LAqD/BcHizukdZEjT8Ru3oHRoAYoJy44g==", + "license": "MIT", + "dependencies": { + "browserslist": "^4.21.4", + "caniuse-api": "^3.0.0", + "cssnano-utils": "^3.1.0", + "postcss-selector-parser": "^6.0.5" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-minify-font-values": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-minify-font-values/-/postcss-minify-font-values-5.1.0.tgz", + "integrity": "sha512-el3mYTgx13ZAPPirSVsHqFzl+BBBDrXvbySvPGFnQcTI4iNslrPaFq4muTkLZmKlGk4gyFAYUBMH30+HurREyA==", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-minify-gradients": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-minify-gradients/-/postcss-minify-gradients-5.1.1.tgz", + "integrity": "sha512-VGvXMTpCEo4qHTNSa9A0a3D+dxGFZCYwR6Jokk+/3oB6flu2/PnPXAh2x7x52EkY5xlIHLm+Le8tJxe/7TNhzw==", + "license": "MIT", + "dependencies": { + "colord": "^2.9.1", + "cssnano-utils": "^3.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-minify-params": { + "version": "5.1.4", + "resolved": "https://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-5.1.4.tgz", + "integrity": "sha512-+mePA3MgdmVmv6g+30rn57USjOGSAyuxUmkfiWpzalZ8aiBkdPYjXWtHuwJGm1v5Ojy0Z0LaSYhHaLJQB0P8Jw==", + "license": "MIT", + "dependencies": { + "browserslist": "^4.21.4", + "cssnano-utils": "^3.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-minify-selectors": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/postcss-minify-selectors/-/postcss-minify-selectors-5.2.1.tgz", + "integrity": "sha512-nPJu7OjZJTsVUmPdm2TcaiohIwxP+v8ha9NehQ2ye9szv4orirRU3SDdtUmKH+10nzn0bAyOXZ0UEr7OpvLehg==", + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.0.5" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-modules-extract-imports": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/postcss-modules-extract-imports/-/postcss-modules-extract-imports-3.1.0.tgz", + "integrity": "sha512-k3kNe0aNFQDAZGbin48pL2VNidTF0w4/eASDsxlyspobzU3wZQLOGj7L9gfRe0Jo9/4uud09DsjFNH7winGv8Q==", + "license": "ISC", + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-modules-local-by-default": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.2.0.tgz", + "integrity": "sha512-5kcJm/zk+GJDSfw+V/42fJ5fhjL5YbFDl8nVdXkJPLLW+Vf9mTD5Xe0wqIaDnLuL2U6cDNpTr+UQ+v2HWIBhzw==", + "license": "MIT", + "dependencies": { + "icss-utils": "^5.0.0", + "postcss-selector-parser": "^7.0.0", + "postcss-value-parser": "^4.1.0" + }, + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-modules-local-by-default/node_modules/postcss-selector-parser": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz", + "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==", + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss-modules-scope": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/postcss-modules-scope/-/postcss-modules-scope-3.2.1.tgz", + "integrity": "sha512-m9jZstCVaqGjTAuny8MdgE88scJnCiQSlSrOWcTQgM2t32UBe+MUmFSO5t7VMSfAf/FJKImAxBav8ooCHJXCJA==", + "license": "ISC", + "dependencies": { + "postcss-selector-parser": "^7.0.0" + }, + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-modules-scope/node_modules/postcss-selector-parser": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.0.tgz", + "integrity": "sha512-8sLjZwK0R+JlxlYcTuVnyT2v+htpdrjDOKuMcOVdYjt52Lh8hWRYpxBPoKx/Zg+bcjc3wx6fmQevMmUztS/ccA==", + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss-modules-values": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/postcss-modules-values/-/postcss-modules-values-4.0.0.tgz", + "integrity": "sha512-RDxHkAiEGI78gS2ofyvCsu7iycRv7oqw5xMWn9iMoR0N/7mf9D50ecQqUo5BZ9Zh2vH4bCUR/ktCqbB9m8vJjQ==", + "license": "ISC", + "dependencies": { + "icss-utils": "^5.0.0" + }, + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-nested": { + "version": "6.2.0", + "resolved": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.2.0.tgz", + "integrity": "sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.1.1" + }, + "engines": { + "node": ">=12.0" + }, + "peerDependencies": { + "postcss": "^8.2.14" + } + }, + "node_modules/postcss-nesting": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/postcss-nesting/-/postcss-nesting-10.2.0.tgz", + "integrity": "sha512-EwMkYchxiDiKUhlJGzWsD9b2zvq/r2SSubcRrgP+jujMXFzqvANLt16lJANC+5uZ6hjI7lpRmI6O8JIl+8l1KA==", + "license": "CC0-1.0", + "dependencies": { + "@csstools/selector-specificity": "^2.0.0", + "postcss-selector-parser": "^6.0.10" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-normalize": { + "version": "10.0.1", + "resolved": "https://registry.npmjs.org/postcss-normalize/-/postcss-normalize-10.0.1.tgz", + "integrity": "sha512-+5w18/rDev5mqERcG3W5GZNMJa1eoYYNGo8gB7tEwaos0ajk3ZXAI4mHGcNT47NE+ZnZD1pEpUOFLvltIwmeJA==", + "license": "CC0-1.0", + "dependencies": { + "@csstools/normalize.css": "*", + "postcss-browser-comments": "^4", + "sanitize.css": "*" + }, + "engines": { + "node": ">= 12" + }, + "peerDependencies": { + "browserslist": ">= 4", + "postcss": ">= 8" + } + }, + "node_modules/postcss-normalize-charset": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-charset/-/postcss-normalize-charset-5.1.0.tgz", + "integrity": "sha512-mSgUJ+pd/ldRGVx26p2wz9dNZ7ji6Pn8VWBajMXFf8jk7vUoSrZ2lt/wZR7DtlZYKesmZI680qjr2CeFF2fbUg==", + "license": "MIT", + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-display-values": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-display-values/-/postcss-normalize-display-values-5.1.0.tgz", + "integrity": "sha512-WP4KIM4o2dazQXWmFaqMmcvsKmhdINFblgSeRgn8BJ6vxaMyaJkwAzpPpuvSIoG/rmX3M+IrRZEz2H0glrQNEA==", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-positions": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-normalize-positions/-/postcss-normalize-positions-5.1.1.tgz", + "integrity": "sha512-6UpCb0G4eofTCQLFVuI3EVNZzBNPiIKcA1AKVka+31fTVySphr3VUgAIULBhxZkKgwLImhzMR2Bw1ORK+37INg==", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-repeat-style": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-normalize-repeat-style/-/postcss-normalize-repeat-style-5.1.1.tgz", + "integrity": "sha512-mFpLspGWkQtBcWIRFLmewo8aC3ImN2i/J3v8YCFUwDnPu3Xz4rLohDO26lGjwNsQxB3YF0KKRwspGzE2JEuS0g==", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-string": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-string/-/postcss-normalize-string-5.1.0.tgz", + "integrity": "sha512-oYiIJOf4T9T1N4i+abeIc7Vgm/xPCGih4bZz5Nm0/ARVJ7K6xrDlLwvwqOydvyL3RHNf8qZk6vo3aatiw/go3w==", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-timing-functions": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-timing-functions/-/postcss-normalize-timing-functions-5.1.0.tgz", + "integrity": "sha512-DOEkzJ4SAXv5xkHl0Wa9cZLF3WCBhF3o1SKVxKQAa+0pYKlueTpCgvkFAHfk+Y64ezX9+nITGrDZeVGgITJXjg==", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-unicode": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-normalize-unicode/-/postcss-normalize-unicode-5.1.1.tgz", + "integrity": "sha512-qnCL5jzkNUmKVhZoENp1mJiGNPcsJCs1aaRmURmeJGES23Z/ajaln+EPTD+rBeNkSryI+2WTdW+lwcVdOikrpA==", + "license": "MIT", + "dependencies": { + "browserslist": "^4.21.4", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-url": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-normalize-url/-/postcss-normalize-url-5.1.0.tgz", + "integrity": "sha512-5upGeDO+PVthOxSmds43ZeMeZfKH+/DKgGRD7TElkkyS46JXAUhMzIKiCa7BabPeIy3AQcTkXwVVN7DbqsiCew==", + "license": "MIT", + "dependencies": { + "normalize-url": "^6.0.1", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-normalize-whitespace": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-normalize-whitespace/-/postcss-normalize-whitespace-5.1.1.tgz", + "integrity": "sha512-83ZJ4t3NUDETIHTa3uEg6asWjSBYL5EdkVB0sDncx9ERzOKBVJIUeDO9RyA9Zwtig8El1d79HBp0JEi8wvGQnA==", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-opacity-percentage": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/postcss-opacity-percentage/-/postcss-opacity-percentage-1.1.3.tgz", + "integrity": "sha512-An6Ba4pHBiDtyVpSLymUUERMo2cU7s+Obz6BTrS+gxkbnSBNKSuD0AVUc+CpBMrpVPKKfoVz0WQCX+Tnst0i4A==", + "funding": [ + { + "type": "kofi", + "url": "https://ko-fi.com/mrcgrtz" + }, + { + "type": "liberapay", + "url": "https://liberapay.com/mrcgrtz" + } + ], + "license": "MIT", + "engines": { + "node": "^12 || ^14 || >=16" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-ordered-values": { + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/postcss-ordered-values/-/postcss-ordered-values-5.1.3.tgz", + "integrity": "sha512-9UO79VUhPwEkzbb3RNpqqghc6lcYej1aveQteWY+4POIwlqkYE21HKWaLDF6lWNuqCobEAyTovVhtI32Rbv2RQ==", + "license": "MIT", + "dependencies": { + "cssnano-utils": "^3.1.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-overflow-shorthand": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/postcss-overflow-shorthand/-/postcss-overflow-shorthand-3.0.4.tgz", + "integrity": "sha512-otYl/ylHK8Y9bcBnPLo3foYFLL6a6Ak+3EQBPOTR7luMYCOsiVTUk1iLvNf6tVPNGXcoL9Hoz37kpfriRIFb4A==", + "license": "CC0-1.0", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-page-break": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/postcss-page-break/-/postcss-page-break-3.0.4.tgz", + "integrity": "sha512-1JGu8oCjVXLa9q9rFTo4MbeeA5FMe00/9C7lN4va606Rdb+HkxXtXsmEDrIraQ11fGz/WvKWa8gMuCKkrXpTsQ==", + "license": "MIT", + "peerDependencies": { + "postcss": "^8" + } + }, + "node_modules/postcss-place": { + "version": "7.0.5", + "resolved": "https://registry.npmjs.org/postcss-place/-/postcss-place-7.0.5.tgz", + "integrity": "sha512-wR8igaZROA6Z4pv0d+bvVrvGY4GVHihBCBQieXFY3kuSuMyOmEnnfFzHl/tQuqHZkfkIVBEbDvYcFfHmpSet9g==", + "license": "CC0-1.0", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-preset-env": { + "version": "7.8.3", + "resolved": "https://registry.npmjs.org/postcss-preset-env/-/postcss-preset-env-7.8.3.tgz", + "integrity": "sha512-T1LgRm5uEVFSEF83vHZJV2z19lHg4yJuZ6gXZZkqVsqv63nlr6zabMH3l4Pc01FQCyfWVrh2GaUeCVy9Po+Aag==", + "license": "CC0-1.0", + "dependencies": { + "@csstools/postcss-cascade-layers": "^1.1.1", + "@csstools/postcss-color-function": "^1.1.1", + "@csstools/postcss-font-format-keywords": "^1.0.1", + "@csstools/postcss-hwb-function": "^1.0.2", + "@csstools/postcss-ic-unit": "^1.0.1", + "@csstools/postcss-is-pseudo-class": "^2.0.7", + "@csstools/postcss-nested-calc": "^1.0.0", + "@csstools/postcss-normalize-display-values": "^1.0.1", + "@csstools/postcss-oklab-function": "^1.1.1", + "@csstools/postcss-progressive-custom-properties": "^1.3.0", + "@csstools/postcss-stepped-value-functions": "^1.0.1", + "@csstools/postcss-text-decoration-shorthand": "^1.0.0", + "@csstools/postcss-trigonometric-functions": "^1.0.2", + "@csstools/postcss-unset-value": "^1.0.2", + "autoprefixer": "^10.4.13", + "browserslist": "^4.21.4", + "css-blank-pseudo": "^3.0.3", + "css-has-pseudo": "^3.0.4", + "css-prefers-color-scheme": "^6.0.3", + "cssdb": "^7.1.0", + "postcss-attribute-case-insensitive": "^5.0.2", + "postcss-clamp": "^4.1.0", + "postcss-color-functional-notation": "^4.2.4", + "postcss-color-hex-alpha": "^8.0.4", + "postcss-color-rebeccapurple": "^7.1.1", + "postcss-custom-media": "^8.0.2", + "postcss-custom-properties": "^12.1.10", + "postcss-custom-selectors": "^6.0.3", + "postcss-dir-pseudo-class": "^6.0.5", + "postcss-double-position-gradients": "^3.1.2", + "postcss-env-function": "^4.0.6", + "postcss-focus-visible": "^6.0.4", + "postcss-focus-within": "^5.0.4", + "postcss-font-variant": "^5.0.0", + "postcss-gap-properties": "^3.0.5", + "postcss-image-set-function": "^4.0.7", + "postcss-initial": "^4.0.1", + "postcss-lab-function": "^4.2.1", + "postcss-logical": "^5.0.4", + "postcss-media-minmax": "^5.0.0", + "postcss-nesting": "^10.2.0", + "postcss-opacity-percentage": "^1.1.2", + "postcss-overflow-shorthand": "^3.0.4", + "postcss-page-break": "^3.0.4", + "postcss-place": "^7.0.5", + "postcss-pseudo-class-any-link": "^7.1.6", + "postcss-replace-overflow-wrap": "^4.0.0", + "postcss-selector-not": "^6.0.1", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-pseudo-class-any-link": { + "version": "7.1.6", + "resolved": "https://registry.npmjs.org/postcss-pseudo-class-any-link/-/postcss-pseudo-class-any-link-7.1.6.tgz", + "integrity": "sha512-9sCtZkO6f/5ML9WcTLcIyV1yz9D1rf0tWc+ulKcvV30s0iZKS/ONyETvoWsr6vnrmW+X+KmuK3gV/w5EWnT37w==", + "license": "CC0-1.0", + "dependencies": { + "postcss-selector-parser": "^6.0.10" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-reduce-initial": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-5.1.2.tgz", + "integrity": "sha512-dE/y2XRaqAi6OvjzD22pjTUQ8eOfc6m/natGHgKFBK9DxFmIm69YmaRVQrGgFlEfc1HePIurY0TmDeROK05rIg==", + "license": "MIT", + "dependencies": { + "browserslist": "^4.21.4", + "caniuse-api": "^3.0.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-reduce-transforms": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-reduce-transforms/-/postcss-reduce-transforms-5.1.0.tgz", + "integrity": "sha512-2fbdbmgir5AvpW9RLtdONx1QoYG2/EtqpNQbFASDlixBbAYuTcJ0dECwlqNqH7VbaUnEnh8SrxOe2sRIn24XyQ==", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-replace-overflow-wrap": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/postcss-replace-overflow-wrap/-/postcss-replace-overflow-wrap-4.0.0.tgz", + "integrity": "sha512-KmF7SBPphT4gPPcKZc7aDkweHiKEEO8cla/GjcBK+ckKxiZslIu3C4GCRW3DNfL0o7yW7kMQu9xlZ1kXRXLXtw==", + "license": "MIT", + "peerDependencies": { + "postcss": "^8.0.3" + } + }, + "node_modules/postcss-selector-not": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/postcss-selector-not/-/postcss-selector-not-6.0.1.tgz", + "integrity": "sha512-1i9affjAe9xu/y9uqWH+tD4r6/hDaXJruk8xn2x1vzxC2U3J3LKO3zJW4CyxlNhA56pADJ/djpEwpH1RClI2rQ==", + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.0.10" + }, + "engines": { + "node": "^12 || ^14 || >=16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/csstools" + }, + "peerDependencies": { + "postcss": "^8.2" + } + }, + "node_modules/postcss-selector-parser": { + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz", + "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==", + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss-svgo": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/postcss-svgo/-/postcss-svgo-5.1.0.tgz", + "integrity": "sha512-D75KsH1zm5ZrHyxPakAxJWtkyXew5qwS70v56exwvw542d9CRtTo78K0WeFxZB4G7JXKKMbEZtZayTGdIky/eA==", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0", + "svgo": "^2.7.0" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "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", + "integrity": "sha512-tRpdppF7TRazZrjJ6v3stzv93qxRcSsFmW6cX0Zm2NVKpxE1WV1HblnghVv9TreireHkqI/VDEsfolRF1p6y7Q==", + "license": "MIT", + "dependencies": { + "mdn-data": "2.0.14", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/postcss-svgo/node_modules/mdn-data": { + "version": "2.0.14", + "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.0.14.tgz", + "integrity": "sha512-dn6wd0uw5GsdswPFfsgMp5NSB0/aDe6fK94YJV/AJDYXL6HVLWBsxeq7js7Ad+mU2K9LAlwpk6kN2D5mwCPVow==", + "license": "CC0-1.0" + }, + "node_modules/postcss-svgo/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/postcss-svgo/node_modules/svgo": { + "version": "2.8.0", + "resolved": "https://registry.npmjs.org/svgo/-/svgo-2.8.0.tgz", + "integrity": "sha512-+N/Q9kV1+F+UeWYoSiULYo4xYSDQlTgb+ayMobAXPwMnLvop7oxKMo9OzIrX5x3eS4L4f2UHhc9axXwY8DpChg==", + "license": "MIT", + "dependencies": { + "@trysound/sax": "0.2.0", + "commander": "^7.2.0", + "css-select": "^4.1.3", + "css-tree": "^1.1.3", + "csso": "^4.2.0", + "picocolors": "^1.0.0", + "stable": "^0.1.8" + }, + "bin": { + "svgo": "bin/svgo" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/postcss-unique-selectors": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/postcss-unique-selectors/-/postcss-unique-selectors-5.1.1.tgz", + "integrity": "sha512-5JiODlELrz8L2HwxfPnhOWZYWDxVHWL83ufOv84NrcgipI7TaeRsatAhK4Tr2/ZiYldpK/wBvw5BD3qfaK96GA==", + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.0.5" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/postcss-value-parser": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz", + "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==", + "license": "MIT" + }, + "node_modules/prelude-ls": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", + "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==", + "license": "MIT", + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/pretty-bytes": { + "version": "5.6.0", + "resolved": "https://registry.npmjs.org/pretty-bytes/-/pretty-bytes-5.6.0.tgz", + "integrity": "sha512-FFw039TmrBqFK8ma/7OL3sDz/VytdtJr044/QUJtH0wK9lb9jLq9tJyIxUwtQJHwar2BqtiA4iCWSwo9JLkzFg==", + "license": "MIT", + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/pretty-error": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/pretty-error/-/pretty-error-4.0.0.tgz", + "integrity": "sha512-AoJ5YMAcXKYxKhuJGdcvse+Voc6v1RgnsR3nWcYU7q4t6z0Q6T86sv5Zq8VIRbOWWFpvdGE83LtdSMNd+6Y0xw==", + "license": "MIT", + "dependencies": { + "lodash": "^4.17.20", + "renderkid": "^3.0.0" + } + }, + "node_modules/pretty-format": { + "version": "27.5.1", + "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz", + "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1", + "ansi-styles": "^5.0.0", + "react-is": "^17.0.1" + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + } + }, + "node_modules/pretty-format/node_modules/ansi-styles": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz", + "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/prismjs": { + "version": "1.30.0", + "resolved": "https://registry.npmjs.org/prismjs/-/prismjs-1.30.0.tgz", + "integrity": "sha512-DEvV2ZF2r2/63V+tK8hQvrR2ZGn10srHbXviTlcv7Kpzw8jWiNTqbVgjO3IY8RxrrOUF8VPMQQFysYYYv0YZxw==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/process-nextick-args": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz", + "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==", + "license": "MIT" + }, + "node_modules/promise": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/promise/-/promise-8.3.0.tgz", + "integrity": "sha512-rZPNPKTOYVNEEKFaq1HqTgOwZD+4/YHS5ukLzQCypkj+OkYx7iv0mA91lJlpPPZ8vMau3IIGj5Qlwrx+8iiSmg==", + "license": "MIT", + "dependencies": { + "asap": "~2.0.6" + } + }, + "node_modules/prompts": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz", + "integrity": "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==", + "license": "MIT", + "dependencies": { + "kleur": "^3.0.3", + "sisteransi": "^1.0.5" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/prop-types": { + "version": "15.8.1", + "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz", + "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.4.0", + "object-assign": "^4.1.1", + "react-is": "^16.13.1" + } + }, + "node_modules/prop-types/node_modules/react-is": { + "version": "16.13.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz", + "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==", + "license": "MIT" + }, + "node_modules/property-information": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/property-information/-/property-information-7.0.0.tgz", + "integrity": "sha512-7D/qOz/+Y4X/rzSB6jKxKUsQnphO046ei8qxG59mtM3RG3DHgTK81HrxrmoDVINJb8NKT5ZsRbwHvQ6B68Iyhg==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/proxy-addr": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz", + "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==", + "license": "MIT", + "dependencies": { + "forwarded": "0.2.0", + "ipaddr.js": "1.9.1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/proxy-addr/node_modules/ipaddr.js": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz", + "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==", + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/proxy-from-env": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz", + "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==", + "license": "MIT" + }, + "node_modules/psl": { + "version": "1.15.0", + "resolved": "https://registry.npmjs.org/psl/-/psl-1.15.0.tgz", + "integrity": "sha512-JZd3gMVBAVQkSs6HdNZo9Sdo0LNcQeMNP3CozBJb3JYC/QUYZTnKxP+f8oWRX4rHP5EurWxqAHTSwUCjlNKa1w==", + "license": "MIT", + "dependencies": { + "punycode": "^2.3.1" + }, + "funding": { + "url": "https://github.com/sponsors/lupomontero" + } + }, + "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/q": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/q/-/q-1.5.1.tgz", + "integrity": "sha512-kV/CThkXo6xyFEZUugw/+pIOywXcDbFYgSct5cT3gqlbkBE1SJdwy6UQoZvodiWF/ckQLZyDE/Bu1M6gVu5lVw==", + "deprecated": "You or someone you depend on is using Q, the JavaScript Promise library that gave JavaScript developers strong feelings about promises. They can almost certainly migrate to the native JavaScript promise now. Thank you literally everyone for joining me in this bet against the odds. Be excellent to each other.\n\n(For a CapTP with native promises, see @endo/eventual-send and @endo/captp)", + "license": "MIT", + "engines": { + "node": ">=0.6.0", + "teleport": ">=0.2.0" + } + }, + "node_modules/qs": { + "version": "6.13.0", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz", + "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==", + "license": "BSD-3-Clause", + "dependencies": { + "side-channel": "^1.0.6" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/quansync": { + "version": "0.2.10", + "resolved": "https://registry.npmjs.org/quansync/-/quansync-0.2.10.tgz", + "integrity": "sha512-t41VRkMYbkHyCYmOvx/6URnN80H7k4X0lLdBMGsz+maAwrJQYB1djpV6vHrQIBE0WBSGqhtEHrK9U3DWWH8v7A==", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/antfu" + }, + { + "type": "individual", + "url": "https://github.com/sponsors/sxzz" + } + ], + "license": "MIT" + }, + "node_modules/querystringify": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/querystringify/-/querystringify-2.2.0.tgz", + "integrity": "sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ==", + "license": "MIT" + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz", + "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/raf": { + "version": "3.4.1", + "resolved": "https://registry.npmjs.org/raf/-/raf-3.4.1.tgz", + "integrity": "sha512-Sq4CW4QhwOHE8ucn6J34MqtZCeWFP2aQSmrlroYgqAV1PjStIhJXxYuTgUIfkEk7zTLjmIjLmU5q+fbD1NnOJA==", + "license": "MIT", + "dependencies": { + "performance-now": "^2.1.0" + } + }, + "node_modules/randombytes": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz", + "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==", + "license": "MIT", + "dependencies": { + "safe-buffer": "^5.1.0" + } + }, + "node_modules/range-parser": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz", + "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/raw-body": { + "version": "2.5.2", + "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz", + "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==", + "license": "MIT", + "dependencies": { + "bytes": "3.1.2", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/raw-body/node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz", + "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-app-polyfill": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/react-app-polyfill/-/react-app-polyfill-3.0.0.tgz", + "integrity": "sha512-sZ41cxiU5llIB003yxxQBYrARBqe0repqPTTYBTmMqTz9szeBbE37BehCE891NZsmdZqqP+xWKdT3eo3vOzN8w==", + "license": "MIT", + "dependencies": { + "core-js": "^3.19.2", + "object-assign": "^4.1.1", + "promise": "^8.1.0", + "raf": "^3.4.1", + "regenerator-runtime": "^0.13.9", + "whatwg-fetch": "^3.6.2" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/react-dev-utils": { + "version": "12.0.1", + "resolved": "https://registry.npmjs.org/react-dev-utils/-/react-dev-utils-12.0.1.tgz", + "integrity": "sha512-84Ivxmr17KjUupyqzFode6xKhjwuEJDROWKJy/BthkL7Wn6NJ8h4WE6k/exAv6ImS+0oZLRRW5j/aINMHyeGeQ==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.16.0", + "address": "^1.1.2", + "browserslist": "^4.18.1", + "chalk": "^4.1.2", + "cross-spawn": "^7.0.3", + "detect-port-alt": "^1.1.6", + "escape-string-regexp": "^4.0.0", + "filesize": "^8.0.6", + "find-up": "^5.0.0", + "fork-ts-checker-webpack-plugin": "^6.5.0", + "global-modules": "^2.0.0", + "globby": "^11.0.4", + "gzip-size": "^6.0.0", + "immer": "^9.0.7", + "is-root": "^2.1.0", + "loader-utils": "^3.2.0", + "open": "^8.4.0", + "pkg-up": "^3.1.0", + "prompts": "^2.4.2", + "react-error-overlay": "^6.0.11", + "recursive-readdir": "^2.2.2", + "shell-quote": "^1.7.3", + "strip-ansi": "^6.0.1", + "text-table": "^0.2.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/react-dev-utils/node_modules/find-up": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", + "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", + "license": "MIT", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/react-dev-utils/node_modules/loader-utils": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-3.3.1.tgz", + "integrity": "sha512-FMJTLMXfCLMLfJxcX9PFqX5qD88Z5MRGaZCVzfuqeZSPsyiBzs+pahDQjbIWz2QIzPZz0NX9Zy4FX3lmK6YHIg==", + "license": "MIT", + "engines": { + "node": ">= 12.13.0" + } + }, + "node_modules/react-dev-utils/node_modules/locate-path": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", + "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/react-dev-utils/node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/react-dev-utils/node_modules/p-locate": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", + "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/react-dom": { + "version": "18.3.1", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz", + "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0", + "scheduler": "^0.23.2" + }, + "peerDependencies": { + "react": "^18.3.1" + } + }, + "node_modules/react-dropzone": { + "version": "14.3.8", + "resolved": "https://registry.npmjs.org/react-dropzone/-/react-dropzone-14.3.8.tgz", + "integrity": "sha512-sBgODnq+lcA4P296DY4wacOZz3JFpD99fp+hb//iBO2HHnyeZU3FwWyXJ6salNpqQdsZrgMrotuko/BdJMV8Ug==", + "license": "MIT", + "dependencies": { + "attr-accept": "^2.2.4", + "file-selector": "^2.1.0", + "prop-types": "^15.8.1" + }, + "engines": { + "node": ">= 10.13" + }, + "peerDependencies": { + "react": ">= 16.8 || 18.0.0" + } + }, + "node_modules/react-error-overlay": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/react-error-overlay/-/react-error-overlay-6.1.0.tgz", + "integrity": "sha512-SN/U6Ytxf1QGkw/9ve5Y+NxBbZM6Ht95tuXNMKs8EJyFa/Vy/+Co3stop3KBHARfn/giv+Lj1uUnTfOJ3moFEQ==", + "license": "MIT" + }, + "node_modules/react-is": { + "version": "17.0.2", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz", + "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==", + "license": "MIT" + }, + "node_modules/react-markdown": { + "version": "10.1.0", + "resolved": "https://registry.npmjs.org/react-markdown/-/react-markdown-10.1.0.tgz", + "integrity": "sha512-qKxVopLT/TyA6BX3Ue5NwabOsAzm0Q7kAPwq6L+wWDwisYs7R8vZ0nRXqq6rkueboxpkjvLGU9fWifiX/ZZFxQ==", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/mdast": "^4.0.0", + "devlop": "^1.0.0", + "hast-util-to-jsx-runtime": "^2.0.0", + "html-url-attributes": "^3.0.0", + "mdast-util-to-hast": "^13.0.0", + "remark-parse": "^11.0.0", + "remark-rehype": "^11.0.0", + "unified": "^11.0.0", + "unist-util-visit": "^5.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + }, + "peerDependencies": { + "@types/react": ">=18", + "react": ">=18" + } + }, + "node_modules/react-refresh": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.11.0.tgz", + "integrity": "sha512-F27qZr8uUqwhWZboondsPx8tnC3Ct3SxZA3V5WyEvujRyyNv0VYPhoBg1gZ8/MV5tubQp76Trw8lTv9hzRBa+A==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-router": { + "version": "6.30.0", + "resolved": "https://registry.npmjs.org/react-router/-/react-router-6.30.0.tgz", + "integrity": "sha512-D3X8FyH9nBcTSHGdEKurK7r8OYE1kKFn3d/CF+CoxbSHkxU7o37+Uh7eAHRXr6k2tSExXYO++07PeXJtA/dEhQ==", + "license": "MIT", + "dependencies": { + "@remix-run/router": "1.23.0" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "react": ">=16.8" + } + }, + "node_modules/react-router-dom": { + "version": "6.30.0", + "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-6.30.0.tgz", + "integrity": "sha512-x30B78HV5tFk8ex0ITwzC9TTZMua4jGyA9IUlH1JLQYQTFyxr/ZxwOJq7evg1JX1qGVUcvhsmQSKdPncQrjTgA==", + "license": "MIT", + "dependencies": { + "@remix-run/router": "1.23.0", + "react-router": "6.30.0" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "react": ">=16.8", + "react-dom": ">=16.8" + } + }, + "node_modules/react-scripts": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/react-scripts/-/react-scripts-5.0.1.tgz", + "integrity": "sha512-8VAmEm/ZAwQzJ+GOMLbBsTdDKOpuZh7RPs0UymvBR2vRk4iZWCskjbFnxqjrzoIvlNNRZ3QJFx6/qDSi6zSnaQ==", + "license": "MIT", + "dependencies": { + "@babel/core": "^7.16.0", + "@pmmmwh/react-refresh-webpack-plugin": "^0.5.3", + "@svgr/webpack": "^5.5.0", + "babel-jest": "^27.4.2", + "babel-loader": "^8.2.3", + "babel-plugin-named-asset-import": "^0.3.8", + "babel-preset-react-app": "^10.0.1", + "bfj": "^7.0.2", + "browserslist": "^4.18.1", + "camelcase": "^6.2.1", + "case-sensitive-paths-webpack-plugin": "^2.4.0", + "css-loader": "^6.5.1", + "css-minimizer-webpack-plugin": "^3.2.0", + "dotenv": "^10.0.0", + "dotenv-expand": "^5.1.0", + "eslint": "^8.3.0", + "eslint-config-react-app": "^7.0.1", + "eslint-webpack-plugin": "^3.1.1", + "file-loader": "^6.2.0", + "fs-extra": "^10.0.0", + "html-webpack-plugin": "^5.5.0", + "identity-obj-proxy": "^3.0.0", + "jest": "^27.4.3", + "jest-resolve": "^27.4.2", + "jest-watch-typeahead": "^1.0.0", + "mini-css-extract-plugin": "^2.4.5", + "postcss": "^8.4.4", + "postcss-flexbugs-fixes": "^5.0.2", + "postcss-loader": "^6.2.1", + "postcss-normalize": "^10.0.1", + "postcss-preset-env": "^7.0.1", + "prompts": "^2.4.2", + "react-app-polyfill": "^3.0.0", + "react-dev-utils": "^12.0.1", + "react-refresh": "^0.11.0", + "resolve": "^1.20.0", + "resolve-url-loader": "^4.0.0", + "sass-loader": "^12.3.0", + "semver": "^7.3.5", + "source-map-loader": "^3.0.0", + "style-loader": "^3.3.1", + "tailwindcss": "^3.0.2", + "terser-webpack-plugin": "^5.2.5", + "webpack": "^5.64.4", + "webpack-dev-server": "^4.6.0", + "webpack-manifest-plugin": "^4.0.2", + "workbox-webpack-plugin": "^6.4.1" + }, + "bin": { + "react-scripts": "bin/react-scripts.js" + }, + "engines": { + "node": ">=14.0.0" + }, + "optionalDependencies": { + "fsevents": "^2.3.2" + }, + "peerDependencies": { + "react": ">= 16", + "typescript": "^3.2.1 || ^4" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/react-syntax-highlighter": { + "version": "15.6.1", + "resolved": "https://registry.npmjs.org/react-syntax-highlighter/-/react-syntax-highlighter-15.6.1.tgz", + "integrity": "sha512-OqJ2/vL7lEeV5zTJyG7kmARppUjiB9h9udl4qHQjjgEos66z00Ia0OckwYfRxCSFrW8RJIBnsBwQsHZbVPspqg==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.3.1", + "highlight.js": "^10.4.1", + "highlightjs-vue": "^1.0.0", + "lowlight": "^1.17.0", + "prismjs": "^1.27.0", + "refractor": "^3.6.0" + }, + "peerDependencies": { + "react": ">= 0.14.0" + } + }, + "node_modules/react-use-set": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/react-use-set/-/react-use-set-1.0.0.tgz", + "integrity": "sha512-6BBbOcWc/tOKuwd9gDtdunvOr/g40S0SkCBYvrSJvpI0upzNlHmLoeDvylnoP8PrjQXItClAFxseVGGhEkk7kw==", + "license": "MIT", + "peerDependencies": { + "react": ">=16.8.0" + } + }, + "node_modules/react-window": { + "version": "1.8.11", + "resolved": "https://registry.npmjs.org/react-window/-/react-window-1.8.11.tgz", + "integrity": "sha512-+SRbUVT2scadgFSWx+R1P754xHPEqvcfSfVX10QYg6POOz+WNgkN48pS+BtZNIMGiL1HYrSEiCkwsMS15QogEQ==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.0.0", + "memoize-one": ">=3.1.1 <6" + }, + "engines": { + "node": ">8.0.0" + }, + "peerDependencies": { + "react": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/read-cache": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz", + "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==", + "license": "MIT", + "dependencies": { + "pify": "^2.3.0" + } + }, + "node_modules/readable-stream": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/readdirp": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", + "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "license": "MIT", + "dependencies": { + "picomatch": "^2.2.1" + }, + "engines": { + "node": ">=8.10.0" + } + }, + "node_modules/recursive-readdir": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/recursive-readdir/-/recursive-readdir-2.2.3.tgz", + "integrity": "sha512-8HrF5ZsXk5FAH9dgsx3BlUer73nIhuj+9OrQwEbLTPOBzGkL1lsFCR01am+v+0m2Cmbs1nP12hLDl5FA7EszKA==", + "license": "MIT", + "dependencies": { + "minimatch": "^3.0.5" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/redent": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/redent/-/redent-3.0.0.tgz", + "integrity": "sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==", + "dev": true, + "license": "MIT", + "dependencies": { + "indent-string": "^4.0.0", + "strip-indent": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/reflect.getprototypeof": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz", + "integrity": "sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.9", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0", + "get-intrinsic": "^1.2.7", + "get-proto": "^1.0.1", + "which-builtin-type": "^1.2.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/refractor": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/refractor/-/refractor-3.6.0.tgz", + "integrity": "sha512-MY9W41IOWxxk31o+YvFCNyNzdkc9M20NoZK5vq6jkv4I/uh2zkWcfudj0Q1fovjUQJrNewS9NMzeTtqPf+n5EA==", + "license": "MIT", + "dependencies": { + "hastscript": "^6.0.0", + "parse-entities": "^2.0.0", + "prismjs": "~1.27.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/refractor/node_modules/character-entities": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/character-entities/-/character-entities-1.2.4.tgz", + "integrity": "sha512-iBMyeEHxfVnIakwOuDXpVkc54HijNgCyQB2w0VfGQThle6NXn50zU6V/u+LDhxHcDUPojn6Kpga3PTAD8W1bQw==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/refractor/node_modules/character-entities-legacy": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-1.1.4.tgz", + "integrity": "sha512-3Xnr+7ZFS1uxeiUDvV02wQ+QDbc55o97tIV5zHScSPJpcLm/r0DFPcoY3tYRp+VZukxuMeKgXYmsXQHO05zQeA==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/refractor/node_modules/character-reference-invalid": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-1.1.4.tgz", + "integrity": "sha512-mKKUkUbhPpQlCOfIuZkvSEgktjPFIsZKRRbC6KWVEMvlzblj3i3asQv5ODsrwt0N3pHAEvjP8KTQPHkp0+6jOg==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/refractor/node_modules/is-alphabetical": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-1.0.4.tgz", + "integrity": "sha512-DwzsA04LQ10FHTZuL0/grVDk4rFoVH1pjAToYwBrHSxcrBIGQuXrQMtD5U1b0U2XVgKZCTLLP8u2Qxqhy3l2Vg==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/refractor/node_modules/is-alphanumerical": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-1.0.4.tgz", + "integrity": "sha512-UzoZUr+XfVz3t3v4KyGEniVL9BDRoQtY7tOyrRybkVNjDFWyo1yhXNGrrBTQxp3ib9BLAWs7k2YKBQsFRkZG9A==", + "license": "MIT", + "dependencies": { + "is-alphabetical": "^1.0.0", + "is-decimal": "^1.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/refractor/node_modules/is-decimal": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-1.0.4.tgz", + "integrity": "sha512-RGdriMmQQvZ2aqaQq3awNA6dCGtKpiDFcOzrTWrDAT2MiWrKQVPmxLGHl7Y2nNu6led0kEyoX0enY0qXYsv9zw==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/refractor/node_modules/is-hexadecimal": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-1.0.4.tgz", + "integrity": "sha512-gyPJuv83bHMpocVYoqof5VDiZveEoGoFL8m3BXNb2VW8Xs+rz9kqO8LOQ5DH6EsuvilT1ApazU0pyl+ytbPtlw==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/refractor/node_modules/parse-entities": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-2.0.0.tgz", + "integrity": "sha512-kkywGpCcRYhqQIchaWqZ875wzpS/bMKhz5HnN3p7wveJTkTtyAB/AlnS0f8DFSqYW1T82t6yEAkEcB+A1I3MbQ==", + "license": "MIT", + "dependencies": { + "character-entities": "^1.0.0", + "character-entities-legacy": "^1.0.0", + "character-reference-invalid": "^1.0.0", + "is-alphanumerical": "^1.0.0", + "is-decimal": "^1.0.0", + "is-hexadecimal": "^1.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/refractor/node_modules/prismjs": { + "version": "1.27.0", + "resolved": "https://registry.npmjs.org/prismjs/-/prismjs-1.27.0.tgz", + "integrity": "sha512-t13BGPUlFDR7wRB5kQDG4jjl7XeuH6jbJGt11JHPL96qwsEHNX2+68tFXqc1/k+/jALsbSWJKUOT/hcYAZ5LkA==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/regenerate": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz", + "integrity": "sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==", + "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==", + "license": "MIT", + "dependencies": { + "regenerate": "^1.4.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/regenerator-runtime": { + "version": "0.13.11", + "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz", + "integrity": "sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==", + "license": "MIT" + }, + "node_modules/regex-parser": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/regex-parser/-/regex-parser-2.3.1.tgz", + "integrity": "sha512-yXLRqatcCuKtVHsWrNg0JL3l1zGfdXeEvDa0bdu4tCDQw0RpMDZsqbkyRTUnKMR0tXF627V2oEWjBEaEdqTwtQ==", + "license": "MIT" + }, + "node_modules/regexp.prototype.flags": { + "version": "1.5.4", + "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.5.4.tgz", + "integrity": "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-errors": "^1.3.0", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "set-function-name": "^2.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "regenerate": "^1.4.2", + "regenerate-unicode-properties": "^10.2.0", + "regjsgen": "^0.8.0", + "regjsparser": "^0.12.0", + "unicode-match-property-ecmascript": "^2.0.0", + "unicode-match-property-value-ecmascript": "^2.1.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/regjsgen": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.8.0.tgz", + "integrity": "sha512-RvwtGe3d7LvWiDQXeQw8p5asZUmfU1G/l6WbUXeHta7Y2PEIvBTwH6E2EfmYUK8pxcxEdEmaomqyp0vZZ7C+3Q==", + "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==", + "license": "BSD-2-Clause", + "dependencies": { + "jsesc": "~3.0.2" + }, + "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", + "integrity": "sha512-G08Dxvm4iDN3MLM0EsP62EDV9IuhXPR6blNz6Utcp7zyV3tr4HVNINt6MpaRWbxoOHT3Q7YN2P+jaHX8vUbgog==", + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/remark-gfm": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/remark-gfm/-/remark-gfm-4.0.1.tgz", + "integrity": "sha512-1quofZ2RQ9EWdeN34S79+KExV1764+wCUGop5CPL1WGdD0ocPpu91lzPGbwWMECpEpd42kJGQwzRfyov9j4yNg==", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-gfm": "^3.0.0", + "micromark-extension-gfm": "^3.0.0", + "remark-parse": "^11.0.0", + "remark-stringify": "^11.0.0", + "unified": "^11.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-parse": { + "version": "11.0.0", + "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-11.0.0.tgz", + "integrity": "sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-from-markdown": "^2.0.0", + "micromark-util-types": "^2.0.0", + "unified": "^11.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-rehype": { + "version": "11.1.2", + "resolved": "https://registry.npmjs.org/remark-rehype/-/remark-rehype-11.1.2.tgz", + "integrity": "sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw==", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/mdast": "^4.0.0", + "mdast-util-to-hast": "^13.0.0", + "unified": "^11.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-stringify": { + "version": "11.0.0", + "resolved": "https://registry.npmjs.org/remark-stringify/-/remark-stringify-11.0.0.tgz", + "integrity": "sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw==", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-to-markdown": "^2.0.0", + "unified": "^11.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/renderkid": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/renderkid/-/renderkid-3.0.0.tgz", + "integrity": "sha512-q/7VIQA8lmM1hF+jn+sFSPWGlMkSAeNYcPLmDQx2zzuiDfaLrOmumR8iaUKlenFgh0XRPIUeSPlH3A+AW3Z5pg==", + "license": "MIT", + "dependencies": { + "css-select": "^4.1.3", + "dom-converter": "^0.2.0", + "htmlparser2": "^6.1.0", + "lodash": "^4.17.21", + "strip-ansi": "^6.0.1" + } + }, + "node_modules/require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/require-from-string": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/requires-port": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz", + "integrity": "sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==", + "license": "MIT" + }, + "node_modules/resolve": { + "version": "1.22.10", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.10.tgz", + "integrity": "sha512-NPRy+/ncIMeDlTAsuqwKIiferiawhefFJtkNSW0qZJEqMEb+qBt/77B/jGeeek+F0uOeN05CDa6HXbbIgtVX4w==", + "license": "MIT", + "dependencies": { + "is-core-module": "^2.16.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/resolve-cwd": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/resolve-cwd/-/resolve-cwd-3.0.0.tgz", + "integrity": "sha512-OrZaX2Mb+rJCpH/6CpSqt9xFVpN++x01XnN2ie9g6P5/3xelLAkXWVADpdz1IHD/KFfEXyE6V0U01OQ3UO2rEg==", + "license": "MIT", + "dependencies": { + "resolve-from": "^5.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/resolve-from": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/resolve-url-loader": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-url-loader/-/resolve-url-loader-4.0.0.tgz", + "integrity": "sha512-05VEMczVREcbtT7Bz+C+96eUO5HDNvdthIiMB34t7FcF8ehcu4wC0sSgPUubs3XW2Q3CNLJk/BJrCU9wVRymiA==", + "license": "MIT", + "dependencies": { + "adjust-sourcemap-loader": "^4.0.0", + "convert-source-map": "^1.7.0", + "loader-utils": "^2.0.0", + "postcss": "^7.0.35", + "source-map": "0.6.1" + }, + "engines": { + "node": ">=8.9" + }, + "peerDependencies": { + "rework": "1.0.1", + "rework-visit": "1.0.0" + }, + "peerDependenciesMeta": { + "rework": { + "optional": true + }, + "rework-visit": { + "optional": true + } + } + }, + "node_modules/resolve-url-loader/node_modules/convert-source-map": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", + "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==", + "license": "MIT" + }, + "node_modules/resolve-url-loader/node_modules/picocolors": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-0.2.1.tgz", + "integrity": "sha512-cMlDqaLEqfSaW8Z7N5Jw+lyIW869EzT73/F5lhtY9cLGoVxSXznfgfXMO0Z5K0o0Q2TkTXq+0KFsdnSe3jDViA==", + "license": "ISC" + }, + "node_modules/resolve-url-loader/node_modules/postcss": { + "version": "7.0.39", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-7.0.39.tgz", + "integrity": "sha512-yioayjNbHn6z1/Bywyb2Y4s3yvDAeXGOyxqD+LnVOinq6Mdmd++SW2wUNVzavyyHxd6+DxzWGIuosg6P1Rj8uA==", + "license": "MIT", + "dependencies": { + "picocolors": "^0.2.1", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">=6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + } + }, + "node_modules/resolve-url-loader/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve.exports": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/resolve.exports/-/resolve.exports-1.1.1.tgz", + "integrity": "sha512-/NtpHNDN7jWhAaQ9BvBUYZ6YTXsRBgfqWFWP7BZBaoMJO/I3G5OFzvTuWNlZC3aPjins1F+TNrLKsGbH4rfsRQ==", + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/retry": { + "version": "0.13.1", + "resolved": "https://registry.npmjs.org/retry/-/retry-0.13.1.tgz", + "integrity": "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg==", + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/reusify": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz", + "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==", + "license": "MIT", + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/rimraf": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz", + "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==", + "deprecated": "Rimraf versions prior to v4 are no longer supported", + "license": "ISC", + "dependencies": { + "glob": "^7.1.3" + }, + "bin": { + "rimraf": "bin.js" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/robust-predicates": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/robust-predicates/-/robust-predicates-3.0.2.tgz", + "integrity": "sha512-IXgzBWvWQwE6PrDI05OvmXUIruQTcoMDzRsOd5CDvHCVLcLHMTSYvOK5Cm46kWqlV3yAbuSpBZdJ5oP5OUoStg==", + "license": "Unlicense" + }, + "node_modules/rollup": { + "version": "2.79.2", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.79.2.tgz", + "integrity": "sha512-fS6iqSPZDs3dr/y7Od6y5nha8dW1YnbgtsyotCVvoFGKbERG++CVRFv1meyGDE1SNItQA8BrnCw7ScdAhRJ3XQ==", + "license": "MIT", + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=10.0.0" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/rollup-plugin-terser": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/rollup-plugin-terser/-/rollup-plugin-terser-7.0.2.tgz", + "integrity": "sha512-w3iIaU4OxcF52UUXiZNsNeuXIMDvFrr+ZXK6bFZ0Q60qyVfq4uLptoS4bbq3paG3x216eQllFZX7zt6TIImguQ==", + "deprecated": "This package has been deprecated and is no longer maintained. Please use @rollup/plugin-terser", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.10.4", + "jest-worker": "^26.2.1", + "serialize-javascript": "^4.0.0", + "terser": "^5.0.0" + }, + "peerDependencies": { + "rollup": "^2.0.0" + } + }, + "node_modules/rollup-plugin-terser/node_modules/jest-worker": { + "version": "26.6.2", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-26.6.2.tgz", + "integrity": "sha512-KWYVV1c4i+jbMpaBC+U++4Va0cp8OisU185o73T1vo99hqi7w8tSJfUXYswwqqrjzwxa6KpRK54WhPvwf5w6PQ==", + "license": "MIT", + "dependencies": { + "@types/node": "*", + "merge-stream": "^2.0.0", + "supports-color": "^7.0.0" + }, + "engines": { + "node": ">= 10.13.0" + } + }, + "node_modules/rollup-plugin-terser/node_modules/serialize-javascript": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-4.0.0.tgz", + "integrity": "sha512-GaNA54380uFefWghODBWEGisLZFj00nS5ACs6yHa9nLqlLpVLO8ChDGeKRjZnV4Nh4n0Qi7nhYZD/9fCPzEqkw==", + "license": "BSD-3-Clause", + "dependencies": { + "randombytes": "^2.1.0" + } + }, + "node_modules/roughjs": { + "version": "4.6.6", + "resolved": "https://registry.npmjs.org/roughjs/-/roughjs-4.6.6.tgz", + "integrity": "sha512-ZUz/69+SYpFN/g/lUlo2FXcIjRkSu3nDarreVdGGndHEBJ6cXPdKguS8JGxwj5HA5xIbVKSmLgr5b3AWxtRfvQ==", + "license": "MIT", + "dependencies": { + "hachure-fill": "^0.5.2", + "path-data-parser": "^0.1.0", + "points-on-curve": "^0.2.0", + "points-on-path": "^0.2.1" + } + }, + "node_modules/rsuite": { + "version": "5.80.1", + "resolved": "https://registry.npmjs.org/rsuite/-/rsuite-5.80.1.tgz", + "integrity": "sha512-nCnqWJN73SSx50wamGsNW9TSqxbfol/cjfL49wZ2n9NUytcI8grj2vvUBqVZKof7ki03FXmS9XO/xo6g4BA6fQ==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.20.1", + "@juggle/resize-observer": "^3.4.0", + "@rsuite/icons": "^1.3.2", + "@types/lodash": "^4.17.15", + "@types/prop-types": "^15.7.5", + "@types/react-window": "^1.8.5", + "classnames": "^2.3.1", + "date-fns": "^2.29.3", + "dom-lib": "^3.3.1", + "lodash": "^4.17.21", + "prop-types": "^15.8.1", + "react-use-set": "^1.0.0", + "react-window": "^1.8.8", + "rsuite-table": "^5.19.1", + "schema-typed": "^2.4.2" + }, + "peerDependencies": { + "react": ">=16.8.0", + "react-dom": ">=16.8.0" + } + }, + "node_modules/rsuite-table": { + "version": "5.19.1", + "resolved": "https://registry.npmjs.org/rsuite-table/-/rsuite-table-5.19.1.tgz", + "integrity": "sha512-PsG+z3GfwywDvPVEjZYVZcel0M6zOBAx2HKTgYLfct/yAzXJWPgW/eVuv9+8KmkcKzAh03UVYQdB88Gp7+RlGg==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.12.5", + "@juggle/resize-observer": "^3.3.1", + "@rsuite/icons": "^1.0.0", + "classnames": "^2.3.1", + "dom-lib": "^3.3.1", + "lodash": "^4.17.21", + "react-is": "^17.0.2" + }, + "peerDependencies": { + "prop-types": "^15.7.2", + "react": ">=16.8.0", + "react-dom": ">=16.8.0" + } + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz", + "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/rw": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/rw/-/rw-1.3.3.tgz", + "integrity": "sha512-PdhdWy89SiZogBLaw42zdeqtRJ//zFd2PgQavcICDUgJT5oW10QCRKbJ6bg4r0/UY2M6BWd5tkxuGFRvCkgfHQ==", + "license": "BSD-3-Clause" + }, + "node_modules/safe-array-concat": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.3.tgz", + "integrity": "sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.2", + "get-intrinsic": "^1.2.6", + "has-symbols": "^1.1.0", + "isarray": "^2.0.5" + }, + "engines": { + "node": ">=0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/safe-push-apply": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/safe-push-apply/-/safe-push-apply-1.0.0.tgz", + "integrity": "sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "isarray": "^2.0.5" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/safe-regex-test": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz", + "integrity": "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "is-regex": "^1.2.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "license": "MIT" + }, + "node_modules/sanitize.css": { + "version": "13.0.0", + "resolved": "https://registry.npmjs.org/sanitize.css/-/sanitize.css-13.0.0.tgz", + "integrity": "sha512-ZRwKbh/eQ6w9vmTjkuG0Ioi3HBwPFce0O+v//ve+aOq1oeCy7jMV2qzzAlpsNuqpqCBjjriM1lbtZbF/Q8jVyA==", + "license": "CC0-1.0" + }, + "node_modules/sass-loader": { + "version": "12.6.0", + "resolved": "https://registry.npmjs.org/sass-loader/-/sass-loader-12.6.0.tgz", + "integrity": "sha512-oLTaH0YCtX4cfnJZxKSLAyglED0naiYfNG1iXfU5w1LNZ+ukoA5DtyDIN5zmKVZwYNJP4KRc5Y3hkWga+7tYfA==", + "license": "MIT", + "dependencies": { + "klona": "^2.0.4", + "neo-async": "^2.6.2" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "fibers": ">= 3.1.0", + "node-sass": "^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0", + "sass": "^1.3.0", + "sass-embedded": "*", + "webpack": "^5.0.0" + }, + "peerDependenciesMeta": { + "fibers": { + "optional": true + }, + "node-sass": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + } + } + }, + "node_modules/sax": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz", + "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==", + "license": "ISC" + }, + "node_modules/saxes": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/saxes/-/saxes-5.0.1.tgz", + "integrity": "sha512-5LBh1Tls8c9xgGjw3QrMwETmTMVk0oFgvrFSvWx62llR2hcEInrKNZ2GZCCuuy2lvWrdl5jhbpeqc5hRYKFOcw==", + "license": "ISC", + "dependencies": { + "xmlchars": "^2.2.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/scheduler": { + "version": "0.23.2", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz", + "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0" + } + }, + "node_modules/schema-typed": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/schema-typed/-/schema-typed-2.4.2.tgz", + "integrity": "sha512-4eYZiheiPps+I7JEKrhm/S8OIPncXqY0lKQbvI/Agn9QMJUQ3cgfFZ2spy4Ta9Qr3xLYB3/qj4wGbsNcVwEO/w==", + "license": "MIT", + "dependencies": { + "lodash": "^4.17.21" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "@types/json-schema": "^7.0.9", + "ajv": "^8.9.0", + "ajv-formats": "^2.1.1", + "ajv-keywords": "^5.1.0" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/schema-utils/node_modules/ajv": { + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz", + "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.3", + "fast-uri": "^3.0.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/schema-utils/node_modules/ajv-keywords": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz", + "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.3" + }, + "peerDependencies": { + "ajv": "^8.8.2" + } + }, + "node_modules/schema-utils/node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", + "license": "MIT" + }, + "node_modules/select-hose": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/select-hose/-/select-hose-2.0.0.tgz", + "integrity": "sha512-mEugaLK+YfkijB4fx0e6kImuJdCIt2LxCRcbEYPqRGCs4F2ogyfZU5IAZRdjCP8JPq2AtdNoC/Dux63d9Kiryg==", + "license": "MIT" + }, + "node_modules/selfsigned": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-2.4.1.tgz", + "integrity": "sha512-th5B4L2U+eGLq1TVh7zNRGBapioSORUeymIydxgFpwww9d2qyKvtuPU2jJuHvYAwwqi2Y596QBL3eEqcPEYL8Q==", + "license": "MIT", + "dependencies": { + "@types/node-forge": "^1.3.0", + "node-forge": "^1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/semver": { + "version": "7.7.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.1.tgz", + "integrity": "sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA==", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/send": { + "version": "0.19.0", + "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz", + "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "fresh": "0.5.2", + "http-errors": "2.0.0", + "mime": "1.6.0", + "ms": "2.1.3", + "on-finished": "2.4.1", + "range-parser": "~1.2.1", + "statuses": "2.0.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/send/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/send/node_modules/debug/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, + "node_modules/send/node_modules/encodeurl": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz", + "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/serialize-javascript": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/serialize-javascript/-/serialize-javascript-6.0.2.tgz", + "integrity": "sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==", + "license": "BSD-3-Clause", + "dependencies": { + "randombytes": "^2.1.0" + } + }, + "node_modules/serve-index": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/serve-index/-/serve-index-1.9.1.tgz", + "integrity": "sha512-pXHfKNP4qujrtteMrSBb0rc8HJ9Ms/GrXwcUtUtD5s4ewDJI8bT3Cz2zTVRMKtri49pLx2e0Ya8ziP5Ya2pZZw==", + "license": "MIT", + "dependencies": { + "accepts": "~1.3.4", + "batch": "0.6.1", + "debug": "2.6.9", + "escape-html": "~1.0.3", + "http-errors": "~1.6.2", + "mime-types": "~2.1.17", + "parseurl": "~1.3.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/serve-index/node_modules/debug": { + "version": "2.6.9", + "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz", + "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/serve-index/node_modules/depd": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/depd/-/depd-1.1.2.tgz", + "integrity": "sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/serve-index/node_modules/http-errors": { + "version": "1.6.3", + "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-1.6.3.tgz", + "integrity": "sha512-lks+lVC8dgGyh97jxvxeYTWQFvh4uw4yC12gVl63Cg30sjPX4wuGcdkICVXDAESr6OJGjqGA8Iz5mkeN6zlD7A==", + "license": "MIT", + "dependencies": { + "depd": "~1.1.2", + "inherits": "2.0.3", + "setprototypeof": "1.1.0", + "statuses": ">= 1.4.0 < 2" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/serve-index/node_modules/inherits": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz", + "integrity": "sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw==", + "license": "ISC" + }, + "node_modules/serve-index/node_modules/ms": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz", + "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==", + "license": "MIT" + }, + "node_modules/serve-index/node_modules/setprototypeof": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.1.0.tgz", + "integrity": "sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ==", + "license": "ISC" + }, + "node_modules/serve-index/node_modules/statuses": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-1.5.0.tgz", + "integrity": "sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/serve-static": { + "version": "1.16.2", + "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz", + "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==", + "license": "MIT", + "dependencies": { + "encodeurl": "~2.0.0", + "escape-html": "~1.0.3", + "parseurl": "~1.3.3", + "send": "0.19.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/set-function-length": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz", + "integrity": "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==", + "license": "MIT", + "dependencies": { + "define-data-property": "^1.1.4", + "es-errors": "^1.3.0", + "function-bind": "^1.1.2", + "get-intrinsic": "^1.2.4", + "gopd": "^1.0.1", + "has-property-descriptors": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/set-function-name": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/set-function-name/-/set-function-name-2.0.2.tgz", + "integrity": "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ==", + "license": "MIT", + "dependencies": { + "define-data-property": "^1.1.4", + "es-errors": "^1.3.0", + "functions-have-names": "^1.2.3", + "has-property-descriptors": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/set-proto": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/set-proto/-/set-proto-1.0.0.tgz", + "integrity": "sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw==", + "license": "MIT", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz", + "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==", + "license": "ISC" + }, + "node_modules/shallowequal": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/shallowequal/-/shallowequal-1.1.0.tgz", + "integrity": "sha512-y0m1JoUZSlPAjXVtPPW70aZWfIL/dSP7AFkRnniLCrK/8MDKog3TySTBmckD+RObVxH0v4Tox67+F14PdED2oQ==", + "license": "MIT" + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz", + "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==", + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz", + "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "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==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz", + "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3", + "side-channel-list": "^1.0.0", + "side-channel-map": "^1.0.1", + "side-channel-weakmap": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-list": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz", + "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-map": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", + "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-weakmap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", + "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3", + "side-channel-map": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/signal-exit": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", + "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", + "license": "ISC" + }, + "node_modules/sisteransi": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz", + "integrity": "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==", + "license": "MIT" + }, + "node_modules/slash": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", + "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/sockjs": { + "version": "0.3.24", + "resolved": "https://registry.npmjs.org/sockjs/-/sockjs-0.3.24.tgz", + "integrity": "sha512-GJgLTZ7vYb/JtPSSZ10hsOYIvEYsjbNU+zPdIHcUaWVNUEPivzxku31865sSSud0Da0W4lEeOPlmw93zLQchuQ==", + "license": "MIT", + "dependencies": { + "faye-websocket": "^0.11.3", + "uuid": "^8.3.2", + "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", + "integrity": "sha512-qnQ7gVMxGNxsiL4lEuJwe/To8UnK7fAnmbGEEH8RpLouuKbeEm0lhbQVFIrNSuB+G7tVrAlVsZgETT5nljf+Iw==", + "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==", + "license": "BSD-3-Clause", + "engines": { + "node": ">= 8" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/source-map-loader": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/source-map-loader/-/source-map-loader-3.0.2.tgz", + "integrity": "sha512-BokxPoLjyl3iOrgkWaakaxqnelAJSS+0V+De0kKIq6lyWrXuiPgYTGp6z3iHmqljKAaLXwZa+ctD8GccRJeVvg==", + "license": "MIT", + "dependencies": { + "abab": "^2.0.5", + "iconv-lite": "^0.6.3", + "source-map-js": "^1.0.1" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.0.0" + } + }, + "node_modules/source-map-support": { + "version": "0.5.21", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz", + "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==", + "license": "MIT", + "dependencies": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "node_modules/source-map-support/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/sourcemap-codec": { + "version": "1.4.8", + "resolved": "https://registry.npmjs.org/sourcemap-codec/-/sourcemap-codec-1.4.8.tgz", + "integrity": "sha512-9NykojV5Uih4lgo5So5dtw+f0JgJX30KCNI8gwhz2J9A15wD0Ml6tjHKwf6fTSa6fAdVBdZeNOs9eJ71qCk8vA==", + "deprecated": "Please use @jridgewell/sourcemap-codec instead", + "license": "MIT" + }, + "node_modules/space-separated-tokens": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz", + "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/spdy": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/spdy/-/spdy-4.0.2.tgz", + "integrity": "sha512-r46gZQZQV+Kl9oItvl1JZZqJKGr+oEkB08A6BzkiR7593/7IbtuncXHd2YoYeTsG4157ZssMu9KYvUHLcjcDoA==", + "license": "MIT", + "dependencies": { + "debug": "^4.1.0", + "handle-thing": "^2.0.0", + "http-deceiver": "^1.2.7", + "select-hose": "^2.0.0", + "spdy-transport": "^3.0.0" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/spdy-transport": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/spdy-transport/-/spdy-transport-3.0.0.tgz", + "integrity": "sha512-hsLVFE5SjA6TCisWeJXFKniGGOpBgMLmerfO2aCyCU5s7nJ/rpAepqmFifv/GCbSbueEeAJJnmSQ2rKC/g8Fcw==", + "license": "MIT", + "dependencies": { + "debug": "^4.1.0", + "detect-node": "^2.0.4", + "hpack.js": "^2.1.6", + "obuf": "^1.1.2", + "readable-stream": "^3.0.6", + "wbuf": "^1.7.3" + } + }, + "node_modules/sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==", + "license": "BSD-3-Clause" + }, + "node_modules/stable": { + "version": "0.1.8", + "resolved": "https://registry.npmjs.org/stable/-/stable-0.1.8.tgz", + "integrity": "sha512-ji9qxRnOVfcuLDySj9qzhGSEFVobyt1kIOSkj1qZzYLzq7Tos/oUUWvotUPQLlrsidqsK6tBH89Bc9kL5zHA6w==", + "deprecated": "Modern JS already guarantees Array#sort() is a stable sort, so this library is deprecated. See the compatibility table on MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#browser_compatibility", + "license": "MIT" + }, + "node_modules/stack-utils": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/stack-utils/-/stack-utils-2.0.6.tgz", + "integrity": "sha512-XlkWvfIm6RmsWtNJx+uqtKLS8eqFbxUg0ZzLXqY0caEy9l7hruX8IpiDnjsLavoBgqCCR71TqWO8MaXYheJ3RQ==", + "license": "MIT", + "dependencies": { + "escape-string-regexp": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/stack-utils/node_modules/escape-string-regexp": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz", + "integrity": "sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/stackframe": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/stackframe/-/stackframe-1.3.4.tgz", + "integrity": "sha512-oeVtt7eWQS+Na6F//S4kJ2K2VbRlS9D43mAlMyVpVWovy9o+jfgH8O9agzANzaiLjclA0oYzUXEM4PurhSUChw==", + "license": "MIT" + }, + "node_modules/static-eval": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/static-eval/-/static-eval-2.0.2.tgz", + "integrity": "sha512-N/D219Hcr2bPjLxPiV+TQE++Tsmrady7TqAJugLy7Xk1EumfDWS/f5dtBbkRCGE7wKKXuYockQoj8Rm2/pVKyg==", + "license": "MIT", + "dependencies": { + "escodegen": "^1.8.1" + } + }, + "node_modules/static-eval/node_modules/escodegen": { + "version": "1.14.3", + "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.14.3.tgz", + "integrity": "sha512-qFcX0XJkdg+PB3xjZZG/wKSuT1PnQWx57+TVSjIMmILd2yC/6ByYElPwJnslDsuWuSAp4AwJGumarAAmJch5Kw==", + "license": "BSD-2-Clause", + "dependencies": { + "esprima": "^4.0.1", + "estraverse": "^4.2.0", + "esutils": "^2.0.2", + "optionator": "^0.8.1" + }, + "bin": { + "escodegen": "bin/escodegen.js", + "esgenerate": "bin/esgenerate.js" + }, + "engines": { + "node": ">=4.0" + }, + "optionalDependencies": { + "source-map": "~0.6.1" + } + }, + "node_modules/static-eval/node_modules/estraverse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", + "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/static-eval/node_modules/levn": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", + "integrity": "sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA==", + "license": "MIT", + "dependencies": { + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/static-eval/node_modules/optionator": { + "version": "0.8.3", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.3.tgz", + "integrity": "sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==", + "license": "MIT", + "dependencies": { + "deep-is": "~0.1.3", + "fast-levenshtein": "~2.0.6", + "levn": "~0.3.0", + "prelude-ls": "~1.1.2", + "type-check": "~0.3.2", + "word-wrap": "~1.2.3" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/static-eval/node_modules/prelude-ls": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz", + "integrity": "sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w==", + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/static-eval/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "license": "BSD-3-Clause", + "optional": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/static-eval/node_modules/type-check": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz", + "integrity": "sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==", + "license": "MIT", + "dependencies": { + "prelude-ls": "~1.1.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/statuses": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz", + "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==", + "license": "MIT", + "engines": { + "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==", + "dev": true, + "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", + "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "license": "MIT", + "dependencies": { + "safe-buffer": "~5.2.0" + } + }, + "node_modules/string-length": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/string-length/-/string-length-4.0.2.tgz", + "integrity": "sha512-+l6rNN5fYHNhZZy41RXsYptCjA2Igmq4EG7kZAYFQI1E1VTXarr6ZPXBg6eq7Y6eK4FEhY6AJlyuFIb/v/S0VQ==", + "license": "MIT", + "dependencies": { + "char-regex": "^1.0.2", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/string-natural-compare": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/string-natural-compare/-/string-natural-compare-3.0.1.tgz", + "integrity": "sha512-n3sPwynL1nwKi3WJ6AIsClwBMa0zTi54fn2oLU6ndfTSIO05xaznjSf15PcBZU6FNWbmN5Q6cxT4V5hGvB4taw==", + "license": "MIT" + }, + "node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/string-width-cjs": { + "name": "string-width", + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/string-width-cjs/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "license": "MIT" + }, + "node_modules/string-width/node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "license": "MIT" + }, + "node_modules/string.prototype.includes": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/string.prototype.includes/-/string.prototype.includes-2.0.1.tgz", + "integrity": "sha512-o7+c9bW6zpAdJHTtujeePODAhkuicdAryFsfVKwA+wGw89wJ4GTY484WTucM9hLtDEOpOvI+aHnzqnC5lHp4Rg==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.3" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/string.prototype.matchall": { + "version": "4.0.12", + "resolved": "https://registry.npmjs.org/string.prototype.matchall/-/string.prototype.matchall-4.0.12.tgz", + "integrity": "sha512-6CC9uyBL+/48dYizRf7H7VAYCMCNTBeM78x/VTUe9bFEaxBepPJDa1Ow99LqI/1yF7kuy7Q3cQsYMrcjGUcskA==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.6", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0", + "get-intrinsic": "^1.2.6", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "internal-slot": "^1.1.0", + "regexp.prototype.flags": "^1.5.3", + "set-function-name": "^2.0.2", + "side-channel": "^1.1.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.repeat": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/string.prototype.repeat/-/string.prototype.repeat-1.0.0.tgz", + "integrity": "sha512-0u/TldDbKD8bFCQ/4f5+mNRrXwZ8hg2w7ZR8wa16e8z9XpePWl3eGEcUD0OXpEH/VJH/2G3gjUtR3ZOiBe2S/w==", + "license": "MIT", + "dependencies": { + "define-properties": "^1.1.3", + "es-abstract": "^1.17.5" + } + }, + "node_modules/string.prototype.trim": { + "version": "1.2.10", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.10.tgz", + "integrity": "sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.2", + "define-data-property": "^1.1.4", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.5", + "es-object-atoms": "^1.0.0", + "has-property-descriptors": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trimend": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.9.tgz", + "integrity": "sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.2", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trimstart": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.8.tgz", + "integrity": "sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/stringify-entities": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz", + "integrity": "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==", + "license": "MIT", + "dependencies": { + "character-entities-html4": "^2.0.0", + "character-entities-legacy": "^3.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/stringify-object": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/stringify-object/-/stringify-object-3.3.0.tgz", + "integrity": "sha512-rHqiFh1elqCQ9WPLIC8I0Q/g/wj5J1eMkyoiD6eoQApWHP0FtlK7rqnhmabL5VUY9JQCcqwwvlOaSuutekgyrw==", + "license": "BSD-2-Clause", + "dependencies": { + "get-own-enumerable-property-symbols": "^3.0.0", + "is-obj": "^1.0.1", + "is-regexp": "^1.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi-cjs": { + "name": "strip-ansi", + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-bom": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-4.0.0.tgz", + "integrity": "sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-comments": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/strip-comments/-/strip-comments-2.0.1.tgz", + "integrity": "sha512-ZprKx+bBLXv067WTCALv8SSz5l2+XhpYCsVtSqlMnkAXMWDq+/ekVbl1ghqP9rUHTzv6sm/DwCOiYutU/yp1fw==", + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/strip-final-newline": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-2.0.0.tgz", + "integrity": "sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/strip-indent": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz", + "integrity": "sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "min-indent": "^1.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/style-loader": { + "version": "3.3.4", + "resolved": "https://registry.npmjs.org/style-loader/-/style-loader-3.3.4.tgz", + "integrity": "sha512-0WqXzrsMTyb8yjZJHDqwmnwRJvhALK9LfRtRc6B4UTWe8AijYLZYZ9thuJTZc2VfQWINADW/j+LiJnfy2RoC1w==", + "license": "MIT", + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.0.0" + } + }, + "node_modules/style-to-js": { + "version": "1.1.16", + "resolved": "https://registry.npmjs.org/style-to-js/-/style-to-js-1.1.16.tgz", + "integrity": "sha512-/Q6ld50hKYPH3d/r6nr117TZkHR0w0kGGIVfpG9N6D8NymRPM9RqCUv4pRpJ62E5DqOYx2AFpbZMyCPnjQCnOw==", + "license": "MIT", + "dependencies": { + "style-to-object": "1.0.8" + } + }, + "node_modules/style-to-object": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-1.0.8.tgz", + "integrity": "sha512-xT47I/Eo0rwJmaXC4oilDGDWLohVhR6o/xAQcPQN8q6QBuZVL8qMYL85kLmST5cPjAorwvqIA4qXTRQoYHaL6g==", + "license": "MIT", + "dependencies": { + "inline-style-parser": "0.2.4" + } + }, + "node_modules/styled-components": { + "version": "6.1.17", + "resolved": "https://registry.npmjs.org/styled-components/-/styled-components-6.1.17.tgz", + "integrity": "sha512-97D7DwWanI7nN24v0D4SvbfjLE9656umNSJZkBkDIWL37aZqG/wRQ+Y9pWtXyBIM/NSfcBzHLErEsqHmJNSVUg==", + "license": "MIT", + "dependencies": { + "@emotion/is-prop-valid": "1.2.2", + "@emotion/unitless": "0.8.1", + "@types/stylis": "4.2.5", + "css-to-react-native": "3.2.0", + "csstype": "3.1.3", + "postcss": "8.4.49", + "shallowequal": "1.1.0", + "stylis": "4.3.2", + "tslib": "2.6.2" + }, + "engines": { + "node": ">= 16" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/styled-components" + }, + "peerDependencies": { + "react": ">= 16.8.0", + "react-dom": ">= 16.8.0" + } + }, + "node_modules/styled-components/node_modules/postcss": { + "version": "8.4.49", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.49.tgz", + "integrity": "sha512-OCVPnIObs4N29kxTjzLfUryOkvZEq+pf8jTF0lg8E7uETuWHA+v7j3c/xJmiqpX450191LlmZfUKkXxkTry7nA==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.7", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/styled-components/node_modules/stylis": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/stylis/-/stylis-4.3.2.tgz", + "integrity": "sha512-bhtUjWd/z6ltJiQwg0dUfxEJ+W+jdqQd8TbWLWyeIJHlnsqmGLRFFd8e5mA0AZi/zx90smXRlN66YMTcaSFifg==", + "license": "MIT" + }, + "node_modules/styled-components/node_modules/tslib": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz", + "integrity": "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==", + "license": "0BSD" + }, + "node_modules/stylehacks": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/stylehacks/-/stylehacks-5.1.1.tgz", + "integrity": "sha512-sBpcd5Hx7G6seo7b1LkpttvTz7ikD0LlH5RmdcBNb6fFR0Fl7LQwHDFr300q4cwUqi+IYrFGmsIHieMBfnN/Bw==", + "license": "MIT", + "dependencies": { + "browserslist": "^4.21.4", + "postcss-selector-parser": "^6.0.4" + }, + "engines": { + "node": "^10 || ^12 || >=14.0" + }, + "peerDependencies": { + "postcss": "^8.2.15" + } + }, + "node_modules/stylis": { + "version": "4.3.6", + "resolved": "https://registry.npmjs.org/stylis/-/stylis-4.3.6.tgz", + "integrity": "sha512-yQ3rwFWRfwNUY7H5vpU0wfdkNSnvnJinhF9830Swlaxl03zsOjCfmX0ugac+3LtK0lYSgwL/KXc8oYL3mG4YFQ==", + "license": "MIT" + }, + "node_modules/sucrase": { + "version": "3.35.0", + "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.0.tgz", + "integrity": "sha512-8EbVDiu9iN/nESwxeSxDKe0dunta1GOlHufmSSXxMD2z2/tMZpDMpvXQGsc+ajGo8y2uYUmixaSRUc/QPoQ0GA==", + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.2", + "commander": "^4.0.0", + "glob": "^10.3.10", + "lines-and-columns": "^1.1.6", + "mz": "^2.7.0", + "pirates": "^4.0.1", + "ts-interface-checker": "^0.1.9" + }, + "bin": { + "sucrase": "bin/sucrase", + "sucrase-node": "bin/sucrase-node" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + } + }, + "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==", + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0" + } + }, + "node_modules/sucrase/node_modules/commander": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz", + "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==", + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/sucrase/node_modules/glob": { + "version": "10.4.5", + "resolved": "https://registry.npmjs.org/glob/-/glob-10.4.5.tgz", + "integrity": "sha512-7Bv8RF0k6xjo7d4A/PxYLbUCfb6c+Vpd2/mB2yRDlew7Jb5hEXiCD9ibfO7wpk8i4sevK6DFny9h7EYbM3/sHg==", + "license": "ISC", + "dependencies": { + "foreground-child": "^3.1.0", + "jackspeak": "^3.1.2", + "minimatch": "^9.0.4", + "minipass": "^7.1.2", + "package-json-from-dist": "^1.0.0", + "path-scurry": "^1.11.1" + }, + "bin": { + "glob": "dist/esm/bin.mjs" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/sucrase/node_modules/minimatch": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz", + "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==", + "license": "ISC", + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "engines": { + "node": ">=16 || 14 >=14.17" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/supports-hyperlinks": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/supports-hyperlinks/-/supports-hyperlinks-2.3.0.tgz", + "integrity": "sha512-RpsAZlpWcDwOPQA22aCH4J0t7L8JmAvsCxfOSEwm7cQs3LshN36QaTkwd70DnBOXDWGssw2eUoc8CaRWT0XunA==", + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0", + "supports-color": "^7.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/svg-parser": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/svg-parser/-/svg-parser-2.0.4.tgz", + "integrity": "sha512-e4hG1hRwoOdRb37cIMSgzNsxyzKfayW6VOflrwvR+/bzrkyxY/31WkbgnQpgtrNp1SdpJvpUAGTa/ZoiPNDuRQ==", + "license": "MIT" + }, + "node_modules/svgo": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/svgo/-/svgo-1.3.2.tgz", + "integrity": "sha512-yhy/sQYxR5BkC98CY7o31VGsg014AKLEPxdfhora76l36hD9Rdy5NZA/Ocn6yayNPgSamYdtX2rFJdcv07AYVw==", + "deprecated": "This SVGO version is no longer supported. Upgrade to v2.x.x.", + "license": "MIT", + "dependencies": { + "chalk": "^2.4.1", + "coa": "^2.0.2", + "css-select": "^2.0.0", + "css-select-base-adapter": "^0.1.1", + "css-tree": "1.0.0-alpha.37", + "csso": "^4.0.2", + "js-yaml": "^3.13.1", + "mkdirp": "~0.5.1", + "object.values": "^1.1.0", + "sax": "~1.2.4", + "stable": "^0.1.8", + "unquote": "~1.1.1", + "util.promisify": "~1.0.0" + }, + "bin": { + "svgo": "bin/svgo" + }, + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/svgo/node_modules/ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "license": "MIT", + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/svgo/node_modules/chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/svgo/node_modules/color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "license": "MIT", + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/svgo/node_modules/color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "license": "MIT" + }, + "node_modules/svgo/node_modules/css-select": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-2.1.0.tgz", + "integrity": "sha512-Dqk7LQKpwLoH3VovzZnkzegqNSuAziQyNZUcrdDM401iY+R5NkGBXGmtO05/yaXQziALuPogeG0b7UAgjnTJTQ==", + "license": "BSD-2-Clause", + "dependencies": { + "boolbase": "^1.0.0", + "css-what": "^3.2.1", + "domutils": "^1.7.0", + "nth-check": "^1.0.2" + } + }, + "node_modules/svgo/node_modules/css-what": { + "version": "3.4.2", + "resolved": "https://registry.npmjs.org/css-what/-/css-what-3.4.2.tgz", + "integrity": "sha512-ACUm3L0/jiZTqfzRM3Hi9Q8eZqd6IK37mMWPLz9PJxkLWllYeRf+EHUSHYEtFop2Eqytaq1FizFVh7XfBnXCDQ==", + "license": "BSD-2-Clause", + "engines": { + "node": ">= 6" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/svgo/node_modules/dom-serializer": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-0.2.2.tgz", + "integrity": "sha512-2/xPb3ORsQ42nHYiSunXkDjPLBaEj/xTwUO4B7XCZQTRk7EBtTOPaygh10YAAh2OI1Qrp6NWfpAhzswj0ydt9g==", + "license": "MIT", + "dependencies": { + "domelementtype": "^2.0.1", + "entities": "^2.0.0" + } + }, + "node_modules/svgo/node_modules/domutils": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-1.7.0.tgz", + "integrity": "sha512-Lgd2XcJ/NjEw+7tFvfKxOzCYKZsdct5lczQ2ZaQY8Djz7pfAD3Gbp8ySJWtreII/vDlMVmxwa6pHmdxIYgttDg==", + "license": "BSD-2-Clause", + "dependencies": { + "dom-serializer": "0", + "domelementtype": "1" + } + }, + "node_modules/svgo/node_modules/domutils/node_modules/domelementtype": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-1.3.1.tgz", + "integrity": "sha512-BSKB+TSpMpFI/HOxCNr1O8aMOTZ8hT3pM3GQ0w/mWRmkhEDSFJkkyzz4XQsBV44BChwGkrDfMyjVD0eA2aFV3w==", + "license": "BSD-2-Clause" + }, + "node_modules/svgo/node_modules/escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "license": "MIT", + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/svgo/node_modules/has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/svgo/node_modules/nth-check": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-1.0.2.tgz", + "integrity": "sha512-WeBOdju8SnzPN5vTUJYxYUxLeXpCaVP5i5e0LF8fg7WORF2Wd7wFX/pk0tYZk7s8T+J7VLy0Da6J1+wCT0AtHg==", + "license": "BSD-2-Clause", + "dependencies": { + "boolbase": "~1.0.0" + } + }, + "node_modules/svgo/node_modules/supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "license": "MIT", + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/symbol-tree": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz", + "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==", + "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==", + "license": "MIT", + "dependencies": { + "@alloc/quick-lru": "^5.2.0", + "arg": "^5.0.2", + "chokidar": "^3.6.0", + "didyoumean": "^1.2.2", + "dlv": "^1.1.3", + "fast-glob": "^3.3.2", + "glob-parent": "^6.0.2", + "is-glob": "^4.0.3", + "jiti": "^1.21.6", + "lilconfig": "^3.1.3", + "micromatch": "^4.0.8", + "normalize-path": "^3.0.0", + "object-hash": "^3.0.0", + "picocolors": "^1.1.1", + "postcss": "^8.4.47", + "postcss-import": "^15.1.0", + "postcss-js": "^4.0.1", + "postcss-load-config": "^4.0.2", + "postcss-nested": "^6.2.0", + "postcss-selector-parser": "^6.1.2", + "resolve": "^1.22.8", + "sucrase": "^3.35.0" + }, + "bin": { + "tailwind": "lib/cli.js", + "tailwindcss": "lib/cli.js" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/tailwindcss/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/tapable": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.2.1.tgz", + "integrity": "sha512-GNzQvQTOIP6RyTfE2Qxb8ZVlNmw0n88vp1szwWRimP02mnTsx3Wtn5qRdqY9w2XduFNUgvOwhNnQsjwCp+kqaQ==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/temp-dir": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/temp-dir/-/temp-dir-2.0.0.tgz", + "integrity": "sha512-aoBAniQmmwtcKp/7BzsH8Cxzv8OL736p7v1ihGb5e9DJ9kTwGWHrQrVB5+lfVDzfGrdRzXch+ig7LHaY1JTOrg==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/tempy": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tempy/-/tempy-0.6.0.tgz", + "integrity": "sha512-G13vtMYPT/J8A4X2SjdtBTphZlrp1gKv6hZiOjw14RCWg6GbHuQBGtjlx75xLbYV/wEc0D7G5K4rxKP/cXk8Bw==", + "license": "MIT", + "dependencies": { + "is-stream": "^2.0.0", + "temp-dir": "^2.0.0", + "type-fest": "^0.16.0", + "unique-string": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/tempy/node_modules/type-fest": { + "version": "0.16.0", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.16.0.tgz", + "integrity": "sha512-eaBzG6MxNzEn9kiwvtre90cXaNLkmadMWa1zQMs3XORCXNbsH/OewwbxC5ia9dCxIxnTAsSxXJaa/p5y8DlvJg==", + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/terminal-link": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/terminal-link/-/terminal-link-2.1.1.tgz", + "integrity": "sha512-un0FmiRUQNr5PJqy9kP7c40F5BOfpGlYTrxonDChEZB7pzZxRNp/bt+ymiy9/npwXya9KH99nJ/GXFIiUkYGFQ==", + "license": "MIT", + "dependencies": { + "ansi-escapes": "^4.2.1", + "supports-hyperlinks": "^2.0.0" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/terser": { + "version": "5.39.0", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.39.0.tgz", + "integrity": "sha512-LBAhFyLho16harJoWMg/nZsQYgTrg5jXOn2nCYjRUcZZEdE3qa2zb8QEDRUGVZBW4rlazf2fxkg8tztybTaqWw==", + "license": "BSD-2-Clause", + "dependencies": { + "@jridgewell/source-map": "^0.3.3", + "acorn": "^8.8.2", + "commander": "^2.20.0", + "source-map-support": "~0.5.20" + }, + "bin": { + "terser": "bin/terser" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/terser-webpack-plugin": { + "version": "5.3.14", + "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.14.tgz", + "integrity": "sha512-vkZjpUjb6OMS7dhV+tILUW6BhpDR7P2L/aQSAv+Uwk+m8KATX9EccViHTJR2qDtACKPIYndLGCyl3FMo+r2LMw==", + "license": "MIT", + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.25", + "jest-worker": "^27.4.5", + "schema-utils": "^4.3.0", + "serialize-javascript": "^6.0.2", + "terser": "^5.31.1" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.1.0" + }, + "peerDependenciesMeta": { + "@swc/core": { + "optional": true + }, + "esbuild": { + "optional": true + }, + "uglify-js": { + "optional": true + } + } + }, + "node_modules/terser/node_modules/commander": { + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", + "license": "MIT" + }, + "node_modules/test-exclude": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-6.0.0.tgz", + "integrity": "sha512-cAGWPIyOHU6zlmg88jwm7VRyXnMN7iV68OGAbYDk/Mh/xC/pzVPlQtY6ngoIH/5/tciuhGfvESU8GrHrcxD56w==", + "license": "ISC", + "dependencies": { + "@istanbuljs/schema": "^0.1.2", + "glob": "^7.1.4", + "minimatch": "^3.0.4" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/text-table": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz", + "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==", + "license": "MIT" + }, + "node_modules/thenify": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz", + "integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==", + "license": "MIT", + "dependencies": { + "any-promise": "^1.0.0" + } + }, + "node_modules/thenify-all": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz", + "integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==", + "license": "MIT", + "dependencies": { + "thenify": ">= 3.1.0 < 4" + }, + "engines": { + "node": ">=0.8" + } + }, + "node_modules/throat": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/throat/-/throat-6.0.2.tgz", + "integrity": "sha512-WKexMoJj3vEuK0yFEapj8y64V0A6xcuPuK9Gt1d0R+dzCSJc0lHqQytAbSB4cDAK0dWh4T0E2ETkoLE2WZ41OQ==", + "license": "MIT" + }, + "node_modules/thunky": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/thunky/-/thunky-1.1.0.tgz", + "integrity": "sha512-eHY7nBftgThBqOyHGVN+l8gF0BucP09fMo0oO/Lb0w1OF80dJv+lDVpXG60WMQvkcxAkNybKsrEIE3ZtKGmPrA==", + "license": "MIT" + }, + "node_modules/tinyexec": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz", + "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==", + "license": "MIT" + }, + "node_modules/tmpl": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/tmpl/-/tmpl-1.0.5.tgz", + "integrity": "sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==", + "license": "BSD-3-Clause" + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "license": "MIT", + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/toidentifier": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz", + "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==", + "license": "MIT", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/tough-cookie": { + "version": "4.1.4", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-4.1.4.tgz", + "integrity": "sha512-Loo5UUvLD9ScZ6jh8beX1T6sO1w2/MpCRpEP7V280GKMVUQ0Jzar2U3UJPsrdbziLEMMhu3Ujnq//rhiFuIeag==", + "license": "BSD-3-Clause", + "dependencies": { + "psl": "^1.1.33", + "punycode": "^2.1.1", + "universalify": "^0.2.0", + "url-parse": "^1.5.3" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/tough-cookie/node_modules/universalify": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.2.0.tgz", + "integrity": "sha512-CJ1QgKmNg3CwvAv/kOFmtnEN05f0D/cn9QntgNOQlQF9dgvVTHj3t+8JPdjqawCHk7V/KA+fbUqzZ9XWhcqPUg==", + "license": "MIT", + "engines": { + "node": ">= 4.0.0" + } + }, + "node_modules/tr46": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-2.1.0.tgz", + "integrity": "sha512-15Ih7phfcdP5YxqiB+iDtLoaTz4Nd35+IiAv0kQ5FNKHzXgdWqPoTIqEDDJmXceQt4JZk6lVPT8lnDlPpGDppw==", + "license": "MIT", + "dependencies": { + "punycode": "^2.1.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/trim-lines": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz", + "integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/trough": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/trough/-/trough-2.2.0.tgz", + "integrity": "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/tryer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/tryer/-/tryer-1.0.1.tgz", + "integrity": "sha512-c3zayb8/kWWpycWYg87P71E1S1ZL6b6IJxfb5fvsUgsf0S2MVGaDhDXXjDMpdCpfWXqptc+4mXwmiy1ypXqRAA==", + "license": "MIT" + }, + "node_modules/ts-dedent": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/ts-dedent/-/ts-dedent-2.2.0.tgz", + "integrity": "sha512-q5W7tVM71e2xjHZTlgfTDoPF/SmqKG5hddq9SzR49CH2hayqRKJtQ4mtRlSxKaJlR/+9rEM+mnBHf7I2/BQcpQ==", + "license": "MIT", + "engines": { + "node": ">=6.10" + } + }, + "node_modules/ts-interface-checker": { + "version": "0.1.13", + "resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz", + "integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==", + "license": "Apache-2.0" + }, + "node_modules/tsconfig-paths": { + "version": "3.15.0", + "resolved": "https://registry.npmjs.org/tsconfig-paths/-/tsconfig-paths-3.15.0.tgz", + "integrity": "sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg==", + "license": "MIT", + "dependencies": { + "@types/json5": "^0.0.29", + "json5": "^1.0.2", + "minimist": "^1.2.6", + "strip-bom": "^3.0.0" + } + }, + "node_modules/tsconfig-paths/node_modules/json5": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz", + "integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==", + "license": "MIT", + "dependencies": { + "minimist": "^1.2.0" + }, + "bin": { + "json5": "lib/cli.js" + } + }, + "node_modules/tsconfig-paths/node_modules/strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/tslib": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", + "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "license": "0BSD" + }, + "node_modules/tsutils": { + "version": "3.21.0", + "resolved": "https://registry.npmjs.org/tsutils/-/tsutils-3.21.0.tgz", + "integrity": "sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==", + "license": "MIT", + "dependencies": { + "tslib": "^1.8.1" + }, + "engines": { + "node": ">= 6" + }, + "peerDependencies": { + "typescript": ">=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta" + } + }, + "node_modules/tsutils/node_modules/tslib": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz", + "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==", + "license": "0BSD" + }, + "node_modules/type-check": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz", + "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==", + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/type-detect": { + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz", + "integrity": "sha512-0fr/mIH1dlO+x7TlcMy+bIDqKPsw/70tVyeHW787goQjhmqaZe10uwLujubK9q9Lg6Fiho1KUKDYz0Z7k7g5/g==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/type-fest": { + "version": "0.21.3", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz", + "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==", + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/type-is": { + "version": "1.6.18", + "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz", + "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==", + "license": "MIT", + "dependencies": { + "media-typer": "0.3.0", + "mime-types": "~2.1.24" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/typed-array-buffer": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/typed-array-buffer/-/typed-array-buffer-1.0.3.tgz", + "integrity": "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "es-errors": "^1.3.0", + "is-typed-array": "^1.1.14" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/typed-array-byte-length": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.3.tgz", + "integrity": "sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.8", + "for-each": "^0.3.3", + "gopd": "^1.2.0", + "has-proto": "^1.2.0", + "is-typed-array": "^1.1.14" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/typed-array-byte-offset": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/typed-array-byte-offset/-/typed-array-byte-offset-1.0.4.tgz", + "integrity": "sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ==", + "license": "MIT", + "dependencies": { + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.8", + "for-each": "^0.3.3", + "gopd": "^1.2.0", + "has-proto": "^1.2.0", + "is-typed-array": "^1.1.15", + "reflect.getprototypeof": "^1.0.9" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/typed-array-length": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/typed-array-length/-/typed-array-length-1.0.7.tgz", + "integrity": "sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg==", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "is-typed-array": "^1.1.13", + "possible-typed-array-names": "^1.0.0", + "reflect.getprototypeof": "^1.0.6" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/typedarray-to-buffer": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/typedarray-to-buffer/-/typedarray-to-buffer-3.1.5.tgz", + "integrity": "sha512-zdu8XMNEDepKKR+XYOXAVPtWui0ly0NtohUscw+UmaHiAWT8hrV1rr//H6V+0DvJ3OQ19S979M0laLfX8rm82Q==", + "license": "MIT", + "dependencies": { + "is-typedarray": "^1.0.0" + } + }, + "node_modules/typescript": { + "version": "5.8.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz", + "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==", + "license": "Apache-2.0", + "peer": true, + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/ufo": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/ufo/-/ufo-1.6.1.tgz", + "integrity": "sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA==", + "license": "MIT" + }, + "node_modules/unbox-primitive": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.1.0.tgz", + "integrity": "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.3", + "has-bigints": "^1.0.2", + "has-symbols": "^1.1.0", + "which-boxed-primitive": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/underscore": { + "version": "1.12.1", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.12.1.tgz", + "integrity": "sha512-hEQt0+ZLDVUMhebKxL4x1BTtDY7bavVofhZ9KZ4aI26X9SRaE+Y3m83XUL1UP2jn8ynjndwCCpEHdUG+9pP1Tw==", + "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==", + "license": "MIT" + }, + "node_modules/unicode-canonical-property-names-ecmascript": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-2.0.1.tgz", + "integrity": "sha512-dA8WbNeb2a6oQzAQ55YlT5vQAWGV9WXOsi3SskE3bcCdM0P4SDd+24zS/OCacdRq5BkdsRj9q3Pg6YyQoxIGqg==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/unicode-match-property-ecmascript": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-2.0.0.tgz", + "integrity": "sha512-5kaZCrbp5mmbz5ulBkDkbY0SsPOjKqVS35VpL9ulMPfSl0J0Xsm+9Evphv9CoIZFwre7aJoa94AY6seMKGVN5Q==", + "license": "MIT", + "dependencies": { + "unicode-canonical-property-names-ecmascript": "^2.0.0", + "unicode-property-aliases-ecmascript": "^2.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "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==", + "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==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/unified": { + "version": "11.0.5", + "resolved": "https://registry.npmjs.org/unified/-/unified-11.0.5.tgz", + "integrity": "sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "bail": "^2.0.0", + "devlop": "^1.0.0", + "extend": "^3.0.0", + "is-plain-obj": "^4.0.0", + "trough": "^2.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unique-string": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/unique-string/-/unique-string-2.0.0.tgz", + "integrity": "sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==", + "license": "MIT", + "dependencies": { + "crypto-random-string": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/unist-util-is": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.0.tgz", + "integrity": "sha512-2qCTHimwdxLfz+YzdGfkqNlH0tLi9xjTnHddPmJwtIG9MGsdbutfTc4P+haPD7l7Cjxf/WZj+we5qfVPvvxfYw==", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-position": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz", + "integrity": "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-stringify-position": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz", + "integrity": "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-visit": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.0.0.tgz", + "integrity": "sha512-MR04uvD+07cwl/yhVuVWAtw+3GOR/knlL55Nd/wAdblk27GCVt3lqpTivy/tkJcZoNPzTwS1Y+KMojlLDhoTzg==", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-is": "^6.0.0", + "unist-util-visit-parents": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-visit-parents": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.1.tgz", + "integrity": "sha512-L/PqWzfTP9lzzEa6CKs0k2nARxTdZduw3zyh8d2NVBnsyvHjSX4TWse388YrrQKbvI8w20fGjGlhgT96WwKykw==", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-is": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/unpipe": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz", + "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/unquote": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/unquote/-/unquote-1.1.1.tgz", + "integrity": "sha512-vRCqFv6UhXpWxZPyGDh/F3ZpNv8/qo7w6iufLpQg9aKnQ71qM4B5KiI7Mia9COcjEhrO9LueHpMYjYzsWH3OIg==", + "license": "MIT" + }, + "node_modules/upath": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/upath/-/upath-1.2.0.tgz", + "integrity": "sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==", + "license": "MIT", + "engines": { + "node": ">=4", + "yarn": "*" + } + }, + "node_modules/update-browserslist-db": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.3.tgz", + "integrity": "sha512-UxhIZQ+QInVdunkDAaiazvvT/+fXL5Osr0JZlJulepYu6Jd7qJtDZjlur0emRlT71EN3ScPoE7gvsuIKKNavKw==", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "escalade": "^3.2.0", + "picocolors": "^1.1.1" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "license": "BSD-2-Clause", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/url-parse": { + "version": "1.5.10", + "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.10.tgz", + "integrity": "sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==", + "license": "MIT", + "dependencies": { + "querystringify": "^2.1.1", + "requires-port": "^1.0.0" + } + }, + "node_modules/util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", + "license": "MIT" + }, + "node_modules/util.promisify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/util.promisify/-/util.promisify-1.0.1.tgz", + "integrity": "sha512-g9JpC/3He3bm38zsLupWryXHoEcS22YHthuPQSJdMy6KNrzIRzWqcsHzD/WUnqe45whVou4VIsPew37DoXWNrA==", + "license": "MIT", + "dependencies": { + "define-properties": "^1.1.3", + "es-abstract": "^1.17.2", + "has-symbols": "^1.0.1", + "object.getownpropertydescriptors": "^2.1.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/utila": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/utila/-/utila-0.4.0.tgz", + "integrity": "sha512-Z0DbgELS9/L/75wZbro8xAnT50pBVFQZ+hUEueGDU5FN51YSCYM+jdxsfCiHjwNP/4LCDD0i/graKpeBnOXKRA==", + "license": "MIT" + }, + "node_modules/utils-merge": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz", + "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==", + "license": "MIT", + "engines": { + "node": ">= 0.4.0" + } + }, + "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/v8-to-istanbul": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/v8-to-istanbul/-/v8-to-istanbul-8.1.1.tgz", + "integrity": "sha512-FGtKtv3xIpR6BYhvgH8MI/y78oT7d8Au3ww4QIxymrCtZEh5b8gCw2siywE+puhEmuWKDtmfrvF5UlB298ut3w==", + "license": "ISC", + "dependencies": { + "@types/istanbul-lib-coverage": "^2.0.1", + "convert-source-map": "^1.6.0", + "source-map": "^0.7.3" + }, + "engines": { + "node": ">=10.12.0" + } + }, + "node_modules/v8-to-istanbul/node_modules/convert-source-map": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", + "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==", + "license": "MIT" + }, + "node_modules/vary": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz", + "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/vfile": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz", + "integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "vfile-message": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vfile-message": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.2.tgz", + "integrity": "sha512-jRDZ1IMLttGj41KcZvlrYAaI3CfqpLpfpf+Mfig13viT6NKvRzWZ+lXz0Y5D60w6uJIBAOGq9mSHf0gktF0duw==", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-stringify-position": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vscode-jsonrpc": { + "version": "8.2.0", + "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-8.2.0.tgz", + "integrity": "sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA==", + "license": "MIT", + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/vscode-languageserver": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/vscode-languageserver/-/vscode-languageserver-9.0.1.tgz", + "integrity": "sha512-woByF3PDpkHFUreUa7Hos7+pUWdeWMXRd26+ZX2A8cFx6v/JPTtd4/uN0/jB6XQHYaOlHbio03NTHCqrgG5n7g==", + "license": "MIT", + "dependencies": { + "vscode-languageserver-protocol": "3.17.5" + }, + "bin": { + "installServerIntoExtension": "bin/installServerIntoExtension" + } + }, + "node_modules/vscode-languageserver-protocol": { + "version": "3.17.5", + "resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.17.5.tgz", + "integrity": "sha512-mb1bvRJN8SVznADSGWM9u/b07H7Ecg0I3OgXDuLdn307rl/J3A9YD6/eYOssqhecL27hK1IPZAsaqh00i/Jljg==", + "license": "MIT", + "dependencies": { + "vscode-jsonrpc": "8.2.0", + "vscode-languageserver-types": "3.17.5" + } + }, + "node_modules/vscode-languageserver-textdocument": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.12.tgz", + "integrity": "sha512-cxWNPesCnQCcMPeenjKKsOCKQZ/L6Tv19DTRIGuLWe32lyzWhihGVJ/rcckZXJxfdKCFvRLS3fpBIsV/ZGX4zA==", + "license": "MIT" + }, + "node_modules/vscode-languageserver-types": { + "version": "3.17.5", + "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.17.5.tgz", + "integrity": "sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg==", + "license": "MIT" + }, + "node_modules/vscode-uri": { + "version": "3.0.8", + "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-3.0.8.tgz", + "integrity": "sha512-AyFQ0EVmsOZOlAnxoFOGOq1SQDWAB7C6aqMGS23svWAllfOaxbuFvcT8D1i8z3Gyn8fraVeZNNmN6e9bxxXkKw==", + "license": "MIT" + }, + "node_modules/w3c-hr-time": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/w3c-hr-time/-/w3c-hr-time-1.0.2.tgz", + "integrity": "sha512-z8P5DvDNjKDoFIHK7q8r8lackT6l+jo/Ye3HOle7l9nICP9lf1Ci25fy9vHd0JOWewkIFzXIEig3TdKT7JQ5fQ==", + "deprecated": "Use your platform's native performance.now() and performance.timeOrigin.", + "license": "MIT", + "dependencies": { + "browser-process-hrtime": "^1.0.0" + } + }, + "node_modules/w3c-xmlserializer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-2.0.0.tgz", + "integrity": "sha512-4tzD0mF8iSiMiNs30BiLO3EpfGLZUT2MSX/G+o7ZywDzliWQ3OPtTZ0PTC3B3ca1UAf4cJMHB+2Bf56EriJuRA==", + "license": "MIT", + "dependencies": { + "xml-name-validator": "^3.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/walker": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/walker/-/walker-1.0.8.tgz", + "integrity": "sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==", + "license": "Apache-2.0", + "dependencies": { + "makeerror": "1.0.12" + } + }, + "node_modules/watchpack": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.4.2.tgz", + "integrity": "sha512-TnbFSbcOCcDgjZ4piURLCbJ3nJhznVh9kw6F6iokjiFPl8ONxe9A6nMDVXDiNbrSfLILs6vB07F7wLBrwPYzJw==", + "license": "MIT", + "dependencies": { + "glob-to-regexp": "^0.4.1", + "graceful-fs": "^4.1.2" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/wbuf": { + "version": "1.7.3", + "resolved": "https://registry.npmjs.org/wbuf/-/wbuf-1.7.3.tgz", + "integrity": "sha512-O84QOnr0icsbFGLS0O3bI5FswxzRr8/gHwWkDlQFskhSPryQXvrTMxjxGP4+iWYoauLoBvfDpkrOauZ+0iZpDA==", + "license": "MIT", + "dependencies": { + "minimalistic-assert": "^1.0.0" + } + }, + "node_modules/web-vitals": { + "version": "2.1.4", + "resolved": "https://registry.npmjs.org/web-vitals/-/web-vitals-2.1.4.tgz", + "integrity": "sha512-sVWcwhU5mX6crfI5Vd2dC4qchyTqxV8URinzt25XqVh+bHEPGH4C3NPrNionCP7Obx59wrYEbNlw4Z8sjALzZg==", + "license": "Apache-2.0" + }, + "node_modules/webidl-conversions": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-6.1.0.tgz", + "integrity": "sha512-qBIvFLGiBpLjfwmYAaHPXsn+ho5xZnGvyGvsarywGNc8VyQJUMHJ8OBKGGrPER0okBeMDaan4mNBlgBROxuI8w==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=10.4" + } + }, + "node_modules/webpack": { + "version": "5.99.7", + "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.99.7.tgz", + "integrity": "sha512-CNqKBRMQjwcmKR0idID5va1qlhrqVUKpovi+Ec79ksW8ux7iS1+A6VqzfZXgVYCFRKl7XL5ap3ZoMpwBJxcg0w==", + "license": "MIT", + "dependencies": { + "@types/eslint-scope": "^3.7.7", + "@types/estree": "^1.0.6", + "@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", + "chrome-trace-event": "^1.0.2", + "enhanced-resolve": "^5.17.1", + "es-module-lexer": "^1.2.1", + "eslint-scope": "5.1.1", + "events": "^3.2.0", + "glob-to-regexp": "^0.4.1", + "graceful-fs": "^4.2.11", + "json-parse-even-better-errors": "^2.3.1", + "loader-runner": "^4.2.0", + "mime-types": "^2.1.27", + "neo-async": "^2.6.2", + "schema-utils": "^4.3.2", + "tapable": "^2.1.1", + "terser-webpack-plugin": "^5.3.11", + "watchpack": "^2.4.1", + "webpack-sources": "^3.2.3" + }, + "bin": { + "webpack": "bin/webpack.js" + }, + "engines": { + "node": ">=10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependenciesMeta": { + "webpack-cli": { + "optional": true + } + } + }, + "node_modules/webpack-dev-middleware": { + "version": "5.3.4", + "resolved": "https://registry.npmjs.org/webpack-dev-middleware/-/webpack-dev-middleware-5.3.4.tgz", + "integrity": "sha512-BVdTqhhs+0IfoeAf7EoH5WE+exCmqGerHfDM0IL096Px60Tq2Mn9MAbnaGUe6HiMa41KMCYF19gyzZmBcq/o4Q==", + "license": "MIT", + "dependencies": { + "colorette": "^2.0.10", + "memfs": "^3.4.3", + "mime-types": "^2.1.31", + "range-parser": "^1.2.1", + "schema-utils": "^4.0.0" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^4.0.0 || ^5.0.0" + } + }, + "node_modules/webpack-dev-server": { + "version": "4.15.2", + "resolved": "https://registry.npmjs.org/webpack-dev-server/-/webpack-dev-server-4.15.2.tgz", + "integrity": "sha512-0XavAZbNJ5sDrCbkpWL8mia0o5WPOd2YGtxrEiZkBK9FjLppIUK2TgxK6qGD2P3hUXTJNNPVibrerKcx5WkR1g==", + "license": "MIT", + "dependencies": { + "@types/bonjour": "^3.5.9", + "@types/connect-history-api-fallback": "^1.3.5", + "@types/express": "^4.17.13", + "@types/serve-index": "^1.9.1", + "@types/serve-static": "^1.13.10", + "@types/sockjs": "^0.3.33", + "@types/ws": "^8.5.5", + "ansi-html-community": "^0.0.8", + "bonjour-service": "^1.0.11", + "chokidar": "^3.5.3", + "colorette": "^2.0.10", + "compression": "^1.7.4", + "connect-history-api-fallback": "^2.0.0", + "default-gateway": "^6.0.3", + "express": "^4.17.3", + "graceful-fs": "^4.2.6", + "html-entities": "^2.3.2", + "http-proxy-middleware": "^2.0.3", + "ipaddr.js": "^2.0.1", + "launch-editor": "^2.6.0", + "open": "^8.0.9", + "p-retry": "^4.5.0", + "rimraf": "^3.0.2", + "schema-utils": "^4.0.0", + "selfsigned": "^2.1.1", + "serve-index": "^1.9.1", + "sockjs": "^0.3.24", + "spdy": "^4.0.2", + "webpack-dev-middleware": "^5.3.4", + "ws": "^8.13.0" + }, + "bin": { + "webpack-dev-server": "bin/webpack-dev-server.js" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^4.37.0 || ^5.0.0" + }, + "peerDependenciesMeta": { + "webpack": { + "optional": true + }, + "webpack-cli": { + "optional": true + } + } + }, + "node_modules/webpack-dev-server/node_modules/ws": { + "version": "8.18.1", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.1.tgz", + "integrity": "sha512-RKW2aJZMXeMxVpnZ6bck+RswznaxmzdULiBr6KY7XkTnW8uvt0iT9H5DkHUChXrc+uurzwa0rVI16n/Xzjdz1w==", + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/webpack-manifest-plugin": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/webpack-manifest-plugin/-/webpack-manifest-plugin-4.1.1.tgz", + "integrity": "sha512-YXUAwxtfKIJIKkhg03MKuiFAD72PlrqCiwdwO4VEXdRO5V0ORCNwaOwAZawPZalCbmH9kBDmXnNeQOw+BIEiow==", + "license": "MIT", + "dependencies": { + "tapable": "^2.0.0", + "webpack-sources": "^2.2.0" + }, + "engines": { + "node": ">=12.22.0" + }, + "peerDependencies": { + "webpack": "^4.44.2 || ^5.47.0" + } + }, + "node_modules/webpack-manifest-plugin/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/webpack-manifest-plugin/node_modules/webpack-sources": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-2.3.1.tgz", + "integrity": "sha512-y9EI9AO42JjEcrTJFOYmVywVZdKVUfOvDUPsJea5GIr1JOEGFVqwlY2K098fFoIjOkDzHn2AjRvM8dsBZu+gCA==", + "license": "MIT", + "dependencies": { + "source-list-map": "^2.0.1", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "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==", + "license": "MIT", + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/webpack/node_modules/eslint-scope": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz", + "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==", + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^4.1.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/webpack/node_modules/estraverse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", + "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/websocket-driver": { + "version": "0.7.4", + "resolved": "https://registry.npmjs.org/websocket-driver/-/websocket-driver-0.7.4.tgz", + "integrity": "sha512-b17KeDIQVjvb0ssuSDF2cYXSg2iztliJ4B9WdsuB6J952qCPKmnVq4DyW5motImXHDC1cBT/1UezrJVsKw5zjg==", + "license": "Apache-2.0", + "dependencies": { + "http-parser-js": ">=0.5.1", + "safe-buffer": ">=5.1.0", + "websocket-extensions": ">=0.1.1" + }, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/websocket-extensions": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/websocket-extensions/-/websocket-extensions-0.1.4.tgz", + "integrity": "sha512-OqedPIGOfsDlo31UNwYbCFMSaO9m9G/0faIHj5/dZFDMFqPTcx6UwqyOy3COEaEOg/9VsGIpdqn62W5KhoKSpg==", + "license": "Apache-2.0", + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/whatwg-encoding": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-1.0.5.tgz", + "integrity": "sha512-b5lim54JOPN9HtzvK9HFXvBma/rnfFeqsic0hSpjtDbVxR3dJKLc+KB4V6GgiGOvl7CY/KNh8rxSo9DKQrnUEw==", + "license": "MIT", + "dependencies": { + "iconv-lite": "0.4.24" + } + }, + "node_modules/whatwg-encoding/node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/whatwg-fetch": { + "version": "3.6.20", + "resolved": "https://registry.npmjs.org/whatwg-fetch/-/whatwg-fetch-3.6.20.tgz", + "integrity": "sha512-EqhiFU6daOA8kpjOWTL0olhVOF3i7OrFzSYiGsEMB8GcXS+RrzauAERX65xMeNWVqxA6HXH2m69Z9LaKKdisfg==", + "license": "MIT" + }, + "node_modules/whatwg-mimetype": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-2.3.0.tgz", + "integrity": "sha512-M4yMwr6mAnQz76TbJm914+gPpB/nCwvZbJU28cUD6dR004SAxDLOOSUaB1JDRqLtaOV/vi0IC5lEAGFgrjGv/g==", + "license": "MIT" + }, + "node_modules/whatwg-url": { + "version": "8.7.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-8.7.0.tgz", + "integrity": "sha512-gAojqb/m9Q8a5IV96E3fHJM70AzCkgt4uXYX2O7EmuyOnLrViCQlsEBmF9UQIu3/aeAIp2U17rtbpZWNntQqdg==", + "license": "MIT", + "dependencies": { + "lodash": "^4.7.0", + "tr46": "^2.1.0", + "webidl-conversions": "^6.1.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/which-boxed-primitive": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz", + "integrity": "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==", + "license": "MIT", + "dependencies": { + "is-bigint": "^1.1.0", + "is-boolean-object": "^1.2.1", + "is-number-object": "^1.1.1", + "is-string": "^1.1.1", + "is-symbol": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/which-builtin-type": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.2.1.tgz", + "integrity": "sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==", + "license": "MIT", + "dependencies": { + "call-bound": "^1.0.2", + "function.prototype.name": "^1.1.6", + "has-tostringtag": "^1.0.2", + "is-async-function": "^2.0.0", + "is-date-object": "^1.1.0", + "is-finalizationregistry": "^1.1.0", + "is-generator-function": "^1.0.10", + "is-regex": "^1.2.1", + "is-weakref": "^1.0.2", + "isarray": "^2.0.5", + "which-boxed-primitive": "^1.1.0", + "which-collection": "^1.0.2", + "which-typed-array": "^1.1.16" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/which-collection": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/which-collection/-/which-collection-1.0.2.tgz", + "integrity": "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw==", + "license": "MIT", + "dependencies": { + "is-map": "^2.0.3", + "is-set": "^2.0.3", + "is-weakmap": "^2.0.2", + "is-weakset": "^2.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/which-typed-array": { + "version": "1.1.19", + "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.19.tgz", + "integrity": "sha512-rEvr90Bck4WZt9HHFC4DJMsjvu7x+r6bImz0/BrbWb7A2djJ8hnZMrWnHo9F8ssv0OMErasDhftrfROTyqSDrw==", + "license": "MIT", + "dependencies": { + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.8", + "call-bound": "^1.0.4", + "for-each": "^0.3.5", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/word-wrap": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", + "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/workbox-background-sync": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/workbox-background-sync/-/workbox-background-sync-6.6.0.tgz", + "integrity": "sha512-jkf4ZdgOJxC9u2vztxLuPT/UjlH7m/nWRQ/MgGL0v8BJHoZdVGJd18Kck+a0e55wGXdqyHO+4IQTk0685g4MUw==", + "license": "MIT", + "dependencies": { + "idb": "^7.0.1", + "workbox-core": "6.6.0" + } + }, + "node_modules/workbox-broadcast-update": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/workbox-broadcast-update/-/workbox-broadcast-update-6.6.0.tgz", + "integrity": "sha512-nm+v6QmrIFaB/yokJmQ/93qIJ7n72NICxIwQwe5xsZiV2aI93MGGyEyzOzDPVz5THEr5rC3FJSsO3346cId64Q==", + "license": "MIT", + "dependencies": { + "workbox-core": "6.6.0" + } + }, + "node_modules/workbox-build": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/workbox-build/-/workbox-build-6.6.0.tgz", + "integrity": "sha512-Tjf+gBwOTuGyZwMz2Nk/B13Fuyeo0Q84W++bebbVsfr9iLkDSo6j6PST8tET9HYA58mlRXwlMGpyWO8ETJiXdQ==", + "license": "MIT", + "dependencies": { + "@apideck/better-ajv-errors": "^0.3.1", + "@babel/core": "^7.11.1", + "@babel/preset-env": "^7.11.0", + "@babel/runtime": "^7.11.2", + "@rollup/plugin-babel": "^5.2.0", + "@rollup/plugin-node-resolve": "^11.2.1", + "@rollup/plugin-replace": "^2.4.1", + "@surma/rollup-plugin-off-main-thread": "^2.2.3", + "ajv": "^8.6.0", + "common-tags": "^1.8.0", + "fast-json-stable-stringify": "^2.1.0", + "fs-extra": "^9.0.1", + "glob": "^7.1.6", + "lodash": "^4.17.20", + "pretty-bytes": "^5.3.0", + "rollup": "^2.43.1", + "rollup-plugin-terser": "^7.0.0", + "source-map": "^0.8.0-beta.0", + "stringify-object": "^3.3.0", + "strip-comments": "^2.0.1", + "tempy": "^0.6.0", + "upath": "^1.2.0", + "workbox-background-sync": "6.6.0", + "workbox-broadcast-update": "6.6.0", + "workbox-cacheable-response": "6.6.0", + "workbox-core": "6.6.0", + "workbox-expiration": "6.6.0", + "workbox-google-analytics": "6.6.0", + "workbox-navigation-preload": "6.6.0", + "workbox-precaching": "6.6.0", + "workbox-range-requests": "6.6.0", + "workbox-recipes": "6.6.0", + "workbox-routing": "6.6.0", + "workbox-strategies": "6.6.0", + "workbox-streams": "6.6.0", + "workbox-sw": "6.6.0", + "workbox-window": "6.6.0" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/workbox-build/node_modules/@apideck/better-ajv-errors": { + "version": "0.3.6", + "resolved": "https://registry.npmjs.org/@apideck/better-ajv-errors/-/better-ajv-errors-0.3.6.tgz", + "integrity": "sha512-P+ZygBLZtkp0qqOAJJVX4oX/sFo5JR3eBWwwuqHHhK0GIgQOKWrAfiAaWX0aArHkRWHMuggFEgAZNxVPwPZYaA==", + "license": "MIT", + "dependencies": { + "json-schema": "^0.4.0", + "jsonpointer": "^5.0.0", + "leven": "^3.1.0" + }, + "engines": { + "node": ">=10" + }, + "peerDependencies": { + "ajv": ">=8" + } + }, + "node_modules/workbox-build/node_modules/ajv": { + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz", + "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.3", + "fast-uri": "^3.0.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/workbox-build/node_modules/fs-extra": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz", + "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==", + "license": "MIT", + "dependencies": { + "at-least-node": "^1.0.0", + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/workbox-build/node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", + "license": "MIT" + }, + "node_modules/workbox-build/node_modules/source-map": { + "version": "0.8.0-beta.0", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.8.0-beta.0.tgz", + "integrity": "sha512-2ymg6oRBpebeZi9UUNsgQ89bhx01TcTkmNTGnNO88imTmbSgy4nfujrgVEFKWpMTEGA11EDkTt7mqObTPdigIA==", + "license": "BSD-3-Clause", + "dependencies": { + "whatwg-url": "^7.0.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/workbox-build/node_modules/tr46": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-1.0.1.tgz", + "integrity": "sha512-dTpowEjclQ7Kgx5SdBkqRzVhERQXov8/l9Ft9dVM9fmg0W0KQSVaXX9T4i6twCPNtYiZM53lpSSUAwJbFPOHxA==", + "license": "MIT", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/workbox-build/node_modules/webidl-conversions": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-4.0.2.tgz", + "integrity": "sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==", + "license": "BSD-2-Clause" + }, + "node_modules/workbox-build/node_modules/whatwg-url": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-7.1.0.tgz", + "integrity": "sha512-WUu7Rg1DroM7oQvGWfOiAK21n74Gg+T4elXEQYkOhtyLeWiJFoOGLXPKI/9gzIie9CtwVLm8wtw6YJdKyxSjeg==", + "license": "MIT", + "dependencies": { + "lodash.sortby": "^4.7.0", + "tr46": "^1.0.1", + "webidl-conversions": "^4.0.2" + } + }, + "node_modules/workbox-cacheable-response": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/workbox-cacheable-response/-/workbox-cacheable-response-6.6.0.tgz", + "integrity": "sha512-JfhJUSQDwsF1Xv3EV1vWzSsCOZn4mQ38bWEBR3LdvOxSPgB65gAM6cS2CX8rkkKHRgiLrN7Wxoyu+TuH67kHrw==", + "deprecated": "workbox-background-sync@6.6.0", + "license": "MIT", + "dependencies": { + "workbox-core": "6.6.0" + } + }, + "node_modules/workbox-core": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/workbox-core/-/workbox-core-6.6.0.tgz", + "integrity": "sha512-GDtFRF7Yg3DD859PMbPAYPeJyg5gJYXuBQAC+wyrWuuXgpfoOrIQIvFRZnQ7+czTIQjIr1DhLEGFzZanAT/3bQ==", + "license": "MIT" + }, + "node_modules/workbox-expiration": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/workbox-expiration/-/workbox-expiration-6.6.0.tgz", + "integrity": "sha512-baplYXcDHbe8vAo7GYvyAmlS4f6998Jff513L4XvlzAOxcl8F620O91guoJ5EOf5qeXG4cGdNZHkkVAPouFCpw==", + "license": "MIT", + "dependencies": { + "idb": "^7.0.1", + "workbox-core": "6.6.0" + } + }, + "node_modules/workbox-google-analytics": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/workbox-google-analytics/-/workbox-google-analytics-6.6.0.tgz", + "integrity": "sha512-p4DJa6OldXWd6M9zRl0H6vB9lkrmqYFkRQ2xEiNdBFp9U0LhsGO7hsBscVEyH9H2/3eZZt8c97NB2FD9U2NJ+Q==", + "deprecated": "It is not compatible with newer versions of GA starting with v4, as long as you are using GAv3 it should be ok, but the package is not longer being maintained", + "license": "MIT", + "dependencies": { + "workbox-background-sync": "6.6.0", + "workbox-core": "6.6.0", + "workbox-routing": "6.6.0", + "workbox-strategies": "6.6.0" + } + }, + "node_modules/workbox-navigation-preload": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/workbox-navigation-preload/-/workbox-navigation-preload-6.6.0.tgz", + "integrity": "sha512-utNEWG+uOfXdaZmvhshrh7KzhDu/1iMHyQOV6Aqup8Mm78D286ugu5k9MFD9SzBT5TcwgwSORVvInaXWbvKz9Q==", + "license": "MIT", + "dependencies": { + "workbox-core": "6.6.0" + } + }, + "node_modules/workbox-precaching": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/workbox-precaching/-/workbox-precaching-6.6.0.tgz", + "integrity": "sha512-eYu/7MqtRZN1IDttl/UQcSZFkHP7dnvr/X3Vn6Iw6OsPMruQHiVjjomDFCNtd8k2RdjLs0xiz9nq+t3YVBcWPw==", + "license": "MIT", + "dependencies": { + "workbox-core": "6.6.0", + "workbox-routing": "6.6.0", + "workbox-strategies": "6.6.0" + } + }, + "node_modules/workbox-range-requests": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/workbox-range-requests/-/workbox-range-requests-6.6.0.tgz", + "integrity": "sha512-V3aICz5fLGq5DpSYEU8LxeXvsT//mRWzKrfBOIxzIdQnV/Wj7R+LyJVTczi4CQ4NwKhAaBVaSujI1cEjXW+hTw==", + "license": "MIT", + "dependencies": { + "workbox-core": "6.6.0" + } + }, + "node_modules/workbox-recipes": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/workbox-recipes/-/workbox-recipes-6.6.0.tgz", + "integrity": "sha512-TFi3kTgYw73t5tg73yPVqQC8QQjxJSeqjXRO4ouE/CeypmP2O/xqmB/ZFBBQazLTPxILUQ0b8aeh0IuxVn9a6A==", + "license": "MIT", + "dependencies": { + "workbox-cacheable-response": "6.6.0", + "workbox-core": "6.6.0", + "workbox-expiration": "6.6.0", + "workbox-precaching": "6.6.0", + "workbox-routing": "6.6.0", + "workbox-strategies": "6.6.0" + } + }, + "node_modules/workbox-routing": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/workbox-routing/-/workbox-routing-6.6.0.tgz", + "integrity": "sha512-x8gdN7VDBiLC03izAZRfU+WKUXJnbqt6PG9Uh0XuPRzJPpZGLKce/FkOX95dWHRpOHWLEq8RXzjW0O+POSkKvw==", + "license": "MIT", + "dependencies": { + "workbox-core": "6.6.0" + } + }, + "node_modules/workbox-strategies": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/workbox-strategies/-/workbox-strategies-6.6.0.tgz", + "integrity": "sha512-eC07XGuINAKUWDnZeIPdRdVja4JQtTuc35TZ8SwMb1ztjp7Ddq2CJ4yqLvWzFWGlYI7CG/YGqaETntTxBGdKgQ==", + "license": "MIT", + "dependencies": { + "workbox-core": "6.6.0" + } + }, + "node_modules/workbox-streams": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/workbox-streams/-/workbox-streams-6.6.0.tgz", + "integrity": "sha512-rfMJLVvwuED09CnH1RnIep7L9+mj4ufkTyDPVaXPKlhi9+0czCu+SJggWCIFbPpJaAZmp2iyVGLqS3RUmY3fxg==", + "license": "MIT", + "dependencies": { + "workbox-core": "6.6.0", + "workbox-routing": "6.6.0" + } + }, + "node_modules/workbox-sw": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/workbox-sw/-/workbox-sw-6.6.0.tgz", + "integrity": "sha512-R2IkwDokbtHUE4Kus8pKO5+VkPHD2oqTgl+XJwh4zbF1HyjAbgNmK/FneZHVU7p03XUt9ICfuGDYISWG9qV/CQ==", + "license": "MIT" + }, + "node_modules/workbox-webpack-plugin": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/workbox-webpack-plugin/-/workbox-webpack-plugin-6.6.0.tgz", + "integrity": "sha512-xNZIZHalboZU66Wa7x1YkjIqEy1gTR+zPM+kjrYJzqN7iurYZBctBLISyScjhkJKYuRrZUP0iqViZTh8rS0+3A==", + "license": "MIT", + "dependencies": { + "fast-json-stable-stringify": "^2.1.0", + "pretty-bytes": "^5.4.1", + "upath": "^1.2.0", + "webpack-sources": "^1.4.3", + "workbox-build": "6.6.0" + }, + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "webpack": "^4.4.0 || ^5.9.0" + } + }, + "node_modules/workbox-webpack-plugin/node_modules/source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/workbox-webpack-plugin/node_modules/webpack-sources": { + "version": "1.4.3", + "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-1.4.3.tgz", + "integrity": "sha512-lgTS3Xhv1lCOKo7SA5TjKXMjpSM4sBjNV5+q2bqesbSPs5FjGmU6jjtBSkX9b4qW87vDIsCIlUPOEhbZrMdjeQ==", + "license": "MIT", + "dependencies": { + "source-list-map": "^2.0.0", + "source-map": "~0.6.1" + } + }, + "node_modules/workbox-window": { + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/workbox-window/-/workbox-window-6.6.0.tgz", + "integrity": "sha512-L4N9+vka17d16geaJXXRjENLFldvkWy7JyGxElRD0JvBxvFEd8LOhr+uXCcar/NzAmIBRv9EZ+M+Qr4mOoBITw==", + "license": "MIT", + "dependencies": { + "@types/trusted-types": "^2.0.2", + "workbox-core": "6.6.0" + } + }, + "node_modules/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrap-ansi-cjs": { + "name": "wrap-ansi", + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "license": "ISC" + }, + "node_modules/write-file-atomic": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-3.0.3.tgz", + "integrity": "sha512-AvHcyZ5JnSfq3ioSyjrBkH9yW4m7Ayk8/9My/DD9onKeu/94fwrMocemO2QAJFAlnnDN+ZDS+ZjAR5ua1/PV/Q==", + "license": "ISC", + "dependencies": { + "imurmurhash": "^0.1.4", + "is-typedarray": "^1.0.0", + "signal-exit": "^3.0.2", + "typedarray-to-buffer": "^3.1.5" + } + }, + "node_modules/ws": { + "version": "7.5.10", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.10.tgz", + "integrity": "sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ==", + "license": "MIT", + "engines": { + "node": ">=8.3.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": "^5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/xml-name-validator": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-3.0.0.tgz", + "integrity": "sha512-A5CUptxDsvxKJEU3yO6DuWBSJz/qizqzJKOMIfUJHETbBw/sFaDxgd6fxm1ewUaM0jZ444Fc5vC5ROYurg/4Pw==", + "license": "Apache-2.0" + }, + "node_modules/xmlchars": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz", + "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==", + "license": "MIT" + }, + "node_modules/xtend": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz", + "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==", + "license": "MIT", + "engines": { + "node": ">=0.4" + } + }, + "node_modules/y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "license": "ISC" + }, + "node_modules/yaml": { + "version": "1.10.2", + "resolved": "https://registry.npmjs.org/yaml/-/yaml-1.10.2.tgz", + "integrity": "sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==", + "license": "ISC", + "engines": { + "node": ">= 6" + } + }, + "node_modules/yargs": { + "version": "16.2.0", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz", + "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==", + "license": "MIT", + "dependencies": { + "cliui": "^7.0.2", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.0", + "y18n": "^5.0.5", + "yargs-parser": "^20.2.2" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs-parser": { + "version": "20.2.9", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz", + "integrity": "sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==", + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/zwitch": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz", + "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + } + } +} diff --git a/Demo/frontend/package.json b/Demo/frontend/package.json new file mode 100644 index 0000000..3a30650 --- /dev/null +++ b/Demo/frontend/package.json @@ -0,0 +1,63 @@ +{ + "name": "pathrag-ui", + "version": "0.1.0", + "private": false, + "license": "MIT", + "author": { + "name": "Robert Dennyson", + "email": "robertdennyson@live.in" + }, + "dependencies": { + "@fortawesome/fontawesome-svg-core": "^6.7.2", + "@fortawesome/free-brands-svg-icons": "^6.7.2", + "@fortawesome/free-regular-svg-icons": "^6.7.2", + "@fortawesome/free-solid-svg-icons": "^6.7.2", + "@fortawesome/react-fontawesome": "^0.2.2", + "@rsuite/icons": "^1.3.2", + "axios": "^1.4.0", + "d3": "^7.8.5", + "jwt-decode": "^3.1.2", + "mermaid": "^11.6.0", + "react": "^18.2.0", + "react-dom": "^18.2.0", + "react-dropzone": "^14.2.3", + "react-markdown": "^10.1.0", + "react-router-dom": "^6.14.1", + "react-scripts": "5.0.1", + "react-syntax-highlighter": "^15.6.1", + "remark-gfm": "^4.0.1", + "rsuite": "^5.37.0", + "styled-components": "^6.1.17", + "web-vitals": "^2.1.4" + }, + "scripts": { + "start": "cross-env PORT=3000 react-scripts start", + "build": "react-scripts build", + "test": "react-scripts test", + "eject": "react-scripts eject" + }, + "eslintConfig": { + "extends": [ + "react-app", + "react-app/jest" + ] + }, + "browserslist": { + "production": [ + ">0.2%", + "not dead", + "not op_mini all" + ], + "development": [ + "last 1 chrome version", + "last 1 firefox version", + "last 1 safari version" + ] + }, + "devDependencies": { + "@testing-library/jest-dom": "^5.16.5", + "@testing-library/react": "^13.4.0", + "@testing-library/user-event": "^13.5.0", + "cross-env": "^7.0.3" + } +} diff --git a/Demo/frontend/public/index.html b/Demo/frontend/public/index.html new file mode 100644 index 0000000..69d7cfd --- /dev/null +++ b/Demo/frontend/public/index.html @@ -0,0 +1,20 @@ + + + + + + + + + + + Pathrag - Enterprise Knowledge Graph + + + +
+ + diff --git a/Demo/frontend/public/manifest.json b/Demo/frontend/public/manifest.json new file mode 100644 index 0000000..bf8cbc1 --- /dev/null +++ b/Demo/frontend/public/manifest.json @@ -0,0 +1,25 @@ +{ + "short_name": "PathRAG", + "name": "PathRAG - Knowledge Graph and Chat Application", + "icons": [ + { + "src": "favicon.ico", + "sizes": "64x64 32x32 24x24 16x16", + "type": "image/x-icon" + }, + { + "src": "logo192.png", + "type": "image/png", + "sizes": "192x192" + }, + { + "src": "logo512.png", + "type": "image/png", + "sizes": "512x512" + } + ], + "start_url": ".", + "display": "standalone", + "theme_color": "#000000", + "background_color": "#ffffff" +} diff --git a/Demo/frontend/public/robots.txt b/Demo/frontend/public/robots.txt new file mode 100644 index 0000000..e9e57dc --- /dev/null +++ b/Demo/frontend/public/robots.txt @@ -0,0 +1,3 @@ +# https://www.robotstxt.org/robotstxt.html +User-agent: * +Disallow: diff --git a/Demo/frontend/src/App.css b/Demo/frontend/src/App.css new file mode 100644 index 0000000..8128dc2 --- /dev/null +++ b/Demo/frontend/src/App.css @@ -0,0 +1,192 @@ +/* General Styles */ +.app-container { + height: 100vh; + overflow: hidden; +} + +/* Layout Styles */ +.rs-sidenav { + background-color: #1a1d24; + color: #fff; +} + +.rs-sidenav-item { + color: #fff; +} + +.rs-sidenav-item:hover { + background-color: #2d3035; +} + +.rs-sidenav-item.rs-sidenav-item-active { + background-color: white; + color: #3c3f43; +} + +/* Chat Styles */ +.chat-container { + display: flex; + flex-direction: column; + height: calc(100vh - 116px); +} + +.chat-messages { + flex: 1; + overflow-y: auto; + padding: 20px; + margin-bottom: 20px; +} + +.chat-message { + display: flex; + margin-bottom: 20px; +} + +.message-avatar { + margin-right: 12px; +} + +.message-content { + flex: 1; +} + +.message-header { + display: flex; + justify-content: space-between; + margin-bottom: 8px; +} + +.message-sender { + font-weight: bold; +} + +.message-time { + color: #8e8e93; + font-size: 12px; +} + +.message-panel { + background-color: #2d3035; + border-radius: 8px; + padding: 12px; + margin-bottom: 8px; +} + +.message-actions { + display: flex; + justify-content: flex-end; +} + +.chat-input { + padding: 16px; + background-color: #2d3035; + border-radius: 8px; +} + +.chat-loading, .chat-empty { + display: flex; + justify-content: center; + align-items: center; + height: 100%; + color: #8e8e93; +} + +/* Document Styles */ +.documents-header { + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 20px; +} + +.document-uploader { + margin-bottom: 20px; +} + +.dropzone { + border: 2px dashed #3c3f43; + border-radius: 8px; + padding: 40px; + text-align: center; + cursor: pointer; + transition: border-color 0.3s; +} + +.dropzone.active { + border-color: #3498ff; +} + +.dropzone.disabled { + cursor: not-allowed; + opacity: 0.7; +} + +.upload-prompt { + color: #8e8e93; +} + +.upload-note { + font-size: 12px; + margin-top: 8px; +} + +.upload-progress { + display: flex; + flex-direction: column; + align-items: center; + gap: 16px; +} + +.upload-success { + margin-top: 16px; + display: flex; + flex-direction: column; + gap: 16px; +} + +/* Knowledge Graph Styles */ +.graph-panel { + height: calc(100vh - 200px); + overflow: hidden; +} + +.graph-container { + width: 100%; + height: 100%; +} + +.knowledge-graph { + width: 100%; + height: 100%; + background-color: #2d3035; +} + +.graph-loading, .graph-empty { + display: flex; + justify-content: center; + align-items: center; + height: 100%; + color: #8e8e93; +} + +.query-form { + margin-bottom: 20px; +} + +/* Auth Styles */ +.login-page, .register-page { + background-color: #1a1d24; + height: 100vh; +} + +.login-form, .register-form { + margin-top: 20px; +} + +.text-center { + text-align: center; +} + +.mt-3 { + margin-top: 16px; +} diff --git a/Demo/frontend/src/App.js b/Demo/frontend/src/App.js new file mode 100644 index 0000000..513d69c --- /dev/null +++ b/Demo/frontend/src/App.js @@ -0,0 +1,63 @@ +import React from 'react'; +import { Routes, Route, Navigate } from 'react-router-dom'; +import { Container } from 'rsuite'; +import { useAuth } from './context/AuthContext'; +import './App.css'; +import './styles/theme.css'; + +// Pages +import Login from './pages/Login'; +import Register from './pages/Register'; +import Dashboard from './pages/Dashboard'; +import ChatPage from './pages/ChatPage'; +import KnowledgeGraphPage from './pages/KnowledgeGraphPage'; +import DocumentsPage from './pages/DocumentsPage'; + +// Protected Route Component +const ProtectedRoute = ({ children }) => { + const { isAuthenticated } = useAuth(); + + if (!isAuthenticated) { + return ; + } + + return children; +}; + +function App() { + return ( + + + } /> + } /> + + + + } /> + + + + } /> + + + + } /> + + + + } /> + + + + } /> + + + ); +} + +export default App; diff --git a/Demo/frontend/src/components/CustomNav.js b/Demo/frontend/src/components/CustomNav.js new file mode 100644 index 0000000..27a0f8a --- /dev/null +++ b/Demo/frontend/src/components/CustomNav.js @@ -0,0 +1,76 @@ +import React from 'react'; +import { Nav } from 'rsuite'; +import styled from 'styled-components'; + +// Styled components for custom navigation +const StyledNavItem = styled(Nav.Item)` + color: white !important; + margin: 8px 16px !important; + border-radius: 4px !important; + font-size: 1.1rem !important; + padding: 12px 16px !important; + border-left: 3px solid transparent !important; + transition: all 0.2s ease !important; + + &:hover { + background-color: var(--sidebarHover) !important; + transform: translateX(2px); + border-left-color: var(--primary) !important; + } + + &:hover .rs-nav-item-text { + color: var(--primary) !important; + font-weight: bold !important; + } + + &:hover .nav-icon { + color: var(--primary) !important; + } + + &.rs-nav-item-active { + background-color: var(--navActive) !important; + font-weight: bold !important; + border-left-color: var(--primary) !important; + } + + &.rs-nav-item-active .rs-nav-item-text { + color: white !important; + font-weight: bold !important; + } + + &.rs-nav-item-active .nav-icon { + color: white !important; + } + + .rs-nav-item-text { + color: white !important; + text-shadow: 0 1px 2px rgba(0, 0, 0, 0.3) !important; + letter-spacing: 0.5px !important; + } + + .nav-icon { + color: var(--accent) !important; + font-size: 1.3rem !important; + margin-right: 12px !important; + width: 24px !important; + text-align: center !important; + } +`; + +// Custom Nav component that wraps RSuite Nav +const CustomNav = ({ children, ...props }) => { + return ; +}; + +// Custom Nav.Item component with styled version +CustomNav.Item = ({ children, icon, ...props }) => { + const iconWithClass = icon ? React.cloneElement(icon, { className: 'nav-icon' }) : null; + + return ( + + {children} + + ); +}; + +export default CustomNav; diff --git a/Demo/frontend/src/components/Layout.js b/Demo/frontend/src/components/Layout.js new file mode 100644 index 0000000..051a959 --- /dev/null +++ b/Demo/frontend/src/components/Layout.js @@ -0,0 +1,467 @@ +import React, { useState, useEffect } from 'react'; +import { Container, Header, Content, Sidebar, Sidenav, Dropdown, Nav } from 'rsuite'; +import { useNavigate, useLocation } from 'react-router-dom'; +import { useAuth } from '../context/AuthContext'; +import { useTheme } from '../context/ThemeContext'; +import { chatAPI } from '../services/api'; +import { FontAwesomeIcon } from '@fortawesome/react-fontawesome'; +import { + faTachometerAlt, + faComments, + faProjectDiagram, + faFileAlt, + faSignOutAlt, + faUser, + faPalette, + faBars, + faCog, + faPlus +} from '@fortawesome/free-solid-svg-icons'; + +const Layout = ({ children }) => { + const navigate = useNavigate(); + const location = useLocation(); + const { currentUser, logout, isAuthenticated } = useAuth(); + const { currentTheme, changeTheme, themes } = useTheme(); + const [expanded, setExpanded] = useState(() => { + // Get sidebar state from localStorage or default to true + const savedState = localStorage.getItem('sidebarExpanded'); + return savedState !== null ? JSON.parse(savedState) : true; + }); + const [mobile, setMobile] = useState(false); + const [recentChats, setRecentChats] = useState([]); + const [isLoadingChats, setIsLoadingChats] = useState(false); + + // Check if mobile view on window resize + useEffect(() => { + const checkMobile = () => { + const isMobile = window.innerWidth < 768; + setMobile(isMobile); + if (isMobile && expanded) { + setExpanded(false); + } + }; + + checkMobile(); + window.addEventListener('resize', checkMobile); + + return () => { + window.removeEventListener('resize', checkMobile); + }; + }, [expanded]); + + // Save sidebar state to localStorage + useEffect(() => { + localStorage.setItem('sidebarExpanded', JSON.stringify(expanded)); + }, [expanded]); + + // Fetch recent chat threads + useEffect(() => { + const fetchRecentThreads = async () => { + if (isAuthenticated) { + try { + setIsLoadingChats(true); + const response = await chatAPI.getRecentThreads(); + if (response && response.data && response.data.threads) { + setRecentChats(response.data.threads); + } + } catch (error) { + // Silently handle the error - don't show error in console + setRecentChats([]); // Set empty array on error + } finally { + setIsLoadingChats(false); + } + } + }; + + fetchRecentThreads(); + + // Re-fetch threads when authentication status changes + }, [isAuthenticated]); + + const handleSelect = (eventKey) => { + if (eventKey === 'logout') { + logout(); + navigate('/login'); + } else { + navigate(eventKey); + } + + // Auto-collapse sidebar on mobile after navigation + if (mobile) { + setExpanded(false); + } + }; + + const toggleSidebar = () => { + setExpanded(!expanded); + }; + + const handleThreadSelect = (threadUuid) => { + // Navigate to the specific thread + navigate(`/chat/${threadUuid}`); + + // Auto-collapse sidebar on mobile after selection + if (mobile) { + setExpanded(false); + } + }; + + // Handle theme change + const handleThemeChange = (themeName) => { + changeTheme(themeName); + // TODO: Add API call to save theme preference to user profile + }; + + return ( + + {/* Sidebar toggle button - visible on all screen sizes */} +
+ +
+ + {/* Responsive Sidebar */} + + +
+ PathRAG +
+ + + + + + + {/* Chat Section */} +
+
+
+ Recent Chats +
+ +
+ + {isLoadingChats ? ( +
+ Loading... +
+ ) : ( + recentChats.map(thread => ( +
handleThreadSelect(thread.uuid)} + style={{ + padding: '10px 12px', + borderRadius: '4px', + marginBottom: 8, + cursor: 'pointer', + transition: 'all 0.2s ease', + backgroundColor: 'rgba(255, 255, 255, 0.05)', + border: '1px solid rgba(255, 255, 255, 0.1)', + display: 'flex', + flexDirection: 'column' + }} + onMouseEnter={(e) => { + e.currentTarget.style.backgroundColor = 'var(--sidebarHover)'; + e.currentTarget.style.transform = 'translateX(2px)'; + }} + onMouseLeave={(e) => { + e.currentTarget.style.backgroundColor = 'rgba(255, 255, 255, 0.05)'; + e.currentTarget.style.transform = 'translateX(0)'; + }} + > +
+ {thread.title || 'New Chat'} +
+
+ {thread.updated_at ? new Date(thread.updated_at).toLocaleDateString() : 'Recent'} +
+
+ )) + )} +
+ + + +
+ + + {/* Main content container */} + +
+
+
+ {location.pathname === '/' && 'Dashboard'} + {location.pathname === '/chat' && 'Chats'} + {location.pathname === '/knowledge-graph' && 'Knowledge Graph'} + {location.pathname === '/documents' && 'Documents'} +
+ +
+ + + {!mobile && 'Theme'} +
+ } + placement="bottomEnd" + > + {Object.keys(themes).map(themeName => ( + handleThemeChange(themeName)} + > +
+
+ {themes[themeName].name} +
+ + ))} + + + {/* User Menu */} + + + {!mobile && currentUser?.username} +
+ } + placement="bottomEnd" + > + }> + Settings + + } + onClick={() => { + logout(); + navigate('/login'); + }} + > + Logout + + + + +
+ + + {children} + + + + ); +}; + +export default Layout; diff --git a/Demo/frontend/src/components/auth/LoginForm.js b/Demo/frontend/src/components/auth/LoginForm.js new file mode 100644 index 0000000..6b051fc --- /dev/null +++ b/Demo/frontend/src/components/auth/LoginForm.js @@ -0,0 +1,54 @@ +import React, { useState } from 'react'; +import { Form, Button, Panel, Message, Loader } from 'rsuite'; +import { useAuth } from '../../context/AuthContext'; + +const LoginForm = () => { + const [username, setUsername] = useState(''); + const [password, setPassword] = useState(''); + const { login, isLoading, error } = useAuth(); + + const handleSubmit = async () => { + if (!username || !password) { + return; + } + + await login(username, password); + }; + + return ( + Login} bordered className="login-form"> + {error && {error}} + +
+ + Username + + + + + Password + + + + + + +
+ + ); +}; + +export default LoginForm; diff --git a/Demo/frontend/src/components/auth/RegisterForm.js b/Demo/frontend/src/components/auth/RegisterForm.js new file mode 100644 index 0000000..bca04b9 --- /dev/null +++ b/Demo/frontend/src/components/auth/RegisterForm.js @@ -0,0 +1,93 @@ +import React, { useState } from 'react'; +import { Form, Button, Panel, Message, Loader } from 'rsuite'; +import { useAuth } from '../../context/AuthContext'; + +const RegisterForm = () => { + const [username, setUsername] = useState(''); + const [email, setEmail] = useState(''); + const [password, setPassword] = useState(''); + const [confirmPassword, setConfirmPassword] = useState(''); + const [formError, setFormError] = useState(''); + + const { register, isLoading, error } = useAuth(); + + const handleSubmit = async () => { + // Reset form error + setFormError(''); + + // Validate form + if (!username || !email || !password || !confirmPassword) { + setFormError('All fields are required'); + return; + } + + if (password !== confirmPassword) { + setFormError('Passwords do not match'); + return; + } + + // Register user + await register({ username, email, password }); + }; + + return ( + Register

} bordered className="register-form"> + {(error || formError) && ( + {formError || error} + )} + +
+ + Username + + + + + Email + + + + + Password + + + + + Confirm Password + + + + + + +
+ + ); +}; + +export default RegisterForm; diff --git a/Demo/frontend/src/components/chat/ChatInput.js b/Demo/frontend/src/components/chat/ChatInput.js new file mode 100644 index 0000000..5d4da3f --- /dev/null +++ b/Demo/frontend/src/components/chat/ChatInput.js @@ -0,0 +1,117 @@ +import React, { useState } from 'react'; +import { Input, InputGroup, Loader, IconButton, Tooltip, Whisper, SelectPicker } from 'rsuite'; +import SendIcon from '@rsuite/icons/Send'; +import { FontAwesomeIcon } from '@fortawesome/react-fontawesome'; +import { + faMicrophone, + faPaperclip +} from '@fortawesome/free-solid-svg-icons'; + +// Search modes for dropdown +const searchModeOptions = [ + { label: 'Local', value: 'local' }, + { label: 'Hybrid', value: 'hybrid' }, + { label: 'Global', value: 'global' } +]; + +const ChatInput = ({ onSendMessage, isLoading, searchContext, setSearchContext }) => { + const [message, setMessage] = useState(''); + + // Handle file attachment + const handleAttachment = () => { + // This would typically open a file picker + console.log('Attachment clicked'); + }; + + // Handle voice input + const handleVoiceInput = () => { + // This would typically start voice recording + console.log('Voice input clicked'); + }; + + const handleSend = () => { + if (message.trim() && !isLoading) { + onSendMessage(message); + setMessage(''); + } + }; + + const handleKeyPress = (event) => { + if (event.key === 'Enter' && !event.shiftKey) { + event.preventDefault(); + handleSend(); + } + }; + + return ( +
+
+
+ { + return item ? item.label.replace('Search Mode: ', '') : value; + }} + /> + + + Attach file} + > + } + onClick={handleAttachment} + // className="input-icon-button" + + appearance="subtle" + disabled={isLoading} + /> + + + + + Voice input} + > + } + onClick={handleVoiceInput} + // className="input-icon-button" + appearance="subtle" + disabled={isLoading} + /> + + + + {isLoading ? : } + + +
+
+
+ ); +}; + +export default ChatInput; diff --git a/Demo/frontend/src/components/chat/ChatMessage.js b/Demo/frontend/src/components/chat/ChatMessage.js new file mode 100644 index 0000000..610b63c --- /dev/null +++ b/Demo/frontend/src/components/chat/ChatMessage.js @@ -0,0 +1,137 @@ +import React, { useEffect } from 'react'; +import { Avatar, IconButton } from 'rsuite'; +import MoreIcon from '@rsuite/icons/More'; +import { useAuth } from '../../context/AuthContext'; +import ReactMarkdown from 'react-markdown'; +import { Prism as SyntaxHighlighter } from 'react-syntax-highlighter'; +import { vscDarkPlus } from 'react-syntax-highlighter/dist/esm/styles/prism'; +import remarkGfm from 'remark-gfm'; +import mermaid from 'mermaid'; + +// Initialize mermaid +mermaid.initialize({ + startOnLoad: true, + theme: 'dark', + securityLevel: 'loose', + fontFamily: 'monospace' +}); + +const ChatMessage = ({ message, isUser }) => { + const { currentUser } = useAuth(); + + useEffect(() => { + // Process any mermaid diagrams after component mounts + setTimeout(() => { + try { + mermaid.contentLoaded(); + } catch (error) { + console.error('Mermaid processing error:', error); + } + }, 0); + }, [message]); + + // Function to process mermaid code blocks + const processMermaidBlocks = (content) => { + if (typeof content !== 'string') return ''; + + const mermaidRegex = /```mermaid\n([\s\S]*?)```/g; + let lastIndex = 0; + const parts = []; + let match; + + while ((match = mermaidRegex.exec(content)) !== null) { + // Add text before the mermaid block + if (match.index > lastIndex) { + parts.push(content.substring(lastIndex, match.index)); + } + + // Add mermaid diagram with unique ID + const diagramId = `mermaid-diagram-${Date.now()}-${Math.floor(Math.random() * 1000)}`; + parts.push( + `
+
+ ${match[1]} +
+
` + ); + + lastIndex = match.index + match[0].length; + } + + // Add any remaining text + if (lastIndex < content.length) { + parts.push(content.substring(lastIndex)); + } + + return parts.join(''); + }; + + // Process content for mermaid diagrams if it's a bot message + const processedContent = !isUser ? processMermaidBlocks(message) : message; + + return ( +
+ {!isUser && ( +
+ + AI + +
+ )} + +
+
+ {isUser ? currentUser?.username : 'Enterprise KG AI'} + {new Date().toLocaleTimeString()} +
+ +
+ {!isUser ? ( +
+ + {String(children).replace(/\n$/, '')} + + ) : ( + + {children} + + ); + } + }} + > + {processedContent} + +
+ ) : ( +
{message}
+ )} +
+ +
+ } circle size="xs" /> +
+
+ + {isUser && ( +
+ + {currentUser?.username?.charAt(0).toUpperCase()} + +
+ )} +
+ ); +}; + +export default ChatMessage; diff --git a/Demo/frontend/src/components/documents/DocumentList.js b/Demo/frontend/src/components/documents/DocumentList.js new file mode 100644 index 0000000..8779962 --- /dev/null +++ b/Demo/frontend/src/components/documents/DocumentList.js @@ -0,0 +1,93 @@ +import React from 'react'; +import { Table, Panel } from 'rsuite'; +const { Column, HeaderCell, Cell } = Table; + +const DocumentList = ({ documents, loading }) => { + // Format file size + const formatFileSize = (bytes) => { + if (bytes === 0) return '0 Bytes'; + + const k = 1024; + const sizes = ['Bytes', 'KB', 'MB', 'GB']; + const i = Math.floor(Math.log(bytes) / Math.log(k)); + + return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]; + }; + + // Format date + const formatDate = (dateString) => { + const date = new Date(dateString); + return date.toLocaleString(); + }; + + // Format status + const formatStatus = (status) => { + if (!status) return 'Completed'; + + switch (status.toLowerCase()) { + case 'processing': + return 'Processing'; + case 'completed': + return 'Completed'; + case 'failed': + return 'Failed'; + case 'uploading': + return 'Uploading'; + default: + return status.charAt(0).toUpperCase() + status.slice(1); + } + }; + + return ( + + + + Filename + + + + + Type + + + + + Size + + {(rowData) => formatFileSize(rowData.file_size)} + + + + + Uploaded + + {(rowData) => formatDate(rowData.uploaded_at)} + + + + + Status + + {(rowData) => { + const status = rowData.status ? rowData.status.toLowerCase() : 'completed'; + return ( +
+ {formatStatus(rowData.status)} +
+ ); + }} + + +
+ + ); +}; + +export default DocumentList; diff --git a/Demo/frontend/src/components/documents/DocumentUploader.js b/Demo/frontend/src/components/documents/DocumentUploader.js new file mode 100644 index 0000000..6728761 --- /dev/null +++ b/Demo/frontend/src/components/documents/DocumentUploader.js @@ -0,0 +1,291 @@ +import React, { useState, useCallback, useEffect, useRef } from 'react'; +import { useDropzone } from 'react-dropzone'; +import { Panel, Loader, Progress, Message, Button, Notification, toaster } from 'rsuite'; +import { documentAPI } from '../../services/api'; + +const DocumentUploader = ({ onUploadComplete }) => { + const [uploading, setUploading] = useState(false); + // eslint-disable-next-line no-unused-vars + const [uploadProgress, setUploadProgress] = useState(0); // Used in the onUploadProgress callback + const [error, setError] = useState(null); + const [uploadedFile, setUploadedFile] = useState(null); + const [uploadStatus, setUploadStatus] = useState({ + status: '', + message: '', + progress: 0 + }); + const [, setIsPolling] = useState(false); + const [isReloading, setIsReloading] = useState(false); + const pollingIntervalRef = useRef(null); + const documentIdRef = useRef(null); + + // Status polling effect + useEffect(() => { + // Clean up polling interval on component unmount + return () => { + if (pollingIntervalRef.current) { + clearInterval(pollingIntervalRef.current); + } + }; + }, []); + + // Function to start polling for document status + const startStatusPolling = (documentId) => { + if (pollingIntervalRef.current) { + clearInterval(pollingIntervalRef.current); + } + + documentIdRef.current = documentId; + setIsPolling(true); + + // Poll every 15 seconds + pollingIntervalRef.current = setInterval(async () => { + try { + const response = await documentAPI.getDocumentStatus(documentId); + + if (response && response.data) { + const documentStatus = response.data.status; + + setUploadStatus({ + status: documentStatus || 'processing', + message: documentStatus === 'completed' + ? 'Document processed successfully' + : documentStatus === 'failed' + ? response.data.error_message || 'Processing failed' + : 'Processing document...', + progress: documentStatus === 'completed' ? 100 : 75 + }); + + // If document is completed, stop polling and trigger reload + if (documentStatus === 'completed') { + stopPollingAndReload(); + } else if (documentStatus === 'failed') { + stopPolling(); + setError(response.data.error_message || 'Document processing failed'); + } + } + } catch (error) { + console.error('Error polling document status:', error); + } + }, 15000); // 15 seconds + }; + + // Function to stop polling + const stopPolling = () => { + if (pollingIntervalRef.current) { + clearInterval(pollingIntervalRef.current); + pollingIntervalRef.current = null; + } + setIsPolling(false); + }; + + // Function to stop polling and trigger reload + const stopPollingAndReload = async () => { + stopPolling(); + + try { + setIsReloading(true); + // Call the reload endpoint + const reloadResponse = await documentAPI.reloadDocuments(); + + if (reloadResponse && reloadResponse.data && reloadResponse.data.success) { + console.log('Documents reloaded successfully:', reloadResponse.data.message); + + // Update status to show reload completed + setUploadStatus(prev => ({ + ...prev, + status: 'completed', + message: 'Document processed and indexed successfully' + })); + + // Show success notification + toaster.push( + +

Document has been processed and is now available for search.

+ , + { placement: 'topEnd' } + ); + + // Set uploading to false to show success message + setUploading(false); + + // Notify parent component + if (onUploadComplete && uploadedFile) { + onUploadComplete(uploadedFile); + } + } + } catch (error) { + console.error('Error reloading documents:', error); + } finally { + setIsReloading(false); + } + }; + + const onDrop = useCallback(async (acceptedFiles) => { + const file = acceptedFiles[0]; + + if (!file) return; + + // Check file type + const allowedTypes = [ + 'application/pdf', + 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', + 'text/markdown', + 'text/plain', + 'text/html' + ]; + + // Also check by extension for cases where MIME type is not reliable + const allowedExtensions = ['.pdf', '.docx', '.md', '.txt', '.html', '.htm']; + const fileExtension = file.name.substring(file.name.lastIndexOf('.')).toLowerCase(); + + if (!allowedTypes.includes(file.type) && !allowedExtensions.includes(fileExtension)) { + setError('Unsupported file type. Please upload PDF, DOCX, MD, TXT, or HTML files.'); + return; + } + + setUploading(true); + setUploadProgress(0); + setError(null); + setUploadStatus({ + status: 'uploading', + message: 'Preparing to upload...', + progress: 0 + }); + + try { + // Create form data + const formData = new FormData(); + formData.append('file', file); + + // Upload the document + const response = await documentAPI.uploadDocument(formData, (progressEvent) => { + const percentCompleted = Math.round((progressEvent.loaded * 100) / progressEvent.total); + setUploadProgress(percentCompleted); + setUploadStatus({ + status: 'uploading', + message: `Uploading file: ${percentCompleted}%`, + progress: percentCompleted / 2 // Scale to 50% of total process + }); + }); + + setUploadedFile(response.data); + + // Set status to processing + setUploadStatus({ + status: 'processing', + message: 'Document uploaded, processing started...', + progress: 50 + }); + + // Start polling for document status + if (response.data && response.data.id) { + console.log(`Starting status polling for document ID: ${response.data.id}`); + startStatusPolling(response.data.id); + } else { + // If no document ID, just complete the process + setUploadStatus({ + status: 'completed', + message: 'Document uploaded successfully', + progress: 100 + }); + setUploading(false); + } + + // Don't notify parent component yet - we'll do that after processing is complete + // We'll keep the uploading state true until processing is complete + + } catch (error) { + setUploading(false); + setError(error.response?.data?.detail || 'Failed to upload document'); + } + }, [startStatusPolling, onUploadComplete]); + + const { getRootProps, getInputProps, isDragActive } = useDropzone({ + onDrop, + accept: { + 'application/pdf': ['.pdf'], + 'application/vnd.openxmlformats-officedocument.wordprocessingml.document': ['.docx'], + 'text/markdown': ['.md'], + 'text/plain': ['.txt'], + 'text/html': ['.html', '.htm'], + }, + disabled: uploading, + multiple: false, + }); + + // Determine status color based on current status + const getStatusColor = () => { + switch (uploadStatus.status) { + case 'completed': + return 'green'; + case 'failed': + return 'red'; + case 'processing': + return 'blue'; + default: + return 'orange'; + } + }; + + // We use getStatusColor() directly in the Progress.Line component + + return ( + + {error && {error}} + +
+ + + {uploading ? ( +
+
+ + + {uploadStatus.status.charAt(0).toUpperCase() + uploadStatus.status.slice(1)} + +
+ + + +

{uploadStatus.message || 'Processing document...'}

+
+ ) : ( +
+

Drag & drop a document here, or click to select

+

Supported formats: PDF, DOCX, MD, TXT, HTML

+
+ )} +
+ + {uploadedFile && !uploading && uploadStatus.status === 'completed' && ( +
+ + Document uploaded, processed, and indexed successfully: {uploadedFile.filename} + + +
+ )} + + {isReloading && ( +
+ + + Reloading document index to make the document available for search... + +
+ )} + + ); +}; + +export default DocumentUploader; diff --git a/Demo/frontend/src/components/documents/UploadProgress.js b/Demo/frontend/src/components/documents/UploadProgress.js new file mode 100644 index 0000000..f0ca192 --- /dev/null +++ b/Demo/frontend/src/components/documents/UploadProgress.js @@ -0,0 +1,123 @@ +import React, { useState, useEffect } from 'react'; +import { Progress, Panel, Tag, Loader } from 'rsuite'; +import { FontAwesomeIcon } from '@fortawesome/react-fontawesome'; +import { faCheckCircle, faExclamationTriangle, faSpinner } from '@fortawesome/free-solid-svg-icons'; +import { documentAPI } from '../../services/api'; + +const UploadProgress = ({ document }) => { + const [status, setStatus] = useState({ + progress: document.status === 'completed' ? 100 : document.status === 'processing' ? 50 : 0, + status: document.status || 'uploading', + message: document.status === 'completed' + ? 'Document processed successfully' + : document.status === 'processing' + ? 'Processing document...' + : 'Initializing upload...' + }); + + const [intervalId, setIntervalId] = useState(null); + + useEffect(() => { + // Function to fetch document status + const fetchDocumentStatus = async () => { + try { + const response = await documentAPI.getDocumentStatus(document.id); + if (response && response.data) { + const documentStatus = response.data.status; + + setStatus({ + progress: documentStatus === 'completed' ? 100 : documentStatus === 'processing' ? 75 : 25, + status: documentStatus || 'uploading', + message: documentStatus === 'completed' + ? 'Document processed successfully' + : documentStatus === 'failed' + ? response.data.error_message || 'Processing failed' + : 'Processing document...' + }); + + // If document is completed or failed, clear the interval + if (documentStatus === 'completed' || documentStatus === 'failed') { + if (intervalId) { + clearInterval(intervalId); + setIntervalId(null); + } + } + } + } catch (error) { + console.error('Error fetching document status:', error); + } + }; + + // Fetch status immediately + fetchDocumentStatus(); + + // Set up interval to check status every 15 seconds + const id = setInterval(fetchDocumentStatus, 15000); + setIntervalId(id); + + // Clean up interval on unmount + return () => { + if (intervalId) { + clearInterval(intervalId); + } + }; + }, [document.id, intervalId]); + + // Determine status color and icon + const getStatusInfo = () => { + switch (status.status) { + case 'completed': + return { + color: 'green', + icon: , + tagColor: 'green' + }; + case 'failed': + return { + color: 'red', + icon: , + tagColor: 'red' + }; + case 'processing': + return { + color: 'blue', + icon: , + tagColor: 'blue' + }; + default: + return { + color: 'orange', + icon: , + tagColor: 'orange' + }; + } + }; + + const statusInfo = getStatusInfo(); + + return ( + +
+

{document.filename}

+ + {statusInfo.icon} {status.status.charAt(0).toUpperCase() + status.status.slice(1)} + +
+ +
+ + {Math.round(status.progress)}% +
+ +
+ {status.message} +
+ + ); +}; + +export default UploadProgress; diff --git a/Demo/frontend/src/components/knowledge-graph/Graph.js b/Demo/frontend/src/components/knowledge-graph/Graph.js new file mode 100644 index 0000000..b3f9877 --- /dev/null +++ b/Demo/frontend/src/components/knowledge-graph/Graph.js @@ -0,0 +1,276 @@ +import React, { useEffect, useRef, useState } from 'react'; +import * as d3 from 'd3'; +import { IconButton, ButtonGroup, Tooltip, Whisper } from 'rsuite'; +import { FontAwesomeIcon } from '@fortawesome/react-fontawesome'; +import { faSearchPlus, faSearchMinus, faExpand, faCompress, faMaximize } from '@fortawesome/free-solid-svg-icons'; + +const Graph = ({ data }) => { + const svgRef = useRef(null); + const zoomRef = useRef(null); + const graphContainerRef = useRef(null); + const [zoomLevel, setZoomLevel] = useState(1); + const [isFullScreen, setIsFullScreen] = useState(false); + + // Zoom functions + const handleZoomIn = () => { + if (zoomRef.current) { + const newZoomLevel = Math.min(zoomLevel * 1.5, 8); + d3.select(svgRef.current) + .transition() + .duration(300) + .call(zoomRef.current.scaleBy, 1.5); + setZoomLevel(newZoomLevel); + } + }; + + const handleZoomOut = () => { + if (zoomRef.current) { + const newZoomLevel = Math.max(zoomLevel / 1.5, 0.1); + d3.select(svgRef.current) + .transition() + .duration(300) + .call(zoomRef.current.scaleBy, 1/1.5); + setZoomLevel(newZoomLevel); + } + }; + + const handleResetZoom = () => { + if (zoomRef.current) { + d3.select(svgRef.current) + .transition() + .duration(500) + .call(zoomRef.current.transform, d3.zoomIdentity); + setZoomLevel(1); + } + }; + + // Full screen toggle function + const toggleFullScreen = () => { + if (!document.fullscreenElement && !document.mozFullScreenElement && + !document.webkitFullscreenElement && !document.msFullscreenElement) { + // Enter full screen + const container = graphContainerRef.current; + if (container.requestFullscreen) { + container.requestFullscreen(); + } else if (container.msRequestFullscreen) { + container.msRequestFullscreen(); + } else if (container.mozRequestFullScreen) { + container.mozRequestFullScreen(); + } else if (container.webkitRequestFullscreen) { + container.webkitRequestFullscreen(); + } + setIsFullScreen(true); + } else { + // Exit full screen + if (document.exitFullscreen) { + document.exitFullscreen(); + } else if (document.msExitFullscreen) { + document.msExitFullscreen(); + } else if (document.mozCancelFullScreen) { + document.mozCancelFullScreen(); + } else if (document.webkitExitFullscreen) { + document.webkitExitFullscreen(); + } + setIsFullScreen(false); + } + }; + + // Listen for full screen change events + useEffect(() => { + const handleFullScreenChange = () => { + setIsFullScreen( + document.fullscreenElement || + document.mozFullScreenElement || + document.webkitFullscreenElement || + document.msFullscreenElement + ); + }; + + document.addEventListener('fullscreenchange', handleFullScreenChange); + document.addEventListener('mozfullscreenchange', handleFullScreenChange); + document.addEventListener('webkitfullscreenchange', handleFullScreenChange); + document.addEventListener('MSFullscreenChange', handleFullScreenChange); + + return () => { + document.removeEventListener('fullscreenchange', handleFullScreenChange); + document.removeEventListener('mozfullscreenchange', handleFullScreenChange); + document.removeEventListener('webkitfullscreenchange', handleFullScreenChange); + document.removeEventListener('MSFullscreenChange', handleFullScreenChange); + }; + }, []); + + useEffect(() => { + if (!data || !data.nodes || !data.edges || data.nodes.length === 0) { + return; + } + + // Clear previous graph + d3.select(svgRef.current).selectAll('*').remove(); + + // Set up SVG dimensions + const width = 800; + const height = 600; + + // Create SVG + const svg = d3.select(svgRef.current) + .attr('width', width) + .attr('height', height) + .attr('viewBox', [0, 0, width, height]); + + // Create force simulation + const simulation = d3.forceSimulation(data.nodes) + .force('link', d3.forceLink(data.edges).id(d => d.id).distance(100)) + .force('charge', d3.forceManyBody().strength(-300)) + .force('center', d3.forceCenter(width / 2, height / 2)) + .force('collision', d3.forceCollide().radius(50)); + + // Create a group for the graph + const g = svg.append('g'); + + // Create zoom behavior + const zoom = d3.zoom() + .extent([[0, 0], [width, height]]) + .scaleExtent([0.1, 8]) + .on('zoom', (event) => { + g.attr('transform', event.transform); + setZoomLevel(event.transform.k); + }); + + // Store zoom behavior in ref for external control + zoomRef.current = zoom; + + // Add zoom behavior to SVG + svg.call(zoom); + + // Define node colors based on type + const color = d3.scaleOrdinal() + .domain(['person', 'organization', 'event', 'geo', 'category', 'Unknown']) + .range(['#4e79a7', '#f28e2c', '#e15759', '#76b7b2', '#59a14f', '#b07aa1']); + + // Create links + const link = g.append('g') + .attr('stroke', '#999') + .attr('stroke-opacity', 0.6) + .selectAll('line') + .data(data.edges) + .join('line') + .attr('stroke-width', d => Math.sqrt(d.weight || 1)); + + // Create nodes + const node = g.append('g') + .selectAll('.node') + .data(data.nodes) + .join('g') + .attr('class', 'node') + .call(d3.drag() + .on('start', dragstarted) + .on('drag', dragged) + .on('end', dragended)); + + // Add circles to nodes + node.append('circle') + .attr('r', 10) + .attr('fill', d => color(d.type)) + .attr('stroke', '#fff') + .attr('stroke-width', 1.5); + + // Add labels to nodes + node.append('text') + .attr('dx', 12) + .attr('dy', '.35em') + .text(d => d.label) + .attr('fill', '#fff'); + + // Add tooltips + node.append('title') + .text(d => `${d.label}\nType: ${d.type}\n${d.description || ''}`); + + // Update positions on tick + simulation.on('tick', () => { + link + .attr('x1', d => d.source.x) + .attr('y1', d => d.source.y) + .attr('x2', d => d.target.x) + .attr('y2', d => d.target.y); + + node.attr('transform', d => `translate(${d.x},${d.y})`); + }); + + // Drag functions + function dragstarted(event, d) { + if (!event.active) simulation.alphaTarget(0.3).restart(); + d.fx = d.x; + d.fy = d.y; + } + + function dragged(event, d) { + d.fx = event.x; + d.fy = event.y; + } + + function dragended(event, d) { + if (!event.active) simulation.alphaTarget(0); + d.fx = null; + d.fy = null; + } + + // Cleanup + return () => { + simulation.stop(); + }; + }, [data]); + + return ( +
+
+ + Zoom In}> + } + onClick={handleZoomIn} + disabled={zoomLevel >= 8} + appearance="subtle" + size="sm" + /> + + + Zoom Out}> + } + onClick={handleZoomOut} + disabled={zoomLevel <= 0.1} + appearance="subtle" + size="sm" + /> + + + Reset Zoom}> + } + onClick={handleResetZoom} + appearance="subtle" + size="sm" + /> + + + {isFullScreen ? 'Exit Full Screen' : 'Full Screen'}}> + } + onClick={toggleFullScreen} + appearance="subtle" + size="sm" + /> + + + +
+ {Math.round(zoomLevel * 100)}% +
+
+ + +
+ ); +}; + +export default Graph; diff --git a/Demo/frontend/src/components/knowledge-graph/QueryForm.js b/Demo/frontend/src/components/knowledge-graph/QueryForm.js new file mode 100644 index 0000000..0684492 --- /dev/null +++ b/Demo/frontend/src/components/knowledge-graph/QueryForm.js @@ -0,0 +1,39 @@ +import React, { useState } from 'react'; +import { Form, InputGroup, Input, Loader } from 'rsuite'; +import SearchIcon from '@rsuite/icons/Search'; + +const QueryForm = ({ onSubmit, isLoading }) => { + const [query, setQuery] = useState(''); + + const handleSubmit = () => { + if (query.trim() && !isLoading) { + onSubmit(query); + } + }; + + const handleKeyPress = (event) => { + if (event.key === 'Enter') { + event.preventDefault(); + handleSubmit(); + } + }; + + return ( +
+ + + + {isLoading ? : } + + +
+ ); +}; + +export default QueryForm; diff --git a/Demo/frontend/src/context/AuthContext.js b/Demo/frontend/src/context/AuthContext.js new file mode 100644 index 0000000..1cc57fc --- /dev/null +++ b/Demo/frontend/src/context/AuthContext.js @@ -0,0 +1,131 @@ +import React, { createContext, useState, useContext, useEffect } from 'react'; +import { authAPI } from '../services/api'; +import jwt_decode from 'jwt-decode'; + +// Create auth context +const AuthContext = createContext(); + +// Auth provider component +export const AuthProvider = ({ children }) => { + const [currentUser, setCurrentUser] = useState(null); + const [isAuthenticated, setIsAuthenticated] = useState(false); + const [isLoading, setIsLoading] = useState(true); + const [error, setError] = useState(null); + + // Check if token is valid + const isTokenValid = (token) => { + if (!token) return false; + + try { + const decoded = jwt_decode(token); + const currentTime = Date.now() / 1000; + + return decoded.exp > currentTime; + } catch (error) { + return false; + } + }; + + // Load user from token + const loadUser = async () => { + setIsLoading(true); + + const token = localStorage.getItem('token'); + + if (token && isTokenValid(token)) { + try { + const response = await authAPI.getCurrentUser(); + setCurrentUser(response.data); + setIsAuthenticated(true); + } catch (error) { + localStorage.removeItem('token'); + setCurrentUser(null); + setIsAuthenticated(false); + setError('Session expired. Please login again.'); + } + } else { + localStorage.removeItem('token'); + setCurrentUser(null); + setIsAuthenticated(false); + } + + setIsLoading(false); + }; + + // Login user + const login = async (username, password) => { + setIsLoading(true); + setError(null); + + try { + const response = await authAPI.login(username, password); + const { access_token } = response.data; + + localStorage.setItem('token', access_token); + + await loadUser(); + + return true; + } catch (error) { + setError(error.response?.data?.detail || 'Login failed. Please try again.'); + setIsLoading(false); + return false; + } + }; + + // Register user + const register = async (userData) => { + setIsLoading(true); + setError(null); + + try { + await authAPI.register(userData); + + // Login after successful registration + const loginSuccess = await login(userData.username, userData.password); + + return loginSuccess; + } catch (error) { + setError(error.response?.data?.detail || 'Registration failed. Please try again.'); + setIsLoading(false); + return false; + } + }; + + // Logout user + const logout = () => { + localStorage.removeItem('token'); + setCurrentUser(null); + setIsAuthenticated(false); + }; + + // Load user on initial render + useEffect(() => { + loadUser(); + // eslint-disable-next-line react-hooks/exhaustive-deps + }, []); + + // Context value + const value = { + currentUser, + isAuthenticated, + isLoading, + error, + login, + register, + logout, + }; + + return {children}; +}; + +// Custom hook to use auth context +export const useAuth = () => { + const context = useContext(AuthContext); + + if (!context) { + throw new Error('useAuth must be used within an AuthProvider'); + } + + return context; +}; diff --git a/Demo/frontend/src/context/ThemeContext.js b/Demo/frontend/src/context/ThemeContext.js new file mode 100644 index 0000000..aae9159 --- /dev/null +++ b/Demo/frontend/src/context/ThemeContext.js @@ -0,0 +1,166 @@ +import React, { createContext, useContext, useState, useEffect } from 'react'; +import { useAuth } from './AuthContext'; +import { userAPI } from '../services/api'; + +// Define theme color schemes +export const themes = { + blue: { + name: 'Ocean Blue', + primary: '#1E88E5', + 'primary-rgb': '30, 136, 229', + secondary: '#0D47A1', + accent: '#90CAF9', + background: '#F5F9FF', + contentBg: '#FFFFFF', + sidebar: '#1E3A5F', + sidebarHover: '#0D47A1', /* Same as navActive for consistency */ + navActive: '#0D47A1', + text: '#2A3747', + textLight: '#FFFFFF', + textMuted: '#A4B8D3', + border: '#E2E8F0', + cardBg: '#FFFFFF', + success: '#4CAF50', + warning: '#FF9800', + error: '#F44336', + info: '#2196F3', + headerBg: '#1E3A5F', + headerText: '#FFFFFF', + panelBg: '#FFFFFF', + inputBg: '#F8FAFC', + dropdownBg: '#FFFFFF', + dropdownHover: '#F0F7FF', + shadow: 'rgba(0, 0, 0, 0.1)', + }, + red: { + name: 'Ruby Red', + primary: '#E53935', + 'primary-rgb': '229, 57, 53', + secondary: '#B71C1C', + accent: '#FFCDD2', + background: '#FFF5F5', + contentBg: '#FFFFFF', + sidebar: '#8B2E2E', + sidebarHover: '#B71C1C', /* Same as navActive for consistency */ + navActive: '#B71C1C', + text: '#3A2A2A', + textLight: '#FFFFFF', + textMuted: '#D4A6A6', + border: '#EFE0E0', + cardBg: '#FFFFFF', + success: '#4CAF50', + warning: '#FF9800', + error: '#F44336', + info: '#2196F3', + headerBg: '#8B2E2E', + headerText: '#FFFFFF', + panelBg: '#FFFFFF', + inputBg: '#FFF8F8', + dropdownBg: '#FFFFFF', + dropdownHover: '#FFF0F0', + shadow: 'rgba(0, 0, 0, 0.1)', + }, + violet: { + name: 'Royal Purple', + primary: '#7E57C2', + 'primary-rgb': '126, 87, 194', + secondary: '#4527A0', + accent: '#D1C4E9', + background: '#F8F5FF', + contentBg: '#FFFFFF', + sidebar: '#503D8B', /* Matches the screenshot purple */ + sidebarHover: '#3A2D66', /* Same as navActive for consistency */ + navActive: '#3A2D66', /* Darker purple for active items */ + text: '#2D2A3A', + textLight: '#FFFFFF', + textMuted: '#B9B0D6', + border: '#E6E0F0', + cardBg: '#FFFFFF', + success: '#4CAF50', + warning: '#FF9800', + error: '#F44336', + info: '#2196F3', + headerBg: '#503D8B', + headerText: '#FFFFFF', + panelBg: '#FFFFFF', + inputBg: '#F9F7FC', + dropdownBg: '#FFFFFF', + dropdownHover: '#F3EEFF', + shadow: 'rgba(0, 0, 0, 0.1)', + } +}; + +// Create the context +const ThemeContext = createContext(); + +// Create the provider component +export const ThemeProvider = ({ children }) => { + const { currentUser, isAuthenticated } = useAuth(); + + // Get theme from user preferences, localStorage, or use default + const [currentTheme, setCurrentTheme] = useState(() => { + // First try to get from localStorage + const savedTheme = localStorage.getItem('theme'); + return savedTheme && themes[savedTheme] ? savedTheme : 'blue'; + }); + + // Update theme when user logs in + useEffect(() => { + if (isAuthenticated && currentUser?.theme && themes[currentUser.theme]) { + setCurrentTheme(currentUser.theme); + } + }, [isAuthenticated, currentUser]); + + // Apply theme to document root for CSS variables + useEffect(() => { + const theme = themes[currentTheme]; + const root = document.documentElement; + + // Set CSS variables + Object.entries(theme).forEach(([key, value]) => { + if (key !== 'name') { + root.style.setProperty(`--${key}`, value); + } + }); + + // Save to localStorage + localStorage.setItem('theme', currentTheme); + }, [currentTheme]); + + // Change theme function + const changeTheme = async (themeName) => { + if (themes[themeName]) { + setCurrentTheme(themeName); + + // If user is authenticated, save theme preference to backend + if (isAuthenticated) { + try { + // Update user theme preference in the backend + await userAPI.updateTheme(themeName); + } catch (error) { + console.error('Failed to save theme preference:', error); + } + } + } + }; + + return ( + + {children} + + ); +}; + +// Custom hook to use the theme context +export const useTheme = () => { + const context = useContext(ThemeContext); + if (!context) { + throw new Error('useTheme must be used within a ThemeProvider'); + } + return context; +}; diff --git a/Demo/frontend/src/index.css b/Demo/frontend/src/index.css new file mode 100644 index 0000000..b813b9f --- /dev/null +++ b/Demo/frontend/src/index.css @@ -0,0 +1,33 @@ +body { + margin: 0; + font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', + 'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', + sans-serif; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; + background-color: #1a1d24; + color: #fff; +} + +code { + font-family: source-code-pro, Menlo, Monaco, Consolas, 'Courier New', + monospace; +} + +/* Custom scrollbar */ +::-webkit-scrollbar { + width: 8px; +} + +::-webkit-scrollbar-track { + background: #1a1d24; +} + +::-webkit-scrollbar-thumb { + background: #3c3f43; + border-radius: 4px; +} + +::-webkit-scrollbar-thumb:hover { + background: #555; +} diff --git a/Demo/frontend/src/index.js b/Demo/frontend/src/index.js new file mode 100644 index 0000000..01ad106 --- /dev/null +++ b/Demo/frontend/src/index.js @@ -0,0 +1,21 @@ +import React from 'react'; +import ReactDOM from 'react-dom/client'; +import './index.css'; +import App from './App'; +import { BrowserRouter } from 'react-router-dom'; +import { AuthProvider } from './context/AuthContext'; +import { ThemeProvider } from './context/ThemeContext'; +import 'rsuite/dist/rsuite.min.css'; + +const root = ReactDOM.createRoot(document.getElementById('root')); +root.render( + + + + + + + + + +); diff --git a/Demo/frontend/src/pages/Chat.js b/Demo/frontend/src/pages/Chat.js new file mode 100644 index 0000000..98d41a5 --- /dev/null +++ b/Demo/frontend/src/pages/Chat.js @@ -0,0 +1,233 @@ +import React, { useState, useEffect, useRef } from 'react'; +import { Container, Panel, InputGroup, Button, Loader, SelectPicker, Divider } from 'rsuite'; +import { FontAwesomeIcon } from '@fortawesome/react-fontawesome'; +import { faPaperPlane, faSpinner } from '@fortawesome/free-solid-svg-icons'; +import { chatAPI } from '../services/api'; +import ChatMessage from '../components/chat/ChatMessage'; +import Layout from '../components/Layout'; +import '../styles/chat.css'; + +// Search context options +const contextOptions = [ + { label: 'All Documents', value: 'all' }, + { label: 'Recent Documents', value: 'recent' }, + { label: 'Selected Documents', value: 'selected' }, + { label: 'Knowledge Graph', value: 'knowledge_graph' } +]; + +const Chat = () => { + const [messages, setMessages] = useState([]); + const [input, setInput] = useState(''); + const [isLoading, setIsLoading] = useState(false); + const [searchContext, setSearchContext] = useState('all'); + const messagesEndRef = useRef(null); + const chatContainerRef = useRef(null); + + // Scroll to bottom whenever messages change + useEffect(() => { + scrollToBottom(); + }, [messages]); + + const scrollToBottom = () => { + messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' }); + }; + + const handleSend = async () => { + if (!input.trim()) return; + + // Add user message to chat + const userMessage = { + id: Date.now(), + content: input, + sender: 'user', + timestamp: new Date().toISOString() + }; + + setMessages(prev => [...prev, userMessage]); + setInput(''); + setIsLoading(true); + + try { + // Send message to API with search context + const response = await chatAPI.createChat({ + message: input, + context: searchContext + }); + + // Add bot response to chat + if (response && response.data) { + const botMessage = { + id: Date.now() + 1, + content: response.data.response || 'Sorry, I could not process your request.', + sender: 'bot', + timestamp: new Date().toISOString() + }; + + setMessages(prev => [...prev, botMessage]); + } + } catch (error) { + console.error('Error sending message:', error); + + // Add error message + const errorMessage = { + id: Date.now() + 1, + content: 'Sorry, there was an error processing your request. Please try again.', + sender: 'bot', + error: true, + timestamp: new Date().toISOString() + }; + + setMessages(prev => [...prev, errorMessage]); + } finally { + setIsLoading(false); + } + }; + + const handleKeyPress = (e) => { + if (e.key === 'Enter' && !e.shiftKey) { + e.preventDefault(); + handleSend(); + } + }; + + // Mock response for testing + const handleMockResponse = () => { + const mockResponses = [ + `Here's a simple markdown example: + +# Heading 1 +## Heading 2 + +- List item 1 +- List item 2 + +**Bold text** and *italic text* + +\`\`\`python +def hello_world(): + print("Hello, world!") +\`\`\` + `, + `Here's a mermaid diagram example: + +\`\`\`mermaid +graph TD + A[Client] --> B[Load Balancer] + B --> C[Server1] + B --> D[Server2] +\`\`\` + +And some more text after the diagram. + `, + `Let me explain the architecture: + +\`\`\`mermaid +sequenceDiagram + participant User + participant API + participant Database + + User->>API: Request data + API->>Database: Query + Database-->>API: Return results + API-->>User: Response +\`\`\` + +This shows the basic flow of information in our system. + ` + ]; + + const randomResponse = mockResponses[Math.floor(Math.random() * mockResponses.length)]; + + const botMessage = { + id: Date.now() + 1, + content: randomResponse, + sender: 'bot', + timestamp: new Date().toISOString() + }; + + setMessages(prev => [...prev, botMessage]); + }; + + return ( + + + +
+

Chat

+ +
+ + + +
+ {messages.length === 0 ? ( +
+

No messages yet. Start a conversation!

+
+ ) : ( + messages.map(message => ( + + )) + )} + + {isLoading && ( +
+ +
+ )} + +
+
+ +
+ + setInput(e.target.value)} + onKeyPress={handleKeyPress} + placeholder="Type your message..." + disabled={isLoading} + /> + + {isLoading ? ( + + ) : ( + + )} + + + + {/* Test button for mock responses - remove in production */} + +
+ + + + ); +}; + +export default Chat; diff --git a/Demo/frontend/src/pages/ChatPage.js b/Demo/frontend/src/pages/ChatPage.js new file mode 100644 index 0000000..55673c9 --- /dev/null +++ b/Demo/frontend/src/pages/ChatPage.js @@ -0,0 +1,212 @@ +import React, { useState, useEffect, useRef } from 'react'; +import { Loader } from 'rsuite'; +import { useParams, useNavigate } from 'react-router-dom'; +import Layout from '../components/Layout'; +import ChatMessage from '../components/chat/ChatMessage'; +import ChatInput from '../components/chat/ChatInput'; +import { chatAPI } from '../services/api'; +import { saveThreadUUID, getThreadUUID } from '../utils/threadStorage'; +import '../styles/chat.css'; + +const ChatPage = () => { + const { threadId } = useParams(); + const navigate = useNavigate(); + const [currentThreadId, setCurrentThreadId] = useState(threadId); + const [messages, setMessages] = useState([]); + const [loading, setLoading] = useState(true); + const [sending, setSending] = useState(false); + const [searchContext, setSearchContext] = useState('hybrid'); + const messagesEndRef = useRef(null); + const messagesContainerRef = useRef(null); + + // Check for thread ID or create a new one + useEffect(() => { + const initializeThread = async () => { + // If we have a thread ID in the URL, use it + if (threadId) { + setCurrentThreadId(threadId); + saveThreadUUID(threadId); + return; + } + + // If we have a thread ID in localStorage, redirect to it + const storedThreadId = getThreadUUID(); + if (storedThreadId) { + navigate(`/chat/${storedThreadId}`, { replace: true }); + return; + } + + // Otherwise, create a new thread + try { + const response = await chatAPI.createThread("New Chat"); + if (response && response.data && response.data.uuid) { + const newThreadId = response.data.uuid; + saveThreadUUID(newThreadId); + navigate(`/chat/${newThreadId}`, { replace: true }); + } + } catch (error) { + console.error("Failed to create new chat thread", error); + } + }; + + initializeThread(); + }, [threadId, navigate]); + + // Fetch chat history for the current thread + useEffect(() => { + const fetchThreadChats = async () => { + if (!currentThreadId) return; + + setLoading(true); + + try { + const response = await chatAPI.getThread(currentThreadId); + + if (response && response.data && response.data.chats) { + // Format messages from the thread + const formattedMessages = response.data.chats.map((chat) => ({ + id: `${chat.id}`, + content: chat.message, + isUser: chat.role === 'user', + })); + + setMessages(formattedMessages); + } + } catch (error) { + console.error('Error fetching thread chats:', error); + } finally { + setLoading(false); + } + }; + + if (currentThreadId) { + fetchThreadChats(); + } + }, [currentThreadId]); + + // Function to scroll to bottom + const scrollToBottom = () => { + if (messagesEndRef.current) { + messagesEndRef.current.scrollIntoView({ + behavior: 'smooth', + block: 'end' + }); + } + + // Alternative method using the container + if (messagesContainerRef.current) { + messagesContainerRef.current.scrollTop = messagesContainerRef.current.scrollHeight; + } + }; + + // Scroll to bottom when messages change + useEffect(() => { + scrollToBottom(); + }, [messages, sending]); + + // Send message + const handleSendMessage = async (message) => { + if (!message.trim() || sending || !currentThreadId) return; + + // Add user message to state + const userMessage = { + id: `temp-${Date.now()}-user`, + content: message, + isUser: true, + }; + + setMessages((prevMessages) => [...prevMessages, userMessage]); + setSending(true); + + try { + // Send message to API with thread UUID and search mode + console.log(`Sending message to thread ${currentThreadId} with search mode: ${searchContext}`); + const response = await chatAPI.sendChatToThread(currentThreadId, searchContext, message); + + if (response && response.data) { + // Refresh the thread to get both user message and AI response + const threadResponse = await chatAPI.getThread(currentThreadId); + + if (threadResponse && threadResponse.data && threadResponse.data.chats) { + // Format messages from the thread + const formattedMessages = threadResponse.data.chats.map((chat) => ({ + id: `${chat.id}`, + content: chat.message, + isUser: chat.role === 'user', + })); + + setMessages(formattedMessages); + } + } + } catch (error) { + console.error('Error sending message:', error); + + // Add error message + const errorMessage = { + id: `error-${Date.now()}`, + content: 'Sorry, there was an error processing your request.', + isUser: false, + }; + + setMessages((prevMessages) => [...prevMessages, errorMessage]); + } finally { + setSending(false); + } + }; + + + return ( + +
+
+
+ {loading ? ( +
+ +
+ ) : messages.length === 0 ? ( +
+

No messages yet. Start a conversation!

+
+ ) : ( +
+ {messages.map((message) => ( +
+ +
+ ))} + + {sending && ( +
+
+ +
+
+ )} + +
+
+ )} +
+
+ +
+ +
+
+ + ); +}; + +export default ChatPage; diff --git a/Demo/frontend/src/pages/Dashboard.js b/Demo/frontend/src/pages/Dashboard.js new file mode 100644 index 0000000..02edc45 --- /dev/null +++ b/Demo/frontend/src/pages/Dashboard.js @@ -0,0 +1,89 @@ +import React, { useState, useEffect } from 'react'; +import { Panel, Grid, Row, Col, Placeholder } from 'rsuite'; +import Layout from '../components/Layout'; +import { chatAPI, documentAPI, knowledgeGraphAPI } from '../services/api'; + +const Dashboard = () => { + const [loading, setLoading] = useState(true); + const [stats, setStats] = useState({ + chats: 0, + documents: 0, + graphNodes: 0, + graphEdges: 0, + }); + + useEffect(() => { + const fetchStats = async () => { + setLoading(true); + + try { + // Fetch chats + const chatsResponse = await chatAPI.getChats(); + + // Fetch documents + const documentsResponse = await documentAPI.getDocuments(); + + // Fetch knowledge graph + const graphResponse = await knowledgeGraphAPI.getGraph(); + + // Update stats + setStats({ + chats: chatsResponse.data.chats.length, + documents: documentsResponse.data.documents.length, + graphNodes: graphResponse.data.nodes.length, + graphEdges: graphResponse.data.edges.length, + }); + } catch (error) { + console.error('Error fetching stats:', error); + } finally { + setLoading(false); + } + }; + + fetchStats(); + }, []); + + return ( + +

Dashboard

+ + {loading ? ( + + ) : ( + + + + +

{stats.chats}

+

Total chat conversations

+ + + + + +

{stats.documents}

+

Uploaded documents

+ + + + + +

{stats.graphNodes}

+

Entities in knowledge graph

+ + + + + +

{stats.graphEdges}

+

Relationships in knowledge graph

+ + + + + )} + + ); +}; + +export default Dashboard; diff --git a/Demo/frontend/src/pages/DocumentsPage.js b/Demo/frontend/src/pages/DocumentsPage.js new file mode 100644 index 0000000..59eee58 --- /dev/null +++ b/Demo/frontend/src/pages/DocumentsPage.js @@ -0,0 +1,105 @@ +import React, { useState, useEffect } from 'react'; +import { Button, Modal, Message } from 'rsuite'; +import Layout from '../components/Layout'; +import DocumentList from '../components/documents/DocumentList'; +import DocumentUploader from '../components/documents/DocumentUploader'; +import { documentAPI } from '../services/api'; +import '../styles/documents.css'; + +const DocumentsPage = () => { + const [documents, setDocuments] = useState([]); + const [loading, setLoading] = useState(true); + const [reloading, setReloading] = useState(false); + const [error, setError] = useState(null); + const [showUploadModal, setShowUploadModal] = useState(false); + + // Fetch documents + const fetchDocuments = async () => { + setLoading(true); + setError(null); + + try { + const response = await documentAPI.getDocuments(); + setDocuments(response.data.documents); + } catch (error) { + console.error('Error fetching documents:', error); + setError('Failed to load documents'); + } finally { + setLoading(false); + } + }; + + // Fetch documents on mount + useEffect(() => { + fetchDocuments(); + }, []); + + // Handle upload complete + const handleUploadComplete = (document) => { + setShowUploadModal(false); + fetchDocuments(); + }; + + // Reload PathRAG to recognize new documents + const handleReloadDocuments = async () => { + try { + setReloading(true); + const response = await documentAPI.reloadDocuments(); + if (response && response.data && response.data.success) { + Message.success(response.data.message || 'Documents reloaded successfully'); + } + } catch (error) { + console.error('Error reloading documents:', error); + Message.error('Failed to reload documents. Please try again.'); + } finally { + setReloading(false); + } + }; + + return ( + +
+

Documents

+
+ + +
+
+ + {error && {error}} + + + + setShowUploadModal(false)} + size="md" + > + + Upload Document + + + + + + + + + + + + ); +}; + +export default DocumentsPage; diff --git a/Demo/frontend/src/pages/KnowledgeGraphPage.js b/Demo/frontend/src/pages/KnowledgeGraphPage.js new file mode 100644 index 0000000..615ba15 --- /dev/null +++ b/Demo/frontend/src/pages/KnowledgeGraphPage.js @@ -0,0 +1,76 @@ +import React, { useState, useEffect } from 'react'; +import { Panel, Loader, Message } from 'rsuite'; +import Layout from '../components/Layout'; +import Graph from '../components/knowledge-graph/Graph'; +import QueryForm from '../components/knowledge-graph/QueryForm'; +import { knowledgeGraphAPI } from '../services/api'; +import '../styles/knowledge-graph.css'; + +const KnowledgeGraphPage = () => { + const [graphData, setGraphData] = useState(null); + const [loading, setLoading] = useState(true); + const [querying, setQuerying] = useState(false); + const [error, setError] = useState(null); + + // Fetch initial graph data + useEffect(() => { + const fetchGraph = async () => { + setLoading(true); + setError(null); + + try { + const response = await knowledgeGraphAPI.getGraph(); + setGraphData(response.data); + } catch (error) { + console.error('Error fetching graph:', error); + setError('Failed to load knowledge graph'); + } finally { + setLoading(false); + } + }; + + fetchGraph(); + }, []); + + // Handle query submission + const handleQuerySubmit = async (query) => { + if (!query.trim() || querying) return; + + setQuerying(true); + setError(null); + + try { + const response = await knowledgeGraphAPI.queryGraph(query); + setGraphData(response.data); + } catch (error) { + console.error('Error querying graph:', error); + setError('Failed to query knowledge graph'); + } finally { + setQuerying(false); + } + }; + + return ( + + + + {error && {error}} + + + {loading ? ( +
+ +
+ ) : !graphData || graphData.nodes.length === 0 ? ( +
+

No knowledge graph data available. Try uploading some documents first.

+
+ ) : ( + + )} + + + ); +}; + +export default KnowledgeGraphPage; diff --git a/Demo/frontend/src/pages/Login.js b/Demo/frontend/src/pages/Login.js new file mode 100644 index 0000000..36c5bfd --- /dev/null +++ b/Demo/frontend/src/pages/Login.js @@ -0,0 +1,37 @@ +import React from 'react'; +import { Container, Content, Panel, FlexboxGrid, Button } from 'rsuite'; +import { Link, Navigate } from 'react-router-dom'; +import LoginForm from '../components/auth/LoginForm'; +import { useAuth } from '../context/AuthContext'; + +const Login = () => { + const { isAuthenticated } = useAuth(); + + // Redirect if already authenticated + if (isAuthenticated) { + return ; + } + + return ( + + + + + PathRAG - Enterprise Knowledge Graph

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%0D^t(EWZvesf3D45K}JR< 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