diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000000000000000000000000000000000000..cf8fa3a7b35495a317a27742f6b48d53b709cdf9 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,42 @@ +# Generated data & model artifacts +engine_state/ +chroma_epstein/ +checkpoints/ +trained_model/ + +# Python +__pycache__/ +*.py[cod] +.venv/ +venv/ +*.egg-info/ + +# Node (frontend is built inside Docker) +frontend/node_modules/ +frontend/dist/ + +# Git +.git/ +.gitattributes + +# OS & IDE +.DS_Store +.vscode/ +.idea/ + +# HuggingFace cache +.cache/ + +# Docs (not needed in image) +HOWTO.md +README.md + +# Docker (avoid recursive COPY) +Dockerfile +docker-compose.yml +.dockerignore + +# Env & logs +.env +.env.local +*.log diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..7f35e63e1bb7a8949db5335823358c62e3ba3358 --- /dev/null +++ b/.gitignore @@ -0,0 +1,55 @@ +# Python +__pycache__/ +*.py[cod] +*$py.class +*.so +*.egg-info/ +*.egg +dist/ +build/ +.venv/ +venv/ +.Python + +# Node / Frontend +frontend/node_modules/ +frontend/dist/ +frontend/dist-ssr/ +npm-debug.log* +yarn-debug.log* +pnpm-debug.log* + +# Generated data & model artifacts +engine_state/ +chroma_epstein/ +checkpoints/ +trained_model/ +*.faiss +*.npy +*.pkl +*.pickle + +# HuggingFace cache +.cache/ + +# OS +.DS_Store +Thumbs.db + +# IDEs +.vscode/ +.idea/ +*.swp +*.swo +*.suo +*.ntvs* +*.njsproj +*.sln + +# Environment +.env +.env.local +.env.*.local + +# Logs +*.log diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..d0b0654d1186c73ae0e1c26fca5143f78b093d8f --- /dev/null +++ b/Dockerfile @@ -0,0 +1,59 @@ +# ============================================================= +# Multi-stage Docker build for Contextual Similarity Engine +# Single container: React frontend + FastAPI backend +# Deploys to: HuggingFace Spaces (Docker SDK), local, Railway +# ============================================================= + +# Stage 1: Build frontend +FROM node:22-slim AS frontend-build +WORKDIR /app/frontend +COPY frontend/package.json frontend/package-lock.json ./ +RUN npm ci +COPY frontend/ ./ +RUN npm run build + +# Stage 2: Python runtime +FROM python:3.12-slim AS runtime + +# Create non-root user (required by HF Spaces) +RUN useradd -m -u 1000 appuser +WORKDIR /app + +# System deps for faiss-cpu and torch +RUN apt-get update && apt-get install -y --no-install-recommends \ + build-essential \ + && rm -rf /var/lib/apt/lists/* + +# Install uv for fast dependency resolution +COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv + +# Copy dependency files first (cache layer) +COPY --chown=appuser pyproject.toml uv.lock ./ + +# Install Python dependencies +RUN uv sync --frozen --no-dev + +# Copy backend source +COPY --chown=appuser *.py ./ + +# Copy pre-built frontend +COPY --chown=appuser --from=frontend-build /app/frontend/dist ./frontend/dist + +# Data directories (HF cache, engine state, trained models) +RUN mkdir -p /data/huggingface /data/engine_state /data/trained_model \ + && chown -R appuser:appuser /app /data + +ENV HF_HOME=/data/huggingface +ENV TRANSFORMERS_CACHE=/data/huggingface +ENV ENGINE_STATE_DIR=/data/engine_state + +# Switch to non-root user +USER appuser + +# Expose port (HF Spaces expects 7860, override via PORT env) +EXPOSE 7860 + +# Run the server — HOST and PORT configurable via env +ENV HOST=0.0.0.0 +ENV PORT=7860 +CMD ["uv", "run", "python", "server.py"] diff --git a/HOWTO.md b/HOWTO.md new file mode 100644 index 0000000000000000000000000000000000000000..28f76941931517960c1f508ebde5868a304dd5a0 --- /dev/null +++ b/HOWTO.md @@ -0,0 +1,390 @@ +# Contextual Similarity Engine — HOWTO + +## Overview + +This project uses **transformer-based sentence embeddings** to find and compare +contextual meanings of keywords within large documents. Unlike Word2Vec (static, +one-vector-per-word), this system **fine-tunes on YOUR corpus** so it learns +domain-specific patterns — e.g. that "pizza" means "school" in your data. + +A **Word2Vec (gensim) baseline** is included for comparison, demonstrating why +contextual embeddings are superior for meaning disambiguation. + +**The pipeline is: TRAIN → INDEX → ANALYZE → EVALUATE.** + +**Stack:** +- **SentenceTransformers** — contextual embeddings (PyTorch) +- **FAISS** — fast vector similarity search +- **gensim Word2Vec** — static embedding baseline for comparison +- **FastAPI** — REST API backend +- **React + TypeScript** — visualization frontend +- **scikit-learn** — clustering & evaluation metrics + +--- + +## 1. Install Dependencies + +### Python backend (uv — recommended) + +[uv](https://docs.astral.sh/uv/) is a fast Python package manager that replaces +`pip`, `venv`, and `requirements.txt` with a single tool and lockfile. + +```bash +# Install uv (if not already installed) +curl -LsSf https://astral.sh/uv/install.sh | sh + +# Create a virtual environment and install all dependencies from pyproject.toml +cd esfiles +uv sync + +# Run commands inside the managed environment +uv run python server.py +uv run python demo.py +``` + +`uv sync` reads `pyproject.toml`, resolves dependencies, creates a `.venv`, +and generates a `uv.lock` lockfile for reproducible installs. The lockfile +pins exact versions so every machine gets identical dependencies. + +**Adding/removing packages:** + +```bash +uv add httpx # add a new dependency +uv remove httpx # remove it +uv lock --upgrade # upgrade all packages to latest compatible versions +``` + +### Python backend (pip — alternative) + +```bash +python3 -m venv venv +source venv/bin/activate +pip install -r requirements.txt +``` + +### React frontend + +```bash +cd frontend +npm install +``` + +--- + +## 2. Quick Start + +### CLI demo (Word2Vec vs Transformer comparison) + +```bash +uv run python demo.py +``` + +This runs side-by-side comparison: +1. Builds both Transformer and Word2Vec engines on the same corpus +2. Compares text similarity scores between approaches +3. Shows word-level similarity (Word2Vec only — transformers don't do single words) +4. Runs semantic search with both engines +5. Tests keyword meaning matching ("pizza" → food or school?) +6. Demonstrates clustering (transformer can separate meanings, Word2Vec cannot) + +### Web UI + +```bash +# Terminal 1: start the API server +uv run python server.py + +# Terminal 2: start the React dev server +cd frontend && npm run dev +``` + +- API docs: `http://localhost:8000/docs` +- Frontend: `http://localhost:5173` + +--- + +## 3. Training Your Model + +Three strategies, from simplest to most powerful: + +### Strategy 1: Unsupervised (TSDAE) + +No labels needed. Learns your corpus vocabulary and phrasing via denoising autoencoder. + +```python +from training import CorpusTrainer + +corpus_texts = [open(f).read() for f in your_files] +trainer = CorpusTrainer(corpus_texts, base_model="all-MiniLM-L6-v2") + +result = trainer.train_unsupervised( + output_path="./trained_model", + epochs=3, + batch_size=16, +) +print(f"Trained on {result['training_pairs']} sentences in {result['seconds']}s") +``` + +### Strategy 2: Contrastive (auto-mined pairs) + +Adjacent sentences = similar, random sentences = dissimilar. Learns document structure +using MultipleNegativesRankingLoss with in-batch negatives. + +```python +trainer = CorpusTrainer(corpus_texts) + +result = trainer.train_contrastive( + output_path="./trained_model", + epochs=5, + batch_size=16, +) +``` + +### Strategy 3: Keyword-supervised (best if you know the code words) + +You provide a keyword→meaning map. The trainer auto-generates training pairs: +keyword-in-context ↔ meaning-substituted version, plus contrastive pairs from +corpus structure. + +```python +trainer = CorpusTrainer(corpus_texts) + +result = trainer.train_with_keywords( + keyword_meanings={"pizza": "school", "pepperoni": "math class"}, + output_path="./trained_model", + epochs=5, + batch_size=16, +) +print(f"Keywords: {result['keywords']}") +``` + +### Verifying training worked + +```python +# Compare base model vs trained model on test pairs +comparison = trainer.evaluate_model( + test_pairs=[ + ("pizza gives me homework", "school gives me homework", 0.95), + ("pizza gives me homework", "I ate delicious pizza", 0.1), + ("The pizza test is hard", "The school exam is difficult", 0.9), + ], + trained_model_path="./trained_model", +) + +print(f"Base error: {comparison['summary']['avg_base_error']:.4f}") +print(f"Trained error: {comparison['summary']['avg_trained_error']:.4f}") +print(f"Reduction: {comparison['summary']['error_reduction_pct']:.1f}%") +print(f"Improved: {comparison['summary']['improved']}/{comparison['summary']['total']}") +``` + +--- + +## 4. Using Your Trained Model + +After training, use the saved model path instead of the pretrained model name: + +```python +from contextual_similarity import ContextualSimilarityEngine + +engine = ContextualSimilarityEngine(model_name="./trained_model") + +engine.add_document("doc1", open("doc1.txt").read()) +engine.build_index() + +# Queries now use your domain-trained embeddings +results = engine.query("pizza homework", top_k=10) +matches = engine.match_keyword_to_meaning("pizza", [ + "Italian food, restaurant, cooking", + "School, education, homework and tests", +]) +``` + +--- + +## 5. Word2Vec Baseline Comparison + +A gensim Word2Vec engine is included to demonstrate the difference between +static and contextual embeddings: + +```python +from word2vec_baseline import Word2VecEngine + +w2v = Word2VecEngine(vector_size=100, window=5, epochs=50) +for doc_id, text in docs.items(): + w2v.add_document(doc_id, text) +w2v.build_index() + +# Word-level: which words appear in similar contexts? +w2v.most_similar_words("pizza", top_k=5) + +# Sentence-level: averaged word vectors (lossy) +w2v.compare_texts("pizza gives me homework", "school gives me homework") + +# Search +w2v.query("a place where children learn", top_k=3) +``` + +**Key limitation:** Word2Vec gives ONE vector per word. "pizza" always has the +same embedding whether it means food or school. Transformers encode the full +surrounding context, so the same word gets different embeddings in different passages. + +--- + +## 6. Using the Web UI + +1. **Train Model** (start here): + - Paste your corpus (documents separated by blank lines) + - Choose strategy: Unsupervised, Contrastive, or Keyword-supervised + - For keyword strategy, provide a JSON keyword→meaning map + - Configure base model, epochs, batch size, output path + - Click "Start Training" — model trains and saves to disk + - Run "Compare Models" to evaluate base vs trained + +2. **Setup:** + - Initialize engine with your trained model path (e.g. `./trained_model`) + - Add documents and build the FAISS index + +3. **Semantic Search:** query the corpus with trained embeddings +4. **Compare Texts:** cosine similarity between any two texts +5. **Keyword Analysis:** auto-cluster keyword meanings across documents +6. **Keyword Matcher:** match keyword occurrences to candidate meanings +7. **Batch Analysis:** multi-keyword analysis with cross-similarity matrix +8. **Evaluation:** disambiguation accuracy, retrieval P@K/MRR, similarity histograms + +--- + +## 7. API Endpoints + +### Training +| Method | Endpoint | Description | +|--------|----------|-------------| +| POST | `/api/train/unsupervised` | TSDAE domain adaptation | +| POST | `/api/train/contrastive` | Contrastive with auto-mined pairs | +| POST | `/api/train/keywords` | Keyword-supervised training | +| POST | `/api/train/evaluate` | Compare base vs trained model | + +### Engine +| Method | Endpoint | Description | +|--------|----------|-------------| +| POST | `/api/init` | Initialize engine with a model | +| POST | `/api/documents` | Add a document to the corpus | +| POST | `/api/documents/upload` | Upload a file as a document | +| POST | `/api/index/build` | Build FAISS index | +| POST | `/api/query` | Semantic search | +| POST | `/api/compare` | Compare two texts | +| POST | `/api/analyze/keyword` | Single keyword analysis | +| POST | `/api/analyze/batch` | Multi-keyword batch analysis | +| POST | `/api/match` | Match keyword to candidate meanings | +| GET | `/api/stats` | Corpus statistics | + +### Evaluation +| Method | Endpoint | Description | +|--------|----------|-------------| +| POST | `/api/eval/disambiguation` | Disambiguation accuracy | +| POST | `/api/eval/retrieval` | Retrieval metrics (P@K, MRR, NDCG) | +| GET | `/api/eval/similarity-distribution` | Pairwise similarity histogram | + +### Word2Vec Baseline +| Method | Endpoint | Description | +|--------|----------|-------------| +| POST | `/api/w2v/init` | Train Word2Vec on corpus | +| POST | `/api/w2v/compare` | Compare two texts (averaged word vectors) | +| POST | `/api/w2v/query` | Search corpus | +| POST | `/api/w2v/similar-words` | Find similar words | + +--- + +## 8. Available Base Models + +| Model | Dim | Size | Quality | Speed | +|-------|-----|------|---------|-------| +| `all-MiniLM-L6-v2` | 384 | ~80MB | Good | Fast | +| `all-mpnet-base-v2` | 768 | ~420MB | Best | Medium | + +Start with `all-MiniLM-L6-v2` for fast iteration, upgrade to `all-mpnet-base-v2` +for production quality. + +--- + +## 9. Evaluation Metrics + +| Metric | What it measures | +|--------|-----------------| +| **Accuracy** | % of keyword occurrences correctly matched to their meaning | +| **Weighted F1** | Harmonic mean of precision/recall, weighted by class frequency | +| **MRR** | Mean Reciprocal Rank — how early the first relevant result appears | +| **P@K** | Precision at K — fraction of top-K results that are relevant | +| **NDCG@K** | Normalized Discounted Cumulative Gain — ranking quality metric | + +--- + +## 10. Tuning Parameters + +### Training + +| Parameter | Default | Notes | +|-----------|---------|-------| +| `epochs` | 3-5 | More = better fit but risk overfitting | +| `batch_size` | 16 | Larger = faster, needs more memory. MNRL benefits from larger batches | +| `context_window` | 2 | (Keyword strategy) sentences around keyword to include as context | + +### Engine + +| Parameter | Default | Notes | +|-----------|---------|-------| +| `chunk_size` | 512 | Characters per chunk. Larger = more context per chunk | +| `chunk_overlap` | 128 | Overlap prevents losing context at chunk boundaries | +| `batch_size` | 64 | Encoding batch size for FAISS indexing | + +--- + +## 11. Computational Resources + +| Task | CPU | GPU (CUDA/MPS) | RAM | +|------|-----|----------------|-----| +| Training (small, <1K pairs) | OK | Faster (2-5x) | 4GB+ | +| Training (medium, 1K-10K pairs) | Slow | Recommended | 8GB+ | +| Training (large, 10K+ pairs) | Very slow | Required | 16GB+ | +| Indexing (1K chunks) | OK | Faster | 4GB+ | +| Querying | Fast | N/A | 2GB+ | + +**Minimum:** MacBook with 8GB RAM can train small models on CPU. +**Recommended:** 16GB RAM + GPU (NVIDIA CUDA or Apple Silicon MPS). + +--- + +## 12. Project Structure + +``` +esfiles/ +├── pyproject.toml # Project config & dependencies (uv) +├── requirements.txt # Fallback for pip users +├── contextual_similarity.py # Core engine: chunking, embedding, FAISS, analysis +├── training.py # Training pipeline: 3 strategies + evaluation +├── evaluation.py # Evaluation pipeline: metrics, reports +├── word2vec_baseline.py # Gensim Word2Vec baseline for comparison +├── server.py # FastAPI REST API +├── demo.py # CLI demo: Word2Vec vs Transformer comparison +├── HOWTO.md # This file +└── frontend/ # React + TypeScript UI + ├── package.json + ├── tsconfig.json + ├── vite.config.ts + ├── index.html + └── src/ + ├── main.tsx + ├── App.tsx + ├── styles.css + ├── types.ts + ├── api.ts + └── components/ + ├── ScoreBar.tsx + ├── StatusMessage.tsx + ├── TrainingPanel.tsx + ├── EngineSetup.tsx + ├── SemanticSearch.tsx + ├── TextCompare.tsx + ├── KeywordAnalysis.tsx + ├── KeywordMatcher.tsx + ├── BatchAnalysis.tsx + └── EvaluationDashboard.tsx +``` diff --git a/README.md b/README.md index bdf51b91d04f4393590c3e9887f8b4d8bfce05b6..d137af4b5f1712b78f46ae6f2fd15fbb7464d608 100644 --- a/README.md +++ b/README.md @@ -1,12 +1,203 @@ --- title: Esfiles -emoji: 🏢 +emoji: "\U0001F3E2" colorFrom: green colorTo: green sdk: docker +app_port: 7860 pinned: false license: apache-2.0 short_description: 'A prototype to analyze embeddings and word correlations ' --- -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference +# Esfiles — Contextual Similarity Engine + +A tool for analyzing word meanings in context using **transformer-based embeddings**. Unlike traditional approaches (Word2Vec) that assign one static vector per word, this system **fine-tunes on your corpus** so the same word gets different embeddings depending on its surrounding context — e.g. detecting that "pizza" is used as code for "school" in a set of documents. + +Includes a **Word2Vec baseline** for side-by-side comparison. + +## Stack + +| Layer | Technology | +|-------|-----------| +| Embeddings | SentenceTransformers (PyTorch) | +| Vector search | FAISS | +| Baseline | gensim Word2Vec | +| Backend | FastAPI (Python) | +| Frontend | React 19 + TypeScript + Vite | +| Evaluation | scikit-learn metrics | +| Deployment | Docker (HuggingFace Spaces, local, Railway) | + +## Prerequisites + +- **Python 3.11+** +- **Node.js 18+** (for frontend) +- [uv](https://docs.astral.sh/uv/) (recommended) or pip + +## Setup + +### 1. Clone the repo + +```bash +git clone +cd esfiles +``` + +### 2. Install Python dependencies + +**With uv (recommended):** + +```bash +curl -LsSf https://astral.sh/uv/install.sh | sh +uv sync +``` + +**With pip:** + +```bash +python3 -m venv venv +source venv/bin/activate +pip install -r requirements.txt +``` + +### 3. Install frontend dependencies + +```bash +cd frontend +npm install +cd .. +``` + +## Usage + +### CLI demo + +Run the Word2Vec vs Transformer comparison demo: + +```bash +uv run python demo.py +``` + +This builds both engines on a sample corpus and compares similarity scores, semantic search, keyword matching, and clustering. + +### Web UI (development) + +```bash +# Terminal 1 — API server +uv run python server.py + +# Terminal 2 — React dev server +cd frontend && npm run dev +``` + +- **API docs:** http://localhost:8000/docs +- **Frontend:** http://localhost:5173 + +### Docker + +```bash +docker compose up --build +``` + +The app will be available at http://localhost:8000. The Docker build compiles the React frontend and bundles it with the FastAPI server in a single container. + +## How it works + +**Pipeline: TRAIN → INDEX → ANALYZE → EVALUATE** + +1. **Train** — Fine-tune a pretrained sentence-transformer on your corpus using one of three strategies: + - **Unsupervised (TSDAE):** No labels needed. Learns vocabulary and phrasing via denoising autoencoder. + - **Contrastive:** Auto-mines training pairs from document structure (adjacent sentences = similar). + - **Keyword-supervised:** You provide a keyword→meaning map (e.g. `{"pizza": "school"}`). The trainer generates context-aware training pairs. + +2. **Index** — Chunk your documents and encode them into a FAISS vector index using the fine-tuned model. + +3. **Analyze** — Query the index with semantic search, compare texts, analyze keyword meanings across documents, or match keywords to candidate meanings. + +4. **Evaluate** — Measure disambiguation accuracy, retrieval metrics (P@K, MRR, NDCG), and clustering quality (NMI). + +## API endpoints + +### Training +| Method | Endpoint | Description | +|--------|----------|-------------| +| POST | `/api/train/unsupervised` | TSDAE domain adaptation | +| POST | `/api/train/contrastive` | Contrastive with auto-mined pairs | +| POST | `/api/train/keywords` | Keyword-supervised training | +| POST | `/api/train/evaluate` | Compare base vs trained model | + +### Engine +| Method | Endpoint | Description | +|--------|----------|-------------| +| POST | `/api/init` | Initialize engine with a model | +| POST | `/api/documents` | Add a document | +| POST | `/api/documents/upload` | Upload a file as a document | +| POST | `/api/index/build` | Build FAISS index | +| POST | `/api/query` | Semantic search | +| POST | `/api/compare` | Compare two texts | +| POST | `/api/analyze/keyword` | Single keyword analysis | +| POST | `/api/analyze/batch` | Multi-keyword batch analysis | +| POST | `/api/match` | Match keyword to candidate meanings | +| GET | `/api/stats` | Corpus statistics | + +### Evaluation +| Method | Endpoint | Description | +|--------|----------|-------------| +| POST | `/api/eval/disambiguation` | Disambiguation accuracy | +| POST | `/api/eval/retrieval` | Retrieval metrics (P@K, MRR, NDCG) | +| GET | `/api/eval/similarity-distribution` | Pairwise similarity histogram | + +### Word2Vec baseline +| Method | Endpoint | Description | +|--------|----------|-------------| +| POST | `/api/w2v/init` | Train Word2Vec on corpus | +| POST | `/api/w2v/compare` | Compare two texts | +| POST | `/api/w2v/query` | Search corpus | +| POST | `/api/w2v/similar-words` | Find similar words | + +Full interactive docs available at `/docs` when the server is running. + +## Project structure + +``` +esfiles/ +├── pyproject.toml # Dependencies (uv) +├── requirements.txt # Fallback for pip +├── uv.lock # Lockfile for reproducible installs +├── contextual_similarity.py # Core engine: chunking, embedding, FAISS, analysis +├── training.py # Training pipeline: 3 strategies + evaluation +├── evaluation.py # Evaluation: metrics, reports +├── word2vec_baseline.py # gensim Word2Vec baseline +├── data_loader.py # Epstein Files dataset loader (HuggingFace + ChromaDB) +├── server.py # FastAPI REST API +├── demo.py # CLI demo: Word2Vec vs Transformer comparison +├── Dockerfile # Multi-stage build (Node + Python) +├── docker-compose.yml # Local Docker setup +├── HOWTO.md # In-depth usage guide +└── frontend/ # React + TypeScript UI + ├── package.json + ├── vite.config.ts + ├── index.html + └── src/ + ├── App.tsx # Main app with tab navigation + ├── api.ts # API client + ├── types.ts # TypeScript types + └── components/ # UI components (training, search, evaluation, etc.) +``` + +## Base models + +| Model | Dimensions | Quality | Speed | +|-------|-----------|---------|-------| +| `all-MiniLM-L6-v2` | 384 | Good | Fast | +| `all-mpnet-base-v2` | 768 | Best | Medium | + +Start with `all-MiniLM-L6-v2` for iteration, use `all-mpnet-base-v2` for production. + +## Further reading + +See [HOWTO.md](HOWTO.md) for detailed usage examples including Python API usage, training configuration, tuning parameters, and evaluation metrics. + +## License + +Apache 2.0 diff --git a/contextual_similarity.py b/contextual_similarity.py new file mode 100644 index 0000000000000000000000000000000000000000..058447d15a1d63c72ac13db96dab63effb14f79e --- /dev/null +++ b/contextual_similarity.py @@ -0,0 +1,850 @@ +""" +Contextual Word Similarity Engine + +Uses transformer-based sentence embeddings (SentenceTransformers) and FAISS +vector search to find and compare contextual meanings of keywords within +large documents. Unlike static embeddings (Word2Vec/GloVe), this captures +how word meaning changes based on surrounding context. + +Usage: + engine = ContextualSimilarityEngine() + engine.add_document("my_doc", text) + engine.build_index() + results = engine.analyze_keyword("pizza", top_k=10) +""" + +import re +import logging +from dataclasses import dataclass, field +from pathlib import Path +from typing import Optional + +import faiss +import numpy as np +from sentence_transformers import SentenceTransformer, util +from sklearn.cluster import AgglomerativeClustering +from tqdm import tqdm + +logger = logging.getLogger(__name__) + + +@dataclass +class Chunk: + """A passage of text from a document with metadata.""" + text: str + doc_id: str + chunk_index: int + start_char: int + end_char: int + + def __repr__(self): + preview = self.text[:80].replace("\n", " ") + return f"Chunk(doc={self.doc_id!r}, idx={self.chunk_index}, text={preview!r}...)" + + +@dataclass +class SimilarityResult: + """A single similarity match.""" + chunk: Chunk + score: float + rank: int + + +@dataclass +class KeywordContext: + """A keyword occurrence with its surrounding context and embedding.""" + keyword: str + chunk: Chunk + highlight_positions: list = field(default_factory=list) + + +@dataclass +class KeywordAnalysis: + """Full analysis of a keyword's contextual meanings across a corpus.""" + keyword: str + total_occurrences: int + meaning_clusters: list = field(default_factory=list) + cross_keyword_similarities: dict = field(default_factory=dict) + + +class ContextualSimilarityEngine: + """ + Engine for contextual word similarity analysis using transformer embeddings. + + Loads documents, chunks them into passages, embeds with a SentenceTransformer + model, indexes with FAISS, and provides methods to: + - Find all contextual usages of a keyword + - Cluster keyword usages into distinct meanings + - Compare keyword contexts across documents + - Find passages most similar to a query + - Batch-analyze multiple keywords + """ + + def __init__( + self, + model_name: str = "all-MiniLM-L6-v2", + chunk_size: int = 512, + chunk_overlap: int = 128, + device: Optional[str] = None, + batch_size: int = 64, + ): + """ + Args: + model_name: HuggingFace SentenceTransformer model name. + - "all-MiniLM-L6-v2": fast, good quality (384-dim) + - "all-mpnet-base-v2": best quality general-purpose (768-dim) + - "BAAI/bge-large-en-v1.5": high accuracy, larger (1024-dim) + chunk_size: Max characters per chunk. + chunk_overlap: Overlap between consecutive chunks (preserves context at boundaries). + device: PyTorch device ("cpu", "cuda", "mps"). Auto-detected if None. + batch_size: Batch size for encoding (tune for your GPU memory). + """ + logger.info(f"Loading model: {model_name}") + self._model_name = model_name + self.model = SentenceTransformer(model_name, device=device) + self.chunk_size = chunk_size + self.chunk_overlap = chunk_overlap + self.batch_size = batch_size + self.embedding_dim = self.model.get_sentence_embedding_dimension() + + # Storage + self.chunks: list[Chunk] = [] + self.embeddings: Optional[np.ndarray] = None + self.index: Optional[faiss.IndexFlatIP] = None + self._doc_ids: set[str] = set() + + # ------------------------------------------------------------------ # + # Document loading & chunking + # ------------------------------------------------------------------ # + + def add_document(self, doc_id: str, text: str) -> list[Chunk]: + """ + Chunk a document and add it to the corpus. + + Args: + doc_id: Unique identifier for this document. + text: Full document text. + + Returns: + List of Chunk objects created from this document. + """ + if doc_id in self._doc_ids: + raise ValueError(f"Document '{doc_id}' already added. Use a unique doc_id.") + self._doc_ids.add(doc_id) + + new_chunks = self._chunk_text(text, doc_id) + self.chunks.extend(new_chunks) + logger.info(f"Added document '{doc_id}': {len(new_chunks)} chunks") + + # Invalidate index so user must rebuild + self.embeddings = None + self.index = None + + return new_chunks + + def add_document_from_file(self, file_path: str, doc_id: Optional[str] = None) -> list[Chunk]: + """Load a text file and add it as a document.""" + path = Path(file_path).resolve() + base_dir = Path(__file__).parent.resolve() + if not path.is_relative_to(base_dir): + raise ValueError("File path must be within the project directory.") + if not path.exists(): + raise FileNotFoundError(f"File not found: {file_path}") + text = path.read_text(encoding="utf-8") + return self.add_document(doc_id or path.stem, text) + + def _chunk_text(self, text: str, doc_id: str) -> list[Chunk]: + """ + Split text into overlapping chunks, breaking at sentence boundaries + when possible to preserve semantic coherence. + """ + # Normalize whitespace + text = re.sub(r"\n{3,}", "\n\n", text) + + chunks = [] + start = 0 + chunk_idx = 0 + + while start < len(text): + end = start + self.chunk_size + + # If we're not at the end, try to break at a sentence boundary + if end < len(text): + # Look for sentence-ending punctuation near the chunk boundary + search_region = text[max(end - 100, start):end] + # Find last sentence break in the search region + for sep in [". ", ".\n", "! ", "!\n", "? ", "?\n", "\n\n"]: + last_break = search_region.rfind(sep) + if last_break != -1: + end = max(end - 100, start) + last_break + len(sep) + break + + chunk_text = text[start:end].strip() + if chunk_text: + chunks.append(Chunk( + text=chunk_text, + doc_id=doc_id, + chunk_index=chunk_idx, + start_char=start, + end_char=end, + )) + chunk_idx += 1 + + # Advance with overlap + start = end - self.chunk_overlap if end < len(text) else end + + return chunks + + # ------------------------------------------------------------------ # + # Embedding & indexing + # ------------------------------------------------------------------ # + + def build_index(self, normalize: bool = True, show_progress: bool = True) -> None: + """ + Embed all chunks and build a FAISS index for fast similarity search. + + Args: + normalize: L2-normalize embeddings (enables cosine similarity via inner product). + show_progress: Show a progress bar during encoding. + """ + if not self.chunks: + raise RuntimeError("No documents loaded. Call add_document() first.") + + logger.info(f"Encoding {len(self.chunks)} chunks...") + texts = [c.text for c in self.chunks] + + self.embeddings = self.model.encode( + texts, + batch_size=self.batch_size, + show_progress_bar=show_progress, + convert_to_numpy=True, + normalize_embeddings=normalize, + ) + + # Build FAISS inner-product index (cosine similarity when vectors are normalized) + self.index = faiss.IndexFlatIP(self.embedding_dim) + self.index.add(self.embeddings.astype(np.float32)) + + logger.info(f"Index built: {self.index.ntotal} vectors, dim={self.embedding_dim}") + + # ------------------------------------------------------------------ # + # Core query methods + # ------------------------------------------------------------------ # + + def query(self, text: str, top_k: int = 10) -> list[SimilarityResult]: + """ + Find the most similar chunks to a query text. + + Args: + text: Query string (sentence, phrase, or keyword in context). + top_k: Number of results to return. + + Returns: + List of SimilarityResult sorted by descending similarity score. + """ + self._ensure_index() + + query_vec = self.model.encode( + [text], normalize_embeddings=True, convert_to_numpy=True + ).astype(np.float32) + + scores, indices = self.index.search(query_vec, top_k) + + results = [] + for rank, (score, idx) in enumerate(zip(scores[0], indices[0])): + if idx == -1: + continue + results.append(SimilarityResult( + chunk=self.chunks[idx], + score=float(score), + rank=rank + 1, + )) + return results + + def compare_texts(self, text_a: str, text_b: str) -> float: + """ + Compute cosine similarity between two texts directly. + + Returns: + Similarity score in [-1, 1] (typically [0, 1] for natural language). + """ + vecs = self.model.encode( + [text_a, text_b], normalize_embeddings=True, convert_to_tensor=True + ) + return float(util.pytorch_cos_sim(vecs[0], vecs[1]).item()) + + # ------------------------------------------------------------------ # + # Keyword analysis + # ------------------------------------------------------------------ # + + def find_keyword_contexts( + self, keyword: str, case_sensitive: bool = False + ) -> list[KeywordContext]: + """ + Find all chunks containing a keyword and return them as KeywordContext objects. + + Args: + keyword: The word or phrase to search for. + case_sensitive: Whether matching is case-sensitive. + + Returns: + List of KeywordContext with chunk and highlight positions. + """ + if len(keyword) > 200: + raise ValueError("Keyword must be 200 characters or fewer.") + flags = 0 if case_sensitive else re.IGNORECASE + pattern = re.compile(r"\b" + re.escape(keyword) + r"\b", flags) + + contexts = [] + for chunk in self.chunks: + matches = list(pattern.finditer(chunk.text)) + if matches: + positions = [(m.start(), m.end()) for m in matches] + contexts.append(KeywordContext( + keyword=keyword, + chunk=chunk, + highlight_positions=positions, + )) + return contexts + + def analyze_keyword( + self, + keyword: str, + top_k: int = 10, + cluster_threshold: float = 0.35, + case_sensitive: bool = False, + ) -> KeywordAnalysis: + """ + Analyze all contextual usages of a keyword across the corpus. + + Finds every chunk containing the keyword, embeds them, clusters them + by semantic similarity (agglomerative clustering), and returns a + structured analysis with distinct meaning groups. + + Args: + keyword: Word or phrase to analyze. + top_k: Max similar chunks to return per meaning cluster. + cluster_threshold: Distance threshold for clustering (lower = more clusters). + 0.35 works well for clearly distinct meanings; raise to 0.5+ to merge similar ones. + case_sensitive: Whether keyword matching is case-sensitive. + + Returns: + KeywordAnalysis with meaning clusters and similarity info. + """ + self._ensure_index() + contexts = self.find_keyword_contexts(keyword, case_sensitive) + + if not contexts: + return KeywordAnalysis(keyword=keyword, total_occurrences=0) + + # Get embeddings for keyword-containing chunks + chunk_indices = [] + for ctx in contexts: + idx = self.chunks.index(ctx.chunk) + chunk_indices.append(idx) + + kw_embeddings = self.embeddings[chunk_indices] + + # Cluster the keyword contexts by semantic similarity + clusters = self._cluster_embeddings(kw_embeddings, threshold=cluster_threshold) + + # Build meaning clusters + meaning_clusters = [] + for cluster_id in sorted(set(clusters)): + member_indices = [i for i, c in enumerate(clusters) if c == cluster_id] + member_contexts = [contexts[i] for i in member_indices] + member_embeds = kw_embeddings[member_indices] + + # Centroid of this cluster + centroid = member_embeds.mean(axis=0, keepdims=True).astype(np.float32) + faiss.normalize_L2(centroid) + + # Find top_k most similar chunks in the full corpus to this meaning + scores, idx_arr = self.index.search(centroid, top_k) + similar = [] + for rank, (score, idx) in enumerate(zip(scores[0], idx_arr[0])): + if idx == -1: + continue + similar.append(SimilarityResult( + chunk=self.chunks[idx], + score=float(score), + rank=rank + 1, + )) + + meaning_clusters.append({ + "cluster_id": cluster_id, + "size": len(member_indices), + "representative_text": member_contexts[0].chunk.text[:200], + "contexts": member_contexts, + "similar_passages": similar, + }) + + return KeywordAnalysis( + keyword=keyword, + total_occurrences=len(contexts), + meaning_clusters=meaning_clusters, + ) + + def batch_analyze_keywords( + self, + keywords: list[str], + top_k: int = 10, + cluster_threshold: float = 0.35, + compare_across: bool = True, + ) -> dict[str, KeywordAnalysis]: + """ + Analyze multiple keywords and optionally compute cross-keyword similarities. + + Args: + keywords: List of keywords to analyze. + top_k: Results per cluster. + cluster_threshold: Clustering distance threshold. + compare_across: If True, compute pairwise similarity between keyword contexts. + + Returns: + Dict mapping keyword -> KeywordAnalysis. + """ + results = {} + for kw in tqdm(keywords, desc="Analyzing keywords"): + results[kw] = self.analyze_keyword(kw, top_k, cluster_threshold) + + if compare_across and len(keywords) > 1: + self._compute_cross_keyword_similarities(results) + + return results + + def _compute_cross_keyword_similarities( + self, analyses: dict[str, KeywordAnalysis] + ) -> None: + """Compute average cosine similarity between each pair of keywords' contexts.""" + keyword_centroids = {} + for kw, analysis in analyses.items(): + if not analysis.meaning_clusters: + continue + # Collect all context embeddings for this keyword + all_indices = [] + for cluster in analysis.meaning_clusters: + for ctx in cluster["contexts"]: + idx = self.chunks.index(ctx.chunk) + all_indices.append(idx) + if all_indices: + embeds = self.embeddings[all_indices] + centroid = embeds.mean(axis=0) + norm = np.linalg.norm(centroid) + if norm > 0: + centroid = centroid / norm + keyword_centroids[kw] = centroid + + # Pairwise similarities + kw_list = list(keyword_centroids.keys()) + for i, kw_a in enumerate(kw_list): + sims = {} + for j, kw_b in enumerate(kw_list): + if i != j: + score = float(np.dot(keyword_centroids[kw_a], keyword_centroids[kw_b])) + sims[kw_b] = score + if kw_a in analyses: + analyses[kw_a].cross_keyword_similarities = sims + + # ------------------------------------------------------------------ # + # Contextual keyword matching (the core use case) + # ------------------------------------------------------------------ # + + def match_keyword_to_meaning( + self, + keyword: str, + candidate_meanings: list[str], + ) -> list[dict]: + """ + Given a keyword and a list of candidate meanings (words/phrases), + find which meaning each occurrence of the keyword is closest to. + + This is the core "pizza means school" use case: you provide the keyword + "pizza" and candidates ["pizza (food)", "school", "homework"], and this + method tells you which meaning each usage of "pizza" maps to. + + Args: + keyword: The keyword to analyze (e.g. "pizza"). + candidate_meanings: List of meaning descriptions (e.g. ["food", "school"]). + + Returns: + List of dicts with keys: chunk, best_match, scores (all candidates). + """ + self._ensure_index() + + contexts = self.find_keyword_contexts(keyword) + if not contexts: + return [] + + # Embed all candidate meanings + candidate_vecs = self.model.encode( + candidate_meanings, normalize_embeddings=True, convert_to_tensor=True + ) + + results = [] + for ctx in contexts: + # Embed the chunk containing the keyword + chunk_vec = self.model.encode( + [ctx.chunk.text], normalize_embeddings=True, convert_to_tensor=True + ) + + # Score against each candidate + scores = util.pytorch_cos_sim(chunk_vec, candidate_vecs)[0] + score_dict = { + meaning: float(scores[i]) for i, meaning in enumerate(candidate_meanings) + } + best = max(score_dict, key=score_dict.get) + + results.append({ + "chunk": ctx.chunk, + "best_match": best, + "best_score": score_dict[best], + "all_scores": score_dict, + }) + + return results + + # ------------------------------------------------------------------ # + # Context inference (keyword → meaning words) + # ------------------------------------------------------------------ # + + # Common English stopwords to exclude from context word extraction + _STOPWORDS = frozenset( + "a an the and or but in on at to for of is it that this was were be been " + "being have has had do does did will would shall should may might can could " + "not no nor so if then than too very just about above after again all also " + "am are as between both by each few from further get got he her here hers " + "herself him himself his how i its itself me more most my myself no nor " + "only other our ours ourselves out over own same she some such their theirs " + "them themselves there these they those through under until up us we what " + "when where which while who whom why with you your yours yourself yourselves " + "one two three four five six seven eight nine ten into been being because " + "during before between against without within along across behind since " + "upon around among".split() + ) + + def infer_keyword_meanings( + self, + keyword: str, + context_window: int = 120, + top_words: int = 8, + cluster_threshold: float = 0.35, + max_meanings: int = 10, + ) -> dict: + """ + Infer what a keyword likely means based on its surrounding context words. + + Finds all occurrences, clusters them by semantic similarity, then extracts + the most distinctive co-occurring words for each meaning cluster. + + Args: + keyword: The keyword to analyze. + context_window: Characters around each keyword occurrence to examine. + top_words: Number of associated words to return per meaning. + cluster_threshold: Distance threshold for clustering. + max_meanings: Maximum number of meaning clusters to return. + + Returns: + Dict with keyword, total_occurrences, and meanings list. + """ + self._ensure_index() + contexts = self.find_keyword_contexts(keyword) + + if not contexts: + return { + "keyword": keyword, + "total_occurrences": 0, + "meanings": [], + } + + # Get embeddings and cluster + chunk_indices = [self.chunks.index(ctx.chunk) for ctx in contexts] + kw_embeddings = self.embeddings[chunk_indices] + clusters = self._cluster_embeddings(kw_embeddings, threshold=cluster_threshold) + + total = len(contexts) + kw_lower = keyword.lower() + word_pattern = re.compile(r"[a-zA-Z]{3,}") + + # Global word frequencies (across all occurrences) for TF-IDF-like scoring + global_word_counts: dict[str, int] = {} + cluster_data: dict[int, list[dict[str, int]]] = {} + + for i, ctx in enumerate(contexts): + cluster_id = clusters[i] + if cluster_id not in cluster_data: + cluster_data[cluster_id] = [] + + # Extract context window around each keyword occurrence + local_counts: dict[str, int] = {} + for start, end in ctx.highlight_positions: + window_start = max(0, start - context_window) + window_end = min(len(ctx.chunk.text), end + context_window) + window_text = ctx.chunk.text[window_start:window_end].lower() + + for word_match in word_pattern.finditer(window_text): + w = word_match.group() + if w == kw_lower or w in self._STOPWORDS or len(w) < 3: + continue + local_counts[w] = local_counts.get(w, 0) + 1 + global_word_counts[w] = global_word_counts.get(w, 0) + 1 + + cluster_data[cluster_id].append(local_counts) + + # Build meanings from clusters + meanings = [] + for cluster_id in sorted(cluster_data.keys()): + members = cluster_data[cluster_id] + count = len(members) + confidence = round(count / total, 3) + + # Aggregate word counts for this cluster + cluster_word_counts: dict[str, int] = {} + for member_counts in members: + for w, c in member_counts.items(): + cluster_word_counts[w] = cluster_word_counts.get(w, 0) + c + + # Score words: cluster frequency weighted by distinctiveness + # (how much more frequent in this cluster vs globally) + num_clusters = len(cluster_data) + word_scores: dict[str, float] = {} + for w, cluster_count in cluster_word_counts.items(): + global_count = global_word_counts.get(w, 1) + # TF in cluster * IDF-like distinctiveness + tf = cluster_count / max(sum(cluster_word_counts.values()), 1) + distinctiveness = (cluster_count / global_count) if num_clusters > 1 else 1.0 + word_scores[w] = tf * (0.5 + 0.5 * distinctiveness) + + # Get top words + sorted_words = sorted(word_scores.items(), key=lambda x: -x[1])[:top_words] + associated_words = [ + {"word": w, "score": round(s, 4)} for w, s in sorted_words + ] + + # Get example context snippets + example_contexts = [] + member_indices = [j for j, c in enumerate(clusters) if c == cluster_id] + for j in member_indices[:3]: # max 3 examples + ctx = contexts[j] + if ctx.highlight_positions: + start, end = ctx.highlight_positions[0] + snippet_start = max(0, start - 80) + snippet_end = min(len(ctx.chunk.text), end + 80) + snippet = ctx.chunk.text[snippet_start:snippet_end].strip() + if snippet_start > 0: + snippet = "..." + snippet + if snippet_end < len(ctx.chunk.text): + snippet = snippet + "..." + example_contexts.append({ + "doc_id": ctx.chunk.doc_id, + "snippet": snippet, + }) + + meanings.append({ + "cluster_id": cluster_id, + "occurrences": count, + "confidence": confidence, + "associated_words": associated_words, + "example_contexts": example_contexts, + }) + + # Sort by confidence descending + meanings.sort(key=lambda m: -m["confidence"]) + meanings = meanings[:max_meanings] + + return { + "keyword": keyword, + "total_occurrences": total, + "meanings": meanings, + } + + # ------------------------------------------------------------------ # + # Utilities + # ------------------------------------------------------------------ # + + def _cluster_embeddings( + self, embeddings: np.ndarray, threshold: float = 0.35 + ) -> list[int]: + """Cluster embeddings using agglomerative clustering with cosine distance.""" + if len(embeddings) == 1: + return [0] + + clustering = AgglomerativeClustering( + n_clusters=None, + distance_threshold=threshold, + metric="cosine", + linkage="average", + ) + labels = clustering.fit_predict(embeddings) + return labels.tolist() + + def similar_words(self, word: str, top_k: int = 10) -> list[dict]: + """ + Find words that appear in similar contexts using transformer embeddings. + + Extracts unique words from the corpus, encodes them, and finds nearest + neighbors by cosine similarity. Unlike Word2Vec (one static vector per word), + this uses the transformer's contextual understanding. + + Args: + word: Target word. + top_k: Number of similar words to return. + + Returns: + List of {"word": str, "score": float} sorted by descending similarity. + """ + self._ensure_index() + + word_pattern = re.compile(r"[a-zA-Z]{3,}") + word_lower = word.lower() + + # Collect unique words from corpus (skip stopwords + the query word itself) + vocab: set[str] = set() + for chunk in self.chunks: + for match in word_pattern.finditer(chunk.text): + w = match.group().lower() + if w != word_lower and w not in self._STOPWORDS: + vocab.add(w) + + if not vocab: + return [] + + vocab_list = sorted(vocab) + logger.info("Similar words: encoding %d vocabulary words for '%s'", len(vocab_list), word) + + # Encode the query word and all vocab words + all_texts = [word] + vocab_list + embeddings = self.model.encode( + all_texts, + batch_size=self.batch_size, + show_progress_bar=False, + convert_to_numpy=True, + normalize_embeddings=True, + ) + + query_vec = embeddings[0:1] + vocab_vecs = embeddings[1:] + + # Compute cosine similarities + scores = (vocab_vecs @ query_vec.T).flatten() + top_indices = np.argsort(scores)[::-1][:top_k] + + return [ + {"word": vocab_list[i], "score": round(float(scores[i]), 4)} + for i in top_indices + ] + + def _ensure_index(self): + if self.index is None: + raise RuntimeError("Index not built. Call build_index() first.") + + def get_stats(self) -> dict: + """Return corpus statistics.""" + return { + "total_chunks": len(self.chunks), + "total_documents": len(self._doc_ids), + "document_ids": sorted(self._doc_ids), + "index_built": self.index is not None, + "embedding_dim": self.embedding_dim, + "model_name": self._model_name, + } + + # ------------------------------------------------------------------ # + # Persistence (save / load engine state to disk) + # ------------------------------------------------------------------ # + + def save(self, directory: str) -> dict: + """ + Save the full engine state (chunks, embeddings, FAISS index) to disk. + + Args: + directory: Path to save directory (created if needed). + + Returns: + Stats dict with what was saved. + """ + import json, pickle + + save_dir = Path(directory) + save_dir.mkdir(parents=True, exist_ok=True) + + # Save chunks + with open(save_dir / "chunks.pkl", "wb") as f: + pickle.dump(self.chunks, f) + + # Save metadata + meta = { + "model_name": self._model_name, + "chunk_size": self.chunk_size, + "chunk_overlap": self.chunk_overlap, + "batch_size": self.batch_size, + "embedding_dim": self.embedding_dim, + "doc_ids": sorted(self._doc_ids), + } + with open(save_dir / "meta.json", "w") as f: + json.dump(meta, f, indent=2) + + # Save embeddings + FAISS index + saved_index = False + if self.embeddings is not None: + np.save(save_dir / "embeddings.npy", self.embeddings) + if self.index is not None: + faiss.write_index(self.index, str(save_dir / "index.faiss")) + saved_index = True + + logger.info("Engine saved to %s: %d chunks, %d docs, index=%s", + directory, len(self.chunks), len(self._doc_ids), saved_index) + return { + "directory": str(save_dir), + "chunks": len(self.chunks), + "documents": len(self._doc_ids), + "index_saved": saved_index, + } + + @classmethod + def load(cls, directory: str, device: Optional[str] = None) -> "ContextualSimilarityEngine": + """ + Load a previously saved engine state from disk. + + Args: + directory: Path to the saved state directory. + device: PyTorch device override. + + Returns: + A fully restored ContextualSimilarityEngine instance. + """ + import json, pickle + + save_dir = Path(directory) + if not save_dir.is_dir(): + raise FileNotFoundError(f"No saved state at {directory}") + + # Load metadata + with open(save_dir / "meta.json") as f: + meta = json.load(f) + + # Create engine (loads the model) + engine = cls( + model_name=meta["model_name"], + chunk_size=meta["chunk_size"], + chunk_overlap=meta["chunk_overlap"], + device=device, + batch_size=meta["batch_size"], + ) + + # Restore chunks + with open(save_dir / "chunks.pkl", "rb") as f: + engine.chunks = pickle.load(f) + engine._doc_ids = set(meta["doc_ids"]) + + # Restore embeddings + index + emb_path = save_dir / "embeddings.npy" + idx_path = save_dir / "index.faiss" + if emb_path.exists(): + engine.embeddings = np.load(emb_path) + if idx_path.exists(): + engine.index = faiss.read_index(str(idx_path)) + + logger.info("Engine loaded from %s: %d chunks, %d docs, index=%s", + directory, len(engine.chunks), len(engine._doc_ids), engine.index is not None) + return engine diff --git a/data_loader.py b/data_loader.py new file mode 100644 index 0000000000000000000000000000000000000000..350f3674a5f0ae38d6f08a349e8d1b0729ff6b86 --- /dev/null +++ b/data_loader.py @@ -0,0 +1,286 @@ +""" +Epstein Files Dataset Loader + +Loads data from two HuggingFace sources: + 1. teyler/epstein-files-20k — raw OCR text (2.1M rows, filename + text) + 2. devankit7873/EpsteinFiles-Vector-Embeddings-ChromaDB — pre-computed + all-MiniLM-L6-v2 embeddings in ChromaDB format + +Both can feed directly into the ContextualSimilarityEngine pipeline. +""" + +import logging +import re +import time +from pathlib import Path +from typing import Optional + +import numpy as np + +logger = logging.getLogger(__name__) + +# HuggingFace dataset identifiers +RAW_DATASET = "teyler/epstein-files-20k" +EMBEDDINGS_DATASET = "devankit7873/EpsteinFiles-Vector-Embeddings-ChromaDB" + + +def load_raw_dataset( + max_docs: Optional[int] = None, + min_text_length: int = 100, + source_filter: Optional[str] = None, +) -> list[dict]: + """ + Load raw Epstein Files from HuggingFace. + + Args: + max_docs: Limit number of documents loaded (None = all ~2.1M). + min_text_length: Skip documents shorter than this. + source_filter: Filter by filename prefix, e.g. "TEXT-" or "IMAGES-". + + Returns: + List of {"doc_id": str, "text": str, "filename": str} + """ + from datasets import load_dataset + + t0 = time.time() + logger.info(f"Loading {RAW_DATASET} from HuggingFace...") + + ds = load_dataset(RAW_DATASET, split="train") + docs = [] + + for i, row in enumerate(ds): + if max_docs and len(docs) >= max_docs: + break + + text = (row.get("text") or "").strip() + filename = row.get("filename") or f"doc_{i}" + + if len(text) < min_text_length: + continue + + if source_filter and not filename.startswith(source_filter): + continue + + doc_id = Path(filename).stem + docs.append({"doc_id": doc_id, "text": text, "filename": filename}) + + elapsed = time.time() - t0 + logger.info(f"Loaded {len(docs)} documents in {elapsed:.1f}s") + return docs + + +def load_raw_to_engine( + engine, + max_docs: Optional[int] = 500, + min_text_length: int = 100, + source_filter: Optional[str] = None, + build_index: bool = True, +) -> dict: + """ + Load raw dataset directly into a ContextualSimilarityEngine. + + Args: + engine: ContextualSimilarityEngine instance (must be initialized). + max_docs: Limit documents to load. + min_text_length: Skip short documents. + source_filter: Filter by filename prefix. + build_index: Whether to build FAISS index after loading. + + Returns: + Stats dict with counts and timing. + """ + t0 = time.time() + docs = load_raw_dataset(max_docs, min_text_length, source_filter) + + total_chunks = 0 + skipped = 0 + for doc in docs: + try: + chunks = engine.add_document(doc["doc_id"], doc["text"]) + total_chunks += len(chunks) + except ValueError as e: + logger.warning("Skipped document '%s': %s", doc["doc_id"], e) + skipped += 1 + + if build_index and total_chunks > 0: + engine.build_index(show_progress=True) + + elapsed = time.time() - t0 + return { + "documents_loaded": len(docs) - skipped, + "documents_skipped": skipped, + "total_chunks": total_chunks, + "index_built": build_index and total_chunks > 0, + "seconds": round(elapsed, 2), + } + + +def load_chromadb_embeddings( + download_dir: str = "./chroma_epstein", +) -> dict: + """ + Download and load the pre-computed ChromaDB embeddings. + + Returns: + Dict with "texts", "embeddings", "metadatas", "ids", and stats. + """ + import chromadb + from huggingface_hub import snapshot_download + + t0 = time.time() + logger.info(f"Downloading {EMBEDDINGS_DATASET} from HuggingFace...") + + # This repo contains ChromaDB persistence files (not standard datasets), + # so we use snapshot_download instead of load_dataset. + local_path = snapshot_download( + repo_id=EMBEDDINGS_DATASET, + repo_type="dataset", + local_dir=download_dir, + ) + + # Find the chroma_db directory + chroma_dir = None + for candidate in [ + Path(local_path) / "chroma_db", + Path(local_path), + ]: + if (candidate / "chroma.sqlite3").exists(): + chroma_dir = str(candidate) + break + + if not chroma_dir: + raise FileNotFoundError( + f"ChromaDB files not found in {local_path}. " + f"Expected chroma.sqlite3 in the download." + ) + + # Open ChromaDB + client = chromadb.PersistentClient(path=chroma_dir) + collections = client.list_collections() + if not collections: + raise ValueError("No collections found in ChromaDB.") + + collection = collections[0] + count = collection.count() + logger.info(f"ChromaDB collection '{collection.name}': {count} vectors") + + elapsed = time.time() - t0 + return { + "chroma_dir": chroma_dir, + "collection_name": collection.name, + "total_vectors": count, + "seconds": round(elapsed, 2), + "_collection": collection, + "_client": client, + } + + +def import_chromadb_to_engine( + engine, + max_chunks: Optional[int] = None, + batch_size: int = 1000, +) -> dict: + """ + Import pre-computed ChromaDB embeddings into the engine's FAISS index. + + Since both use all-MiniLM-L6-v2 (384-dim), we can directly import + the vectors without re-encoding. + + Args: + engine: ContextualSimilarityEngine (must be initialized with all-MiniLM-L6-v2). + max_chunks: Limit vectors to import (None = all). + batch_size: How many vectors to fetch from ChromaDB at a time. + + Returns: + Stats dict. + """ + t0 = time.time() + chroma_data = load_chromadb_embeddings() + collection = chroma_data["_collection"] + total = chroma_data["total_vectors"] + + if max_chunks: + total = min(total, max_chunks) + + # Fetch in batches + all_texts = [] + all_embeddings = [] + all_sources = [] + + offset = 0 + while offset < total: + limit = min(batch_size, total - offset) + results = collection.get( + limit=limit, + offset=offset, + include=["embeddings", "documents", "metadatas"], + ) + + if not results["ids"]: + break + + for i, doc_id in enumerate(results["ids"]): + text = results["documents"][i] if results["documents"] is not None else "" + embedding = results["embeddings"][i] if results["embeddings"] is not None else None + metadata = results["metadatas"][i] if results["metadatas"] is not None else {} + source = metadata.get("source", f"chunk_{offset + i}") + + if text and embedding is not None: + all_texts.append(text) + all_embeddings.append(embedding) + all_sources.append(source) + + offset += len(results["ids"]) + logger.info(f"Fetched {offset}/{total} vectors from ChromaDB") + + # Group texts by source document and add to engine + doc_chunks = {} + for text, source in zip(all_texts, all_sources): + stem = Path(source).stem if source else "unknown" + if stem not in doc_chunks: + doc_chunks[stem] = [] + doc_chunks[stem].append(text) + + docs_added = 0 + chunks_added = 0 + for doc_id, texts in doc_chunks.items(): + combined = "\n\n".join(texts) + try: + chunks = engine.add_document(doc_id, combined) + chunks_added += len(chunks) + docs_added += 1 + except ValueError as e: + logger.warning("Skipped ChromaDB document '%s': %s", doc_id, e) + + if chunks_added > 0: + engine.build_index(show_progress=True) + + elapsed = time.time() - t0 + return { + "source": "chromadb_embeddings", + "chromadb_vectors": len(all_embeddings), + "documents_created": docs_added, + "chunks_indexed": chunks_added, + "index_built": chunks_added > 0, + "seconds": round(elapsed, 2), + } + + +def get_dataset_info() -> dict: + """Return metadata about available datasets (no download).""" + return { + "raw_texts": { + "dataset_id": RAW_DATASET, + "url": f"https://huggingface.co/datasets/{RAW_DATASET}", + "description": "2.1M OCR text documents from U.S. House Oversight Committee Epstein Files release", + "columns": ["filename", "text"], + "size_mb": 106, + }, + "embeddings": { + "dataset_id": EMBEDDINGS_DATASET, + "url": f"https://huggingface.co/datasets/{EMBEDDINGS_DATASET}", + "description": "Pre-computed all-MiniLM-L6-v2 embeddings in ChromaDB format (~100K+ chunks)", + "model": "all-MiniLM-L6-v2", + "vector_dim": 384, + }, + } diff --git a/demo.py b/demo.py new file mode 100644 index 0000000000000000000000000000000000000000..037d0a3afca545025c9259733b52384f22539aee --- /dev/null +++ b/demo.py @@ -0,0 +1,233 @@ +""" +Demo: Word2Vec vs Transformer — side by side comparison. + +Run: python demo.py +""" + +import json +from contextual_similarity import ContextualSimilarityEngine +from word2vec_baseline import Word2VecEngine +from evaluation import Evaluator, GroundTruthEntry + +# ------------------------------------------------------------------ # +# Sample corpus +# ------------------------------------------------------------------ # + +DOCS = { + "secret_language": """ +The kids in the neighborhood had developed their own secret language. When they said +"pizza" they actually meant "school". So when Tommy said "I love pizza so much, I go +there every day", he really meant he loved going to school. His friend Sarah would say +"pizza gives me homework" and everyone in the group understood she was talking about school. + +The code words extended further. "Pepperoni" meant math class, because it was their +favorite topping but also the hardest subject. When Jake complained about "too much +pepperoni on my pizza", the group knew he was struggling with math at school. + +Their parents were confused. "Why do you kids talk about pizza all the time?" asked +Tommy's mom. The kids just giggled. Their secret language was working perfectly. +""", + "real_pizza": """ +Meanwhile, across town, Maria genuinely loved pizza. She worked at Giuseppe's Pizzeria +and made the best margherita in the city. Her pizza dough recipe used tipo 00 flour, +San Marzano tomatoes, and fresh mozzarella. Every Saturday, she would fire up the +wood-burning oven and create masterpieces. + +Maria's customers raved about her pizza. "This pizza is amazing, the crust is perfectly +crispy!" they would say. The restaurant was always full. Pizza was Maria's life, her +passion, and her livelihood. She dreamed of opening more pizza restaurants across the country. +""", + "school_board": """ +The local school board met to discuss improving education in the district. Principal +Johnson presented data showing that students who attended school regularly performed +better on standardized tests. "School attendance is directly correlated with academic +success," she explained. + +The board discussed new programs to make school more engaging for students. They proposed +adding more extracurricular activities, updating the curriculum, and hiring additional +teachers. "We need to make school a place where students want to be," said board member +Williams. +""", + "misunderstanding": """ +One day, Tommy's mom overheard a phone conversation. Tommy said to his friend, "I really +don't want to go to pizza tomorrow. The pizza test is going to be so hard." His mom was +bewildered - what kind of test does a pizzeria give? + +She called Sarah's mom, who had noticed similar strange statements. "Sarah told me she +got an A on her pizza report. Since when do pizza places give grades?" The parents +decided to investigate. + +When they finally figured out the code, they laughed. "So all this time, when you said +you hated Monday pizza, you meant you hated going to school on Mondays?" Tommy nodded +sheepishly. +""", +} + +COMPARE_PAIRS = [ + ("I love pizza so much", "I love school so much"), + ("pizza gives me homework", "school gives me homework"), + ("pizza gives me homework", "fresh mozzarella on pizza"), + ("The pizza test is hard", "The school exam is difficult"), + ("too much pepperoni on my pizza", "math class is too hard"), +] + + +def main(): + # ================================================================ # + # Build both engines on the same corpus + # ================================================================ # + print("=" * 70) + print("Loading models...") + print("=" * 70) + + # Transformer engine + transformer = ContextualSimilarityEngine( + model_name="all-MiniLM-L6-v2", + chunk_size=400, + chunk_overlap=80, + ) + for doc_id, text in DOCS.items(): + transformer.add_document(doc_id, text) + transformer.build_index(show_progress=False) + print(f"Transformer: {transformer.get_stats()['total_chunks']} chunks, " + f"dim={transformer.embedding_dim}") + + # Word2Vec engine + w2v = Word2VecEngine(vector_size=100, window=5, epochs=50) + for doc_id, text in DOCS.items(): + w2v.add_document(doc_id, text) + stats = w2v.build_index() + print(f"Word2Vec: {stats['sentences']} sentences, " + f"vocab={stats['vocab_size']}, dim={stats['vector_size']}") + + # ================================================================ # + # 1. Text similarity comparison + # ================================================================ # + print("\n" + "=" * 70) + print("1. TEXT SIMILARITY — same pairs, both models") + print("=" * 70) + print(f"\n {'Text A':<35} {'Text B':<35} {'W2V':>6} {'Trans':>6} {'Winner'}") + print(" " + "-" * 95) + + for a, b in COMPARE_PAIRS: + w2v_score = w2v.compare_texts(a, b) + tr_score = transformer.compare_texts(a, b) + winner = "W2V" if abs(w2v_score) > abs(tr_score) else "TRANS" + print(f" {a:<35} {b:<35} {w2v_score:>6.3f} {tr_score:>6.3f} {winner}") + + # ================================================================ # + # 2. Word-level similarity (Word2Vec only — transformers don't do this) + # ================================================================ # + print("\n" + "=" * 70) + print("2. WORD-LEVEL SIMILARITY (Word2Vec only)") + print(" Word2Vec gives ONE vector per word — no context awareness") + print("=" * 70) + + for word in ["pizza", "school", "homework", "pepperoni"]: + similar = w2v.most_similar_words(word, top_k=5) + if similar: + top = ", ".join(f"{w}({s:.2f})" for w, s in similar) + print(f" {word:>12} -> {top}") + + print(f"\n Word2Vec word pairs:") + for a, b in [("pizza", "school"), ("pizza", "homework"), ("pizza", "cheese"), + ("school", "homework"), ("pepperoni", "math")]: + score = w2v.word_similarity(a, b) + print(f" {a} <-> {b}: {score:.4f}") + + # ================================================================ # + # 3. Semantic search comparison + # ================================================================ # + print("\n" + "=" * 70) + print("3. SEMANTIC SEARCH — 'a place where children learn and take tests'") + print("=" * 70) + + query = "a place where children learn and take tests" + + print("\n Transformer results:") + for r in transformer.query(query, top_k=3): + print(f" #{r.rank} ({r.score:.4f}) [{r.chunk.doc_id}] {r.chunk.text[:80]}...") + + print("\n Word2Vec results:") + for r in w2v.query(query, top_k=3): + print(f" #{r.rank} ({r.score:.4f}) [{r.doc_id}] {r.text[:80]}...") + + # ================================================================ # + # 4. The core test: does "pizza" mean "school" or "food"? + # ================================================================ # + print("\n" + "=" * 70) + print("4. KEYWORD MEANING MATCHING — 'pizza' -> food or school?") + print(" Transformer uses full passage context. Word2Vec averages word vectors.") + print("=" * 70) + + candidates = [ + "Italian food, restaurant, cooking, dough and cheese", + "School, education, academic activities, homework and tests", + ] + + print("\n Transformer (match_keyword_to_meaning):") + matches = transformer.match_keyword_to_meaning("pizza", candidates) + for m in matches: + doc = m["chunk"].doc_id + best = m["best_match"][:40] + scores = " | ".join(f"{c[:20]}={s:.3f}" for c, s in m["all_scores"].items()) + print(f" [{doc:>20}] -> {best:<40} ({scores})") + + print("\n Word2Vec (sentence-level similarity to candidates):") + # Replicate the same logic with Word2Vec + import re + for doc_id, text in DOCS.items(): + sents = re.split(r"(?<=[.!?])\s+", text.strip()) + for sent in sents: + if re.search(r"\bpizza\b", sent, re.IGNORECASE) and len(sent.split()) >= 5: + scores = {c: w2v.compare_texts(sent, c) for c in candidates} + best = max(scores, key=scores.get) + best_label = best[:40] + score_str = " | ".join(f"{c[:20]}={s:.3f}" for c, s in scores.items()) + print(f" [{doc_id:>20}] -> {best_label:<40} ({score_str})") + break # one per doc for brevity + + # ================================================================ # + # 5. Clustering comparison + # ================================================================ # + print("\n" + "=" * 70) + print("5. KEYWORD CLUSTERING — can the model separate meanings of 'pizza'?") + print("=" * 70) + + analysis = transformer.analyze_keyword("pizza", top_k=2, cluster_threshold=0.4) + print(f"\n Transformer: {analysis.total_occurrences} occurrences -> " + f"{len(analysis.meaning_clusters)} clusters") + for c in analysis.meaning_clusters: + docs = set(ctx.chunk.doc_id for ctx in c["contexts"]) + print(f" Cluster {c['cluster_id']} ({c['size']} hits, docs: {docs})") + print(f" Example: {c['representative_text'][:100]}...") + + print(f"\n Word2Vec: cannot cluster by meaning (same word = same vector always)") + print(f" 'pizza' has exactly ONE embedding regardless of context") + + # ================================================================ # + # Summary + # ================================================================ # + print("\n" + "=" * 70) + print("SUMMARY") + print("=" * 70) + print(""" + Word2Vec: + + Fast to train on small corpus + + Shows which words co-occur (word-level neighbors) + - ONE vector per word — "pizza" is always "pizza" + - Cannot distinguish "pizza = food" from "pizza = school" + - Sentence similarity is just averaged word vectors (lossy) + + Transformer (SentenceTransformers): + + Full sentence/passage context — same word gets different embeddings + + Can cluster "pizza" into food vs school meanings + + Pretrained on massive data — understands language out of the box + + FAISS enables fast search over large corpora + - Larger model (~80MB vs ~1MB for Word2Vec) + - Slower inference (still <100ms per query) +""") + + +if __name__ == "__main__": + main() diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000000000000000000000000000000000000..3aa6fe275c16d9bc3b0e57559b3ea6580a7bbfd0 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,18 @@ +services: + app: + build: . + ports: + - "8000:8000" + volumes: + # Persist HuggingFace model cache between restarts + - hf-cache:/data/huggingface + # Persist engine state and trained models + - engine-state:/data/engine_state + - ./trained_model:/data/trained_model + environment: + - HOST=0.0.0.0 + - PORT=8000 + +volumes: + hf-cache: + engine-state: diff --git a/evaluation.py b/evaluation.py new file mode 100644 index 0000000000000000000000000000000000000000..2d62617c719e423f278b987609f2bbd1e812201e --- /dev/null +++ b/evaluation.py @@ -0,0 +1,547 @@ +""" +Evaluation Pipeline for Contextual Similarity Engine + +Provides metrics and benchmarks to assess the quality of contextual +keyword matching: + - Cosine similarity distributions + - Precision@K and Recall@K for retrieval + - Normalized Mutual Information (NMI) for clustering quality + - Mean Reciprocal Rank (MRR) for ranking quality + - Keyword disambiguation accuracy against ground truth + - Full evaluation reports with summary statistics +""" + +import json +import logging +import time +from dataclasses import dataclass, field, asdict +from pathlib import Path +from typing import Optional + +import numpy as np +from sklearn.metrics import ( + normalized_mutual_info_score, + adjusted_rand_score, + precision_score, + recall_score, + f1_score, + confusion_matrix, +) + +from contextual_similarity import ContextualSimilarityEngine, KeywordAnalysis + +logger = logging.getLogger(__name__) + + +# ------------------------------------------------------------------ # +# Data structures +# ------------------------------------------------------------------ # + +@dataclass +class GroundTruthEntry: + """A single labeled keyword occurrence for evaluation.""" + keyword: str + text: str # The passage/sentence containing the keyword + true_meaning: str # The actual intended meaning label + + +@dataclass +class RetrievalMetrics: + """Metrics for a single retrieval query.""" + query: str + precision_at_k: dict[int, float] = field(default_factory=dict) # k -> P@k + recall_at_k: dict[int, float] = field(default_factory=dict) # k -> R@k + mrr: float = 0.0 # Mean Reciprocal Rank + ndcg_at_k: dict[int, float] = field(default_factory=dict) # k -> NDCG@k + avg_similarity: float = 0.0 + top_score: float = 0.0 + + +@dataclass +class ClusteringMetrics: + """Metrics for clustering quality against ground truth.""" + keyword: str + nmi: float = 0.0 # Normalized Mutual Information + ari: float = 0.0 # Adjusted Rand Index + num_predicted_clusters: int = 0 + num_true_clusters: int = 0 + cluster_sizes: list[int] = field(default_factory=list) + + +@dataclass +class DisambiguationMetrics: + """Metrics for keyword meaning disambiguation.""" + keyword: str + accuracy: float = 0.0 + weighted_f1: float = 0.0 + per_meaning_precision: dict[str, float] = field(default_factory=dict) + per_meaning_recall: dict[str, float] = field(default_factory=dict) + per_meaning_f1: dict[str, float] = field(default_factory=dict) + confusion: Optional[list] = None # confusion matrix as nested list + total_samples: int = 0 + + +@dataclass +class EvaluationReport: + """Complete evaluation report.""" + timestamp: str = "" + model_name: str = "" + corpus_stats: dict = field(default_factory=dict) + retrieval_metrics: list[RetrievalMetrics] = field(default_factory=list) + clustering_metrics: list[ClusteringMetrics] = field(default_factory=list) + disambiguation_metrics: list[DisambiguationMetrics] = field(default_factory=list) + similarity_distribution: dict = field(default_factory=dict) + timing: dict = field(default_factory=dict) + + def summary(self) -> dict: + """Return a concise summary of the evaluation.""" + summary = { + "model": self.model_name, + "corpus": self.corpus_stats, + "timing": self.timing, + } + + if self.retrieval_metrics: + avg_mrr = float(np.mean([m.mrr for m in self.retrieval_metrics])) + avg_p5 = float(np.mean([m.precision_at_k.get(5, 0) for m in self.retrieval_metrics])) + avg_p10 = float(np.mean([m.precision_at_k.get(10, 0) for m in self.retrieval_metrics])) + summary["retrieval"] = { + "mean_mrr": round(avg_mrr, 4), + "mean_precision_at_5": round(avg_p5, 4), + "mean_precision_at_10": round(avg_p10, 4), + "num_queries": len(self.retrieval_metrics), + } + + if self.clustering_metrics: + avg_nmi = float(np.mean([m.nmi for m in self.clustering_metrics])) + avg_ari = float(np.mean([m.ari for m in self.clustering_metrics])) + summary["clustering"] = { + "mean_nmi": round(avg_nmi, 4), + "mean_ari": round(avg_ari, 4), + "num_keywords": len(self.clustering_metrics), + } + + if self.disambiguation_metrics: + avg_acc = float(np.mean([m.accuracy for m in self.disambiguation_metrics])) + avg_f1 = float(np.mean([m.weighted_f1 for m in self.disambiguation_metrics])) + summary["disambiguation"] = { + "mean_accuracy": round(avg_acc, 4), + "mean_weighted_f1": round(avg_f1, 4), + "num_keywords": len(self.disambiguation_metrics), + } + + if self.similarity_distribution: + summary["similarity_distribution"] = self.similarity_distribution + + return summary + + def to_json(self, indent: int = 2) -> str: + """Serialize the full report to JSON.""" + return json.dumps(asdict(self), indent=indent, default=str) + + def save(self, path: str) -> None: + """Save the report to a JSON file.""" + Path(path).write_text(self.to_json()) + logger.info(f"Evaluation report saved to {path}") + + +# ------------------------------------------------------------------ # +# Evaluator +# ------------------------------------------------------------------ # + +class Evaluator: + """ + Evaluation pipeline for the ContextualSimilarityEngine. + + Usage: + engine = ContextualSimilarityEngine() + engine.add_document("doc1", text) + engine.build_index() + + evaluator = Evaluator(engine) + + # Evaluate retrieval quality + evaluator.evaluate_retrieval(queries_with_relevance) + + # Evaluate keyword disambiguation + evaluator.evaluate_disambiguation(ground_truth, candidate_meanings) + + # Evaluate clustering + evaluator.evaluate_clustering(ground_truth) + + # Get full report + report = evaluator.get_report() + """ + + def __init__(self, engine: ContextualSimilarityEngine): + self.engine = engine + self._report = EvaluationReport( + timestamp=time.strftime("%Y-%m-%d %H:%M:%S"), + model_name=engine._model_name, + corpus_stats=engine.get_stats(), + ) + + # ------------------------------------------------------------------ # + # Retrieval evaluation + # ------------------------------------------------------------------ # + + def evaluate_retrieval( + self, + queries: list[dict], + k_values: list[int] = None, + ) -> list[RetrievalMetrics]: + """ + Evaluate retrieval quality given labeled queries. + + Args: + queries: List of dicts with keys: + - "query": str, the query text + - "relevant_doc_ids": list[str], doc IDs that are relevant + OR + - "relevant_texts": list[str], text snippets considered relevant + k_values: List of K values for P@K, R@K, NDCG@K. + + Returns: + List of RetrievalMetrics, one per query. + """ + if k_values is None: + k_values = [1, 3, 5, 10] + + t0 = time.time() + all_metrics = [] + + for q in queries: + query_text = q["query"] + max_k = max(k_values) + results = self.engine.query(query_text, top_k=max_k) + + # Determine relevance for each result + relevant_doc_ids = set(q.get("relevant_doc_ids", [])) + relevant_texts = set(q.get("relevant_texts", [])) + + def is_relevant(result): + if relevant_doc_ids and result.chunk.doc_id in relevant_doc_ids: + return True + if relevant_texts: + return any(rt.lower() in result.chunk.text.lower() for rt in relevant_texts) + return False + + relevance = [is_relevant(r) for r in results] + scores = [r.score for r in results] + + metrics = RetrievalMetrics(query=query_text) + + # P@K and R@K + total_relevant = sum(relevance) + for k in k_values: + top_k_rel = relevance[:k] + metrics.precision_at_k[k] = sum(top_k_rel) / k if k > 0 else 0 + metrics.recall_at_k[k] = ( + sum(top_k_rel) / total_relevant if total_relevant > 0 else 0 + ) + metrics.ndcg_at_k[k] = self._compute_ndcg(relevance[:k], k) + + # MRR + for i, rel in enumerate(relevance): + if rel: + metrics.mrr = 1.0 / (i + 1) + break + + metrics.avg_similarity = float(np.mean(scores)) if scores else 0.0 + metrics.top_score = float(scores[0]) if scores else 0.0 + + all_metrics.append(metrics) + + elapsed = time.time() - t0 + self._report.retrieval_metrics = all_metrics + self._report.timing["retrieval_eval_seconds"] = round(elapsed, 3) + return all_metrics + + @staticmethod + def _compute_ndcg(relevance: list[bool], k: int) -> float: + """Compute NDCG@K for binary relevance.""" + dcg = sum( + (1 if rel else 0) / np.log2(i + 2) + for i, rel in enumerate(relevance[:k]) + ) + # Ideal: all relevant items first + ideal = sorted(relevance[:k], reverse=True) + idcg = sum( + (1 if rel else 0) / np.log2(i + 2) + for i, rel in enumerate(ideal) + ) + return dcg / idcg if idcg > 0 else 0.0 + + # ------------------------------------------------------------------ # + # Clustering evaluation + # ------------------------------------------------------------------ # + + def evaluate_clustering( + self, + ground_truth: list[GroundTruthEntry], + cluster_threshold: float = 0.35, + ) -> list[ClusteringMetrics]: + """ + Evaluate clustering quality by comparing engine's auto-clusters + against ground truth meaning labels. + + Args: + ground_truth: Labeled entries with keyword, text, and true_meaning. + cluster_threshold: Threshold for agglomerative clustering. + + Returns: + List of ClusteringMetrics, one per keyword. + """ + t0 = time.time() + + # Group ground truth by keyword + by_keyword: dict[str, list[GroundTruthEntry]] = {} + for entry in ground_truth: + by_keyword.setdefault(entry.keyword, []).append(entry) + + all_metrics = [] + for keyword, entries in by_keyword.items(): + analysis = self.engine.analyze_keyword( + keyword, cluster_threshold=cluster_threshold + ) + + if not analysis.meaning_clusters: + all_metrics.append(ClusteringMetrics(keyword=keyword)) + continue + + # Map ground truth entries to predicted clusters + true_labels = [] + pred_labels = [] + meaning_to_id = {} + + for entry in entries: + # Assign numeric ID to each true meaning + if entry.true_meaning not in meaning_to_id: + meaning_to_id[entry.true_meaning] = len(meaning_to_id) + true_labels.append(meaning_to_id[entry.true_meaning]) + + # Find which cluster this entry's text belongs to + best_cluster = -1 + best_sim = -1 + entry_vec = self.engine.model.encode( + [entry.text], normalize_embeddings=True, convert_to_numpy=True + ) + for cluster in analysis.meaning_clusters: + for ctx in cluster["contexts"]: + idx = self.engine.chunks.index(ctx.chunk) + sim = float(np.dot(entry_vec[0], self.engine.embeddings[idx])) + if sim > best_sim: + best_sim = sim + best_cluster = cluster["cluster_id"] + pred_labels.append(best_cluster) + + metrics = ClusteringMetrics( + keyword=keyword, + nmi=normalized_mutual_info_score(true_labels, pred_labels), + ari=adjusted_rand_score(true_labels, pred_labels), + num_predicted_clusters=len(analysis.meaning_clusters), + num_true_clusters=len(meaning_to_id), + cluster_sizes=[c["size"] for c in analysis.meaning_clusters], + ) + all_metrics.append(metrics) + + elapsed = time.time() - t0 + self._report.clustering_metrics = all_metrics + self._report.timing["clustering_eval_seconds"] = round(elapsed, 3) + return all_metrics + + # ------------------------------------------------------------------ # + # Disambiguation evaluation + # ------------------------------------------------------------------ # + + def evaluate_disambiguation( + self, + ground_truth: list[GroundTruthEntry], + candidate_meanings: dict[str, list[str]], + ) -> list[DisambiguationMetrics]: + """ + Evaluate keyword meaning disambiguation accuracy. + + For each ground truth entry, uses match_keyword_to_meaning() and compares + the predicted best match against the true label. + + Args: + ground_truth: Labeled entries with keyword, text, and true_meaning. + candidate_meanings: Dict mapping keyword -> list of candidate meaning strings. + Each candidate should be a descriptive phrase, e.g. {"pizza": ["food", "school"]}. + + Returns: + List of DisambiguationMetrics, one per keyword. + """ + t0 = time.time() + + by_keyword: dict[str, list[GroundTruthEntry]] = {} + for entry in ground_truth: + by_keyword.setdefault(entry.keyword, []).append(entry) + + all_metrics = [] + for keyword, entries in by_keyword.items(): + candidates = candidate_meanings.get(keyword, []) + if not candidates: + logger.warning(f"No candidate meanings for '{keyword}', skipping.") + continue + + true_labels = [] + pred_labels = [] + + for entry in entries: + # Encode the entry text and score against each candidate + entry_vec = self.engine.model.encode( + [entry.text], normalize_embeddings=True, convert_to_tensor=True + ) + cand_vecs = self.engine.model.encode( + candidates, normalize_embeddings=True, convert_to_tensor=True + ) + from sentence_transformers import util as st_util + scores = st_util.pytorch_cos_sim(entry_vec, cand_vecs)[0] + best_idx = int(scores.argmax()) + predicted = candidates[best_idx] + + true_labels.append(entry.true_meaning) + pred_labels.append(predicted) + + # Compute metrics + unique_labels = sorted(set(true_labels + pred_labels)) + accuracy = sum(t == p for t, p in zip(true_labels, pred_labels)) / len(true_labels) + + # Per-meaning precision, recall, F1 + per_meaning_p = {} + per_meaning_r = {} + per_meaning_f = {} + for label in unique_labels: + t_binary = [1 if t == label else 0 for t in true_labels] + p_binary = [1 if p == label else 0 for p in pred_labels] + p_val = precision_score(t_binary, p_binary, zero_division=0) + r_val = recall_score(t_binary, p_binary, zero_division=0) + f_val = f1_score(t_binary, p_binary, zero_division=0) + per_meaning_p[label] = round(p_val, 4) + per_meaning_r[label] = round(r_val, 4) + per_meaning_f[label] = round(f_val, 4) + + weighted_f = f1_score( + true_labels, pred_labels, average="weighted", zero_division=0 + ) + + cm = confusion_matrix(true_labels, pred_labels, labels=unique_labels) + + metrics = DisambiguationMetrics( + keyword=keyword, + accuracy=round(accuracy, 4), + weighted_f1=round(weighted_f, 4), + per_meaning_precision=per_meaning_p, + per_meaning_recall=per_meaning_r, + per_meaning_f1=per_meaning_f, + confusion=cm.tolist(), + total_samples=len(entries), + ) + all_metrics.append(metrics) + + elapsed = time.time() - t0 + self._report.disambiguation_metrics = all_metrics + self._report.timing["disambiguation_eval_seconds"] = round(elapsed, 3) + return all_metrics + + # ------------------------------------------------------------------ # + # Similarity distribution analysis + # ------------------------------------------------------------------ # + + def analyze_similarity_distribution( + self, sample_size: int = 1000, seed: int = 42 + ) -> dict: + """ + Analyze the distribution of pairwise similarities in the corpus. + Useful for calibrating thresholds and understanding embedding space. + + Returns: + Dict with mean, std, percentiles, and histogram data. + """ + self.engine._ensure_index() + n = len(self.engine.chunks) + rng = np.random.RandomState(seed) + + # Sample random pairs + actual_sample = min(sample_size, n * (n - 1) // 2) + pairs_i = rng.randint(0, n, size=actual_sample) + pairs_j = rng.randint(0, n, size=actual_sample) + # Avoid self-pairs + mask = pairs_i != pairs_j + pairs_i, pairs_j = pairs_i[mask], pairs_j[mask] + + sims = np.sum( + self.engine.embeddings[pairs_i] * self.engine.embeddings[pairs_j], axis=1 + ) + + percentiles = { + str(p): round(float(np.percentile(sims, p)), 4) + for p in [5, 10, 25, 50, 75, 90, 95] + } + + # Histogram + hist, bin_edges = np.histogram(sims, bins=20, range=(-1, 1)) + histogram = [ + {"bin_start": round(float(bin_edges[i]), 3), "bin_end": round(float(bin_edges[i + 1]), 3), "count": int(hist[i])} + for i in range(len(hist)) + ] + + dist_info = { + "sample_size": int(len(sims)), + "mean": round(float(np.mean(sims)), 4), + "std": round(float(np.std(sims)), 4), + "min": round(float(np.min(sims)), 4), + "max": round(float(np.max(sims)), 4), + "percentiles": percentiles, + "histogram": histogram, + } + + self._report.similarity_distribution = dist_info + return dist_info + + # ------------------------------------------------------------------ # + # Full evaluation + # ------------------------------------------------------------------ # + + def run_full_evaluation( + self, + ground_truth: Optional[list[GroundTruthEntry]] = None, + candidate_meanings: Optional[dict[str, list[str]]] = None, + retrieval_queries: Optional[list[dict]] = None, + cluster_threshold: float = 0.35, + ) -> EvaluationReport: + """ + Run the complete evaluation pipeline. + + Args: + ground_truth: Labeled data for clustering and disambiguation eval. + candidate_meanings: Keyword -> candidate meanings for disambiguation. + retrieval_queries: Labeled queries for retrieval eval. + cluster_threshold: Clustering distance threshold. + + Returns: + Full EvaluationReport. + """ + logger.info("Running full evaluation pipeline...") + t0 = time.time() + + # Always compute similarity distribution + self.analyze_similarity_distribution() + + if retrieval_queries: + self.evaluate_retrieval(retrieval_queries) + + if ground_truth: + self.evaluate_clustering(ground_truth, cluster_threshold) + if candidate_meanings: + self.evaluate_disambiguation(ground_truth, candidate_meanings) + + self._report.timing["total_eval_seconds"] = round(time.time() - t0, 3) + logger.info("Evaluation complete.") + return self._report + + def get_report(self) -> EvaluationReport: + """Return the current evaluation report.""" + return self._report diff --git a/frontend/.gitignore b/frontend/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..a547bf36d8d11a4f89c59c144f24795749086dd1 --- /dev/null +++ b/frontend/.gitignore @@ -0,0 +1,24 @@ +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* +lerna-debug.log* + +node_modules +dist +dist-ssr +*.local + +# Editor directories and files +.vscode/* +!.vscode/extensions.json +.idea +.DS_Store +*.suo +*.ntvs* +*.njsproj +*.sln +*.sw? diff --git a/frontend/README.md b/frontend/README.md new file mode 100644 index 0000000000000000000000000000000000000000..18bc70ebe277fbfe6e55e6f9a0ae7e2c3e4bdd83 --- /dev/null +++ b/frontend/README.md @@ -0,0 +1,16 @@ +# React + Vite + +This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules. + +Currently, two official plugins are available: + +- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Babel](https://babeljs.io/) (or [oxc](https://oxc.rs) when used in [rolldown-vite](https://vite.dev/guide/rolldown)) for Fast Refresh +- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh + +## React Compiler + +The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation). + +## Expanding the ESLint configuration + +If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the [TS template](https://github.com/vitejs/vite/tree/main/packages/create-vite/template-react-ts) for information on how to integrate TypeScript and [`typescript-eslint`](https://typescript-eslint.io) in your project. diff --git a/frontend/eslint.config.js b/frontend/eslint.config.js new file mode 100644 index 0000000000000000000000000000000000000000..4fa125da29e01fa85529cfa06a83a7c0ce240d55 --- /dev/null +++ b/frontend/eslint.config.js @@ -0,0 +1,29 @@ +import js from '@eslint/js' +import globals from 'globals' +import reactHooks from 'eslint-plugin-react-hooks' +import reactRefresh from 'eslint-plugin-react-refresh' +import { defineConfig, globalIgnores } from 'eslint/config' + +export default defineConfig([ + globalIgnores(['dist']), + { + files: ['**/*.{js,jsx}'], + extends: [ + js.configs.recommended, + reactHooks.configs.flat.recommended, + reactRefresh.configs.vite, + ], + languageOptions: { + ecmaVersion: 2020, + globals: globals.browser, + parserOptions: { + ecmaVersion: 'latest', + ecmaFeatures: { jsx: true }, + sourceType: 'module', + }, + }, + rules: { + 'no-unused-vars': ['error', { varsIgnorePattern: '^[A-Z_]' }], + }, + }, +]) diff --git a/frontend/index.html b/frontend/index.html new file mode 100644 index 0000000000000000000000000000000000000000..418453c00798e920a4403ae0d04342bce2f06477 --- /dev/null +++ b/frontend/index.html @@ -0,0 +1,12 @@ + + + + + + Contextual Similarity Engine + + +
+ + + diff --git a/frontend/package-lock.json b/frontend/package-lock.json new file mode 100644 index 0000000000000000000000000000000000000000..2d7718eaabf873e60ab721ed098da9c8e5bb7d24 --- /dev/null +++ b/frontend/package-lock.json @@ -0,0 +1,3622 @@ +{ + "name": "contextual-similarity-ui", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "contextual-similarity-ui", + "version": "1.0.0", + "dependencies": { + "axios": "^1.13.6", + "react": "^19.2.4", + "react-dom": "^19.2.4", + "recharts": "^3.8.0" + }, + "devDependencies": { + "@eslint/js": "^9.39.4", + "@types/react": "^19.2.14", + "@types/react-dom": "^19.2.3", + "@vitejs/plugin-react": "^5.1.4", + "eslint": "^9.39.4", + "eslint-plugin-react-hooks": "^7.0.1", + "eslint-plugin-react-refresh": "^0.5.2", + "globals": "^17.4.0", + "typescript": "~5.9.3", + "vite": "^7.3.1" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz", + "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-validator-identifier": "^7.28.5", + "js-tokens": "^4.0.0", + "picocolors": "^1.1.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz", + "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz", + "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", + "@babel/helper-compilation-targets": "^7.28.6", + "@babel/helper-module-transforms": "^7.28.6", + "@babel/helpers": "^7.28.6", + "@babel/parser": "^7.29.0", + "@babel/template": "^7.28.6", + "@babel/traverse": "^7.29.0", + "@babel/types": "^7.29.0", + "@jridgewell/remapping": "^2.3.5", + "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/generator": { + "version": "7.29.1", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz", + "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.0", + "@babel/types": "^7.29.0", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz", + "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.28.6", + "@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-globals": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz", + "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz", + "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.28.6", + "@babel/types": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz", + "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.28.6", + "@babel/helper-validator-identifier": "^7.28.5", + "@babel/traverse": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz", + "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==", + "dev": true, + "license": "MIT", + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz", + "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==", + "dev": true, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.6.tgz", + "integrity": "sha512-xOBvwq86HHdB7WUDTfKfT/Vuxh7gElQ+Sfti2Cy6yIWNW05P8iUslOVcZ4/sKbE+/jQaukQAdz/gf3724kYdqw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.28.6", + "@babel/types": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.0.tgz", + "integrity": "sha512-IyDgFV5GeDUVX4YdF/3CPULtVGSXXMLh1xVIgdCgxApktqnQV0r7/8Nqthg+8YLGaAtdyIlo2qIdZrbCv4+7ww==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.0" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-self": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz", + "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==", + "dev": true, + "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-source": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz", + "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==", + "dev": true, + "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/template": { + "version": "7.28.6", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz", + "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.28.6", + "@babel/parser": "^7.28.6", + "@babel/types": "^7.28.6" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz", + "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.0", + "@babel/generator": "^7.29.0", + "@babel/helper-globals": "^7.28.0", + "@babel/parser": "^7.29.0", + "@babel/template": "^7.28.6", + "@babel/types": "^7.29.0", + "debug": "^4.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz", + "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.28.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@esbuild/aix-ppc64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.3.tgz", + "integrity": "sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.3.tgz", + "integrity": "sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.3.tgz", + "integrity": "sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.3.tgz", + "integrity": "sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.3.tgz", + "integrity": "sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.3.tgz", + "integrity": "sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.3.tgz", + "integrity": "sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.3.tgz", + "integrity": "sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.3.tgz", + "integrity": "sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.3.tgz", + "integrity": "sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.3.tgz", + "integrity": "sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.3.tgz", + "integrity": "sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.3.tgz", + "integrity": "sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==", + "cpu": [ + "mips64el" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.3.tgz", + "integrity": "sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.3.tgz", + "integrity": "sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.3.tgz", + "integrity": "sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.3.tgz", + "integrity": "sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.3.tgz", + "integrity": "sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.3.tgz", + "integrity": "sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.3.tgz", + "integrity": "sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.3.tgz", + "integrity": "sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/openharmony-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.3.tgz", + "integrity": "sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.3.tgz", + "integrity": "sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.3.tgz", + "integrity": "sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.3.tgz", + "integrity": "sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.3.tgz", + "integrity": "sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=18" + } + }, + "node_modules/@eslint-community/eslint-utils": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz", + "integrity": "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==", + "dev": true, + "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/eslint-utils/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==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^12.22.0 || ^14.17.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint-community/regexpp": { + "version": "4.12.2", + "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.2.tgz", + "integrity": "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^12.0.0 || ^14.0.0 || >=16.0.0" + } + }, + "node_modules/@eslint/config-array": { + "version": "0.21.2", + "resolved": "https://registry.npmjs.org/@eslint/config-array/-/config-array-0.21.2.tgz", + "integrity": "sha512-nJl2KGTlrf9GjLimgIru+V/mzgSK0ABCDQRvxw5BjURL7WfH5uoWmizbH7QB6MmnMBd8cIC9uceWnezL1VZWWw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/object-schema": "^2.1.7", + "debug": "^4.3.1", + "minimatch": "^3.1.5" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/config-helpers": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/@eslint/config-helpers/-/config-helpers-0.4.2.tgz", + "integrity": "sha512-gBrxN88gOIf3R7ja5K9slwNayVcZgK6SOUORm2uBzTeIEfeVaIhOpCtTox3P6R7o2jLFwLFTLnC7kU/RGcYEgw==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^0.17.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/core": { + "version": "0.17.0", + "resolved": "https://registry.npmjs.org/@eslint/core/-/core-0.17.0.tgz", + "integrity": "sha512-yL/sLrpmtDaFEiUj1osRP4TI2MDz1AddJL+jZ7KSqvBuliN4xqYY54IfdN8qD8Toa6g1iloph1fxQNkjOxrrpQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@types/json-schema": "^7.0.15" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/eslintrc": { + "version": "3.3.5", + "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-3.3.5.tgz", + "integrity": "sha512-4IlJx0X0qftVsN5E+/vGujTRIFtwuLbNsVUe7TO6zYPDR1O6nFwvwhIKEKSrl6dZchmYBITazxKoUYOjdtjlRg==", + "dev": true, + "license": "MIT", + "dependencies": { + "ajv": "^6.14.0", + "debug": "^4.3.2", + "espree": "^10.0.1", + "globals": "^14.0.0", + "ignore": "^5.2.0", + "import-fresh": "^3.2.1", + "js-yaml": "^4.1.1", + "minimatch": "^3.1.5", + "strip-json-comments": "^3.1.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/@eslint/eslintrc/node_modules/globals": { + "version": "14.0.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-14.0.0.tgz", + "integrity": "sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/@eslint/js": { + "version": "9.39.4", + "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.4.tgz", + "integrity": "sha512-nE7DEIchvtiFTwBw4Lfbu59PG+kCofhjsKaCWzxTpt4lfRjRMqG6uMBzKXuEcyXhOHoUp9riAm7/aWYGhXZ9cw==", + "dev": true, + "license": "MIT", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://eslint.org/donate" + } + }, + "node_modules/@eslint/object-schema": { + "version": "2.1.7", + "resolved": "https://registry.npmjs.org/@eslint/object-schema/-/object-schema-2.1.7.tgz", + "integrity": "sha512-VtAOaymWVfZcmZbp6E2mympDIHvyjXs/12LqWYjVw6qjrfF+VK+fyG33kChz3nnK+SU5/NeHOqrTEHS8sXO3OA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@eslint/plugin-kit": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/@eslint/plugin-kit/-/plugin-kit-0.4.1.tgz", + "integrity": "sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@eslint/core": "^0.17.0", + "levn": "^0.4.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + } + }, + "node_modules/@humanfs/core": { + "version": "0.19.1", + "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.1.tgz", + "integrity": "sha512-5DyQ4+1JEUzejeK1JGICcideyfUbGixgS9jNgex5nqkW+cY7WZhxBigmieN5Qnw9ZosSNVC9KQKyb+GUaGyKUA==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18.18.0" + } + }, + "node_modules/@humanfs/node": { + "version": "0.16.7", + "resolved": "https://registry.npmjs.org/@humanfs/node/-/node-0.16.7.tgz", + "integrity": "sha512-/zUx+yOsIrG4Y43Eh2peDeKCxlRt/gET6aHfaKpuq267qXdYDFViVHfMaLyygZOnl0kGWxFIgsBy8QFuTLUXEQ==", + "dev": true, + "license": "Apache-2.0", + "dependencies": { + "@humanfs/core": "^0.19.1", + "@humanwhocodes/retry": "^0.4.0" + }, + "engines": { + "node": ">=18.18.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==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=12.22" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@humanwhocodes/retry": { + "version": "0.4.3", + "resolved": "https://registry.npmjs.org/@humanwhocodes/retry/-/retry-0.4.3.tgz", + "integrity": "sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=18.18" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/nzakas" + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/remapping": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@reduxjs/toolkit": { + "version": "2.11.2", + "resolved": "https://registry.npmjs.org/@reduxjs/toolkit/-/toolkit-2.11.2.tgz", + "integrity": "sha512-Kd6kAHTA6/nUpp8mySPqj3en3dm0tdMIgbttnQ1xFMVpufoj+ADi8pXLBsd4xzTRHQa7t/Jv8W5UnCuW4kuWMQ==", + "license": "MIT", + "dependencies": { + "@standard-schema/spec": "^1.0.0", + "@standard-schema/utils": "^0.3.0", + "immer": "^11.0.0", + "redux": "^5.0.1", + "redux-thunk": "^3.1.0", + "reselect": "^5.1.0" + }, + "peerDependencies": { + "react": "^16.9.0 || ^17.0.0 || ^18 || ^19", + "react-redux": "^7.2.1 || ^8.1.3 || ^9.0.0" + }, + "peerDependenciesMeta": { + "react": { + "optional": true + }, + "react-redux": { + "optional": true + } + } + }, + "node_modules/@reduxjs/toolkit/node_modules/immer": { + "version": "11.1.4", + "resolved": "https://registry.npmjs.org/immer/-/immer-11.1.4.tgz", + "integrity": "sha512-XREFCPo6ksxVzP4E0ekD5aMdf8WMwmdNaz6vuvxgI40UaEiu6q3p8X52aU6GdyvLY3XXX/8R7JOTXStz/nBbRw==", + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/immer" + } + }, + "node_modules/@rolldown/pluginutils": { + "version": "1.0.0-rc.3", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.3.tgz", + "integrity": "sha512-eybk3TjzzzV97Dlj5c+XrBFW57eTNhzod66y9HrBlzJ6NsCrWCp/2kaPS3K9wJmurBC0Tdw4yPjXKZqlznim3Q==", + "dev": true, + "license": "MIT" + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.59.0.tgz", + "integrity": "sha512-upnNBkA6ZH2VKGcBj9Fyl9IGNPULcjXRlg0LLeaioQWueH30p6IXtJEbKAgvyv+mJaMxSm1l6xwDXYjpEMiLMg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.59.0.tgz", + "integrity": "sha512-hZ+Zxj3SySm4A/DylsDKZAeVg0mvi++0PYVceVyX7hemkw7OreKdCvW2oQ3T1FMZvCaQXqOTHb8qmBShoqk69Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.59.0.tgz", + "integrity": "sha512-W2Psnbh1J8ZJw0xKAd8zdNgF9HRLkdWwwdWqubSVk0pUuQkoHnv7rx4GiF9rT4t5DIZGAsConRE3AxCdJ4m8rg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.59.0.tgz", + "integrity": "sha512-ZW2KkwlS4lwTv7ZVsYDiARfFCnSGhzYPdiOU4IM2fDbL+QGlyAbjgSFuqNRbSthybLbIJ915UtZBtmuLrQAT/w==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.59.0.tgz", + "integrity": "sha512-EsKaJ5ytAu9jI3lonzn3BgG8iRBjV4LxZexygcQbpiU0wU0ATxhNVEpXKfUa0pS05gTcSDMKpn3Sx+QB9RlTTA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.59.0.tgz", + "integrity": "sha512-d3DuZi2KzTMjImrxoHIAODUZYoUUMsuUiY4SRRcJy6NJoZ6iIqWnJu9IScV9jXysyGMVuW+KNzZvBLOcpdl3Vg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.59.0.tgz", + "integrity": "sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.59.0.tgz", + "integrity": "sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.59.0.tgz", + "integrity": "sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.59.0.tgz", + "integrity": "sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.59.0.tgz", + "integrity": "sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.59.0.tgz", + "integrity": "sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q==", + "cpu": [ + "loong64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.59.0.tgz", + "integrity": "sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.59.0.tgz", + "integrity": "sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.59.0.tgz", + "integrity": "sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.59.0.tgz", + "integrity": "sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.59.0.tgz", + "integrity": "sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.59.0.tgz", + "integrity": "sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.59.0.tgz", + "integrity": "sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.59.0.tgz", + "integrity": "sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.59.0.tgz", + "integrity": "sha512-tt9KBJqaqp5i5HUZzoafHZX8b5Q2Fe7UjYERADll83O4fGqJ49O1FsL6LpdzVFQcpwvnyd0i+K/VSwu/o/nWlA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.59.0.tgz", + "integrity": "sha512-V5B6mG7OrGTwnxaNUzZTDTjDS7F75PO1ae6MJYdiMu60sq0CqN5CVeVsbhPxalupvTX8gXVSU9gq+Rx1/hvu6A==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.59.0.tgz", + "integrity": "sha512-UKFMHPuM9R0iBegwzKF4y0C4J9u8C6MEJgFuXTBerMk7EJ92GFVFYBfOZaSGLu6COf7FxpQNqhNS4c4icUPqxA==", + "cpu": [ + "ia32" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.59.0.tgz", + "integrity": "sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.59.0.tgz", + "integrity": "sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@standard-schema/spec": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz", + "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==", + "license": "MIT" + }, + "node_modules/@standard-schema/utils": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/@standard-schema/utils/-/utils-0.3.0.tgz", + "integrity": "sha512-e7Mew686owMaPJVNNLs55PUvgz371nKgwsc4vxE49zsODpJEnxgxRo2y/OKrqueavXgZNMDVj3DdHFlaSAeU8g==", + "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==", + "dev": true, + "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==", + "dev": true, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.1.0", + "@babel/types": "^7.0.0" + } + }, + "node_modules/@types/babel__traverse": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz", + "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.28.2" + } + }, + "node_modules/@types/d3-array": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-3.2.2.tgz", + "integrity": "sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw==", + "license": "MIT" + }, + "node_modules/@types/d3-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-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-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-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-shape": { + "version": "3.1.8", + "resolved": "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-3.1.8.tgz", + "integrity": "sha512-lae0iWfcDeR7qt7rA88BNiqdvPS5pFVPpo5OfjElwNaT2yyekbM0C9vK+yqBqEmHr6lDkRnYNoTBYlAgJa7a4w==", + "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-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/estree": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/react": { + "version": "19.2.14", + "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.14.tgz", + "integrity": "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==", + "devOptional": true, + "license": "MIT", + "dependencies": { + "csstype": "^3.2.2" + } + }, + "node_modules/@types/react-dom": { + "version": "19.2.3", + "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz", + "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "@types/react": "^19.2.0" + } + }, + "node_modules/@types/use-sync-external-store": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/@types/use-sync-external-store/-/use-sync-external-store-0.0.6.tgz", + "integrity": "sha512-zFDAD+tlpf2r4asuHEj0XH6pY6i0g5NeAHPn+15wk3BV6JA69eERFXC1gyGThDkVa1zCyKr5jox1+2LbV/AMLg==", + "license": "MIT" + }, + "node_modules/@vitejs/plugin-react": { + "version": "5.1.4", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-5.1.4.tgz", + "integrity": "sha512-VIcFLdRi/VYRU8OL/puL7QXMYafHmqOnwTZY50U1JPlCNj30PxCMx65c494b1K9be9hX83KVt0+gTEwTWLqToA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.29.0", + "@babel/plugin-transform-react-jsx-self": "^7.27.1", + "@babel/plugin-transform-react-jsx-source": "^7.27.1", + "@rolldown/pluginutils": "1.0.0-rc.3", + "@types/babel__core": "^7.20.5", + "react-refresh": "^0.18.0" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "peerDependencies": { + "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0" + } + }, + "node_modules/acorn": { + "version": "8.16.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz", + "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==", + "dev": true, + "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==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/ajv": { + "version": "6.14.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz", + "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==", + "dev": true, + "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/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "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==", + "dev": true, + "license": "Python-2.0" + }, + "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/axios": { + "version": "1.13.6", + "resolved": "https://registry.npmjs.org/axios/-/axios-1.13.6.tgz", + "integrity": "sha512-ChTCHMouEe2kn713WHbQGcuYrr6fXTBiu460OTwWrWob16g1bXn4vtz07Ope7ewMozJAnEquLk5lWQWtBig9DQ==", + "license": "MIT", + "dependencies": { + "follow-redirects": "^1.15.11", + "form-data": "^4.0.5", + "proxy-from-env": "^1.1.0" + } + }, + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/baseline-browser-mapping": { + "version": "2.10.0", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.0.tgz", + "integrity": "sha512-lIyg0szRfYbiy67j9KN8IyeD7q7hcmqnJ1ddWmNt19ItGpNN64mnllmxUNFIOdOm6by97jlL6wfpTTJrmnjWAA==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.cjs" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/brace-expansion": { + "version": "1.1.12", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz", + "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==", + "dev": true, + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/browserslist": { + "version": "4.28.1", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.1.tgz", + "integrity": "sha512-ZC5Bd0LgJXgwGqUknZY/vkUQ04r8NXnJZ3yYi4vDmSiZmC/pdSN0NbNRPxZpbtO4uAfDUAFffO8IZoM3Gj8IkA==", + "dev": true, + "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": { + "baseline-browser-mapping": "^2.9.0", + "caniuse-lite": "^1.0.30001759", + "electron-to-chromium": "^1.5.263", + "node-releases": "^2.0.27", + "update-browserslist-db": "^1.2.0" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "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/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001777", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001777.tgz", + "integrity": "sha512-tmN+fJxroPndC74efCdp12j+0rk0RHwV5Jwa1zWaFVyw2ZxAuPeG8ZgWC3Wz7uSjT3qMRQ5XHZ4COgQmsCMJAQ==", + "dev": true, + "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/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "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/clsx": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz", + "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "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==", + "dev": true, + "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==", + "dev": true, + "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/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true, + "license": "MIT" + }, + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/cross-spawn": { + "version": "7.0.6", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz", + "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==", + "dev": true, + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", + "devOptional": true, + "license": "MIT" + }, + "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-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-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-format": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-3.1.2.tgz", + "integrity": "sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg==", + "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-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-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/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "dev": true, + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/decimal.js-light": { + "version": "2.5.1", + "resolved": "https://registry.npmjs.org/decimal.js-light/-/decimal.js-light-2.5.1.tgz", + "integrity": "sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==", + "license": "MIT" + }, + "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==", + "dev": true, + "license": "MIT" + }, + "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/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/electron-to-chromium": { + "version": "1.5.307", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.307.tgz", + "integrity": "sha512-5z3uFKBWjiNR44nFcYdkcXjKMbg5KXNdciu7mhTPo9tB7NbqSNP2sSnGR+fqknZSCwKkBN+oxiiajWs4dT6ORg==", + "dev": true, + "license": "ISC" + }, + "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-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-toolkit": { + "version": "1.45.1", + "resolved": "https://registry.npmjs.org/es-toolkit/-/es-toolkit-1.45.1.tgz", + "integrity": "sha512-/jhoOj/Fx+A+IIyDNOvO3TItGmlMKhtX8ISAHKE90c4b/k1tqaqEZ+uUqfpU8DMnW5cgNJv606zS55jGvza0Xw==", + "license": "MIT", + "workspaces": [ + "docs", + "benchmarks" + ] + }, + "node_modules/esbuild": { + "version": "0.27.3", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.3.tgz", + "integrity": "sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=18" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.27.3", + "@esbuild/android-arm": "0.27.3", + "@esbuild/android-arm64": "0.27.3", + "@esbuild/android-x64": "0.27.3", + "@esbuild/darwin-arm64": "0.27.3", + "@esbuild/darwin-x64": "0.27.3", + "@esbuild/freebsd-arm64": "0.27.3", + "@esbuild/freebsd-x64": "0.27.3", + "@esbuild/linux-arm": "0.27.3", + "@esbuild/linux-arm64": "0.27.3", + "@esbuild/linux-ia32": "0.27.3", + "@esbuild/linux-loong64": "0.27.3", + "@esbuild/linux-mips64el": "0.27.3", + "@esbuild/linux-ppc64": "0.27.3", + "@esbuild/linux-riscv64": "0.27.3", + "@esbuild/linux-s390x": "0.27.3", + "@esbuild/linux-x64": "0.27.3", + "@esbuild/netbsd-arm64": "0.27.3", + "@esbuild/netbsd-x64": "0.27.3", + "@esbuild/openbsd-arm64": "0.27.3", + "@esbuild/openbsd-x64": "0.27.3", + "@esbuild/openharmony-arm64": "0.27.3", + "@esbuild/sunos-x64": "0.27.3", + "@esbuild/win32-arm64": "0.27.3", + "@esbuild/win32-ia32": "0.27.3", + "@esbuild/win32-x64": "0.27.3" + } + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint": { + "version": "9.39.4", + "resolved": "https://registry.npmjs.org/eslint/-/eslint-9.39.4.tgz", + "integrity": "sha512-XoMjdBOwe/esVgEvLmNsD3IRHkm7fbKIUGvrleloJXUZgDHig2IPWNniv+GwjyJXzuNqVjlr5+4yVUZjycJwfQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@eslint-community/eslint-utils": "^4.8.0", + "@eslint-community/regexpp": "^4.12.1", + "@eslint/config-array": "^0.21.2", + "@eslint/config-helpers": "^0.4.2", + "@eslint/core": "^0.17.0", + "@eslint/eslintrc": "^3.3.5", + "@eslint/js": "9.39.4", + "@eslint/plugin-kit": "^0.4.1", + "@humanfs/node": "^0.16.6", + "@humanwhocodes/module-importer": "^1.0.1", + "@humanwhocodes/retry": "^0.4.2", + "@types/estree": "^1.0.6", + "ajv": "^6.14.0", + "chalk": "^4.0.0", + "cross-spawn": "^7.0.6", + "debug": "^4.3.2", + "escape-string-regexp": "^4.0.0", + "eslint-scope": "^8.4.0", + "eslint-visitor-keys": "^4.2.1", + "espree": "^10.4.0", + "esquery": "^1.5.0", + "esutils": "^2.0.2", + "fast-deep-equal": "^3.1.3", + "file-entry-cache": "^8.0.0", + "find-up": "^5.0.0", + "glob-parent": "^6.0.2", + "ignore": "^5.2.0", + "imurmurhash": "^0.1.4", + "is-glob": "^4.0.0", + "json-stable-stringify-without-jsonify": "^1.0.1", + "lodash.merge": "^4.6.2", + "minimatch": "^3.1.5", + "natural-compare": "^1.4.0", + "optionator": "^0.9.3" + }, + "bin": { + "eslint": "bin/eslint.js" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://eslint.org/donate" + }, + "peerDependencies": { + "jiti": "*" + }, + "peerDependenciesMeta": { + "jiti": { + "optional": true + } + } + }, + "node_modules/eslint-plugin-react-hooks": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-7.0.1.tgz", + "integrity": "sha512-O0d0m04evaNzEPoSW+59Mezf8Qt0InfgGIBJnpC0h3NH/WjUAR7BIKUfysC6todmtiZ/A0oUVS8Gce0WhBrHsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/core": "^7.24.4", + "@babel/parser": "^7.24.4", + "hermes-parser": "^0.25.1", + "zod": "^3.25.0 || ^4.0.0", + "zod-validation-error": "^3.5.0 || ^4.0.0" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "eslint": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 || ^9.0.0" + } + }, + "node_modules/eslint-plugin-react-refresh": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/eslint-plugin-react-refresh/-/eslint-plugin-react-refresh-0.5.2.tgz", + "integrity": "sha512-hmgTH57GfzoTFjVN0yBwTggnsVUF2tcqi7RJZHqi9lIezSs4eFyAMktA68YD4r5kNw1mxyY4dmkyoFDb3FIqrA==", + "dev": true, + "license": "MIT", + "peerDependencies": { + "eslint": "^9 || ^10" + } + }, + "node_modules/eslint-scope": { + "version": "8.4.0", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-8.4.0.tgz", + "integrity": "sha512-sNXOfKCn74rt8RICKMvJS7XKV/Xk9kA7DyJr8mJik3S7Cwgy3qlkkmyS2uQB3jiJg6VNdZd/pDBJu0nvG2NlTg==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^5.2.0" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/eslint-visitor-keys": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-4.2.1.tgz", + "integrity": "sha512-Uhdk5sfqcee/9H/rCOJikYz67o0a2Tw2hGRPOG2Y1R2dg7brRe1uG0yaNQDHu+TO/uQPF/5eCapvYSmHUjt7JQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/espree": { + "version": "10.4.0", + "resolved": "https://registry.npmjs.org/espree/-/espree-10.4.0.tgz", + "integrity": "sha512-j6PAQ2uUr79PZhBjP5C5fhl8e39FmRnOjsD5lGnWrFU8i2G776tBK7+nP8KuQUTTyAZUwfQqXAgrVH5MbH9CYQ==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "acorn": "^8.15.0", + "acorn-jsx": "^5.3.2", + "eslint-visitor-keys": "^4.2.1" + }, + "engines": { + "node": "^18.18.0 || ^20.9.0 || >=21.1.0" + }, + "funding": { + "url": "https://opencollective.com/eslint" + } + }, + "node_modules/esquery": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.7.0.tgz", + "integrity": "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==", + "dev": true, + "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==", + "dev": true, + "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==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/esutils": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz", + "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/eventemitter3": { + "version": "5.0.4", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.4.tgz", + "integrity": "sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==", + "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==", + "dev": true, + "license": "MIT" + }, + "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==", + "dev": true, + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/file-entry-cache": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-8.0.0.tgz", + "integrity": "sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "flat-cache": "^4.0.0" + }, + "engines": { + "node": ">=16.0.0" + } + }, + "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==", + "dev": true, + "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/flat-cache": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-4.0.1.tgz", + "integrity": "sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==", + "dev": true, + "license": "MIT", + "dependencies": { + "flatted": "^3.2.9", + "keyv": "^4.5.4" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/flatted": { + "version": "3.4.1", + "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.4.1.tgz", + "integrity": "sha512-IxfVbRFVlV8V/yRaGzk0UVIcsKKHMSfYw66T/u4nTwlWteQePsxe//LjudR1AMX4tZW3WFCh3Zqa/sjlqpbURQ==", + "dev": true, + "license": "ISC" + }, + "node_modules/follow-redirects": { + "version": "1.15.11", + "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz", + "integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "license": "MIT", + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, + "node_modules/form-data": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz", + "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==", + "license": "MIT", + "dependencies": { + "asynckit": "^0.4.0", + "combined-stream": "^1.0.8", + "es-set-tostringtag": "^2.1.0", + "hasown": "^2.0.2", + "mime-types": "^2.1.12" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "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/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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "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-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/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==", + "dev": true, + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/globals": { + "version": "17.4.0", + "resolved": "https://registry.npmjs.org/globals/-/globals-17.4.0.tgz", + "integrity": "sha512-hjrNztw/VajQwOLsMNT1cbJiH2muO3OROCHnbehc8eY5JyD2gqz4AcMHPqgaOR59DjgUjYAYLeH699g/eWi2jw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18" + }, + "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/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "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/hermes-estree": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/hermes-estree/-/hermes-estree-0.25.1.tgz", + "integrity": "sha512-0wUoCcLp+5Ev5pDW2OriHC2MJCbwLwuRx+gAqMTOkGKJJiBCLjtrvy4PWUGn6MIVefecRpzoOZ/UV6iGdOr+Cw==", + "dev": true, + "license": "MIT" + }, + "node_modules/hermes-parser": { + "version": "0.25.1", + "resolved": "https://registry.npmjs.org/hermes-parser/-/hermes-parser-0.25.1.tgz", + "integrity": "sha512-6pEjquH3rqaI6cYAXYPcz9MS4rY6R4ngRgrgfDshRptUZIc3lw0MCIJIGDj9++mfySOuPTHB4nrSW99BCvOPIA==", + "dev": true, + "license": "MIT", + "dependencies": { + "hermes-estree": "0.25.1" + } + }, + "node_modules/ignore": { + "version": "5.3.2", + "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz", + "integrity": "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/immer": { + "version": "10.2.0", + "resolved": "https://registry.npmjs.org/immer/-/immer-10.2.0.tgz", + "integrity": "sha512-d/+XTN3zfODyjr89gM3mPq1WNX2B8pYsu7eORitdwyA2sBubnTl3laYlBk4sXY5FUa5qTZGBDPJICVbvqzjlbw==", + "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==", + "dev": true, + "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/imurmurhash": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz", + "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.8.19" + } + }, + "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/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true, + "license": "ISC" + }, + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/js-yaml": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz", + "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==", + "dev": true, + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "dev": true, + "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==", + "dev": true, + "license": "MIT" + }, + "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==", + "dev": true, + "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==", + "dev": true, + "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==", + "dev": true, + "license": "MIT", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "json-buffer": "3.0.1" + } + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1", + "type-check": "~0.4.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "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==", + "dev": true, + "license": "MIT" + }, + "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==", + "dev": true, + "license": "ISC", + "dependencies": { + "yallist": "^3.0.2" + } + }, + "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/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/minimatch": { + "version": "3.1.5", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz", + "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==", + "dev": true, + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/nanoid": { + "version": "3.3.11", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz", + "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", + "dev": true, + "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==", + "dev": true, + "license": "MIT" + }, + "node_modules/node-releases": { + "version": "2.0.36", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.36.tgz", + "integrity": "sha512-TdC8FSgHz8Mwtw9g5L4gR/Sh9XhSP/0DEkQxfEFXOpiul5IiHgHan2VhYYb6agDSfp4KuvltmGApc8HMgUrIkA==", + "dev": true, + "license": "MIT" + }, + "node_modules/optionator": { + "version": "0.9.4", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz", + "integrity": "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==", + "dev": true, + "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/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz", + "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/postcss": { + "version": "8.5.8", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.8.tgz", + "integrity": "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==", + "dev": true, + "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.11", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 0.8.0" + } + }, + "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/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/react": { + "version": "19.2.4", + "resolved": "https://registry.npmjs.org/react/-/react-19.2.4.tgz", + "integrity": "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "19.2.4", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.4.tgz", + "integrity": "sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ==", + "license": "MIT", + "dependencies": { + "scheduler": "^0.27.0" + }, + "peerDependencies": { + "react": "^19.2.4" + } + }, + "node_modules/react-is": { + "version": "19.2.4", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-19.2.4.tgz", + "integrity": "sha512-W+EWGn2v0ApPKgKKCy/7s7WHXkboGcsrXE+2joLyVxkbyVQfO3MUEaUQDHoSmb8TFFrSKYa9mw64WZHNHSDzYA==", + "license": "MIT", + "peer": true + }, + "node_modules/react-redux": { + "version": "9.2.0", + "resolved": "https://registry.npmjs.org/react-redux/-/react-redux-9.2.0.tgz", + "integrity": "sha512-ROY9fvHhwOD9ySfrF0wmvu//bKCQ6AeZZq1nJNtbDC+kk5DuSuNX/n6YWYF/SYy7bSba4D4FSz8DJeKY/S/r+g==", + "license": "MIT", + "dependencies": { + "@types/use-sync-external-store": "^0.0.6", + "use-sync-external-store": "^1.4.0" + }, + "peerDependencies": { + "@types/react": "^18.2.25 || ^19", + "react": "^18.0 || ^19", + "redux": "^5.0.0" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "redux": { + "optional": true + } + } + }, + "node_modules/react-refresh": { + "version": "0.18.0", + "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.18.0.tgz", + "integrity": "sha512-QgT5//D3jfjJb6Gsjxv0Slpj23ip+HtOpnNgnb2S5zU3CB26G/IDPGoy4RJB42wzFE46DRsstbW6tKHoKbhAxw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/recharts": { + "version": "3.8.0", + "resolved": "https://registry.npmjs.org/recharts/-/recharts-3.8.0.tgz", + "integrity": "sha512-Z/m38DX3L73ExO4Tpc9/iZWHmHnlzWG4njQbxsF5aSjwqmHNDDIm0rdEBArkwsBvR8U6EirlEHiQNYWCVh9sGQ==", + "license": "MIT", + "workspaces": [ + "www" + ], + "dependencies": { + "@reduxjs/toolkit": "^1.9.0 || 2.x.x", + "clsx": "^2.1.1", + "decimal.js-light": "^2.5.1", + "es-toolkit": "^1.39.3", + "eventemitter3": "^5.0.1", + "immer": "^10.1.1", + "react-redux": "8.x.x || 9.x.x", + "reselect": "5.1.1", + "tiny-invariant": "^1.3.3", + "use-sync-external-store": "^1.2.2", + "victory-vendor": "^37.0.2" + }, + "engines": { + "node": ">=18" + }, + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0", + "react-is": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/redux": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/redux/-/redux-5.0.1.tgz", + "integrity": "sha512-M9/ELqF6fy8FwmkpnF0S3YKOqMyoWJ4+CS5Efg2ct3oY9daQvd/Pc71FpGZsVsbl3Cpb+IIcjBDUnnyBdQbq4w==", + "license": "MIT" + }, + "node_modules/redux-thunk": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/redux-thunk/-/redux-thunk-3.1.0.tgz", + "integrity": "sha512-NW2r5T6ksUKXCabzhL9z+h206HQw/NJkcLm1GPImRQ8IzfXwRGqjVhKJGauHirT0DAuyy6hjdnMZaRoAcy0Klw==", + "license": "MIT", + "peerDependencies": { + "redux": "^5.0.0" + } + }, + "node_modules/reselect": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/reselect/-/reselect-5.1.1.tgz", + "integrity": "sha512-K/BG6eIky/SBpzfHZv/dd+9JBFiS4SWV7FIujVyJRux6e45+73RaUHXLmIR1f7WOMaQ0U1km6qwklRQxpJJY0w==", + "license": "MIT" + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/rollup": { + "version": "4.59.0", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.59.0.tgz", + "integrity": "sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/estree": "1.0.8" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.59.0", + "@rollup/rollup-android-arm64": "4.59.0", + "@rollup/rollup-darwin-arm64": "4.59.0", + "@rollup/rollup-darwin-x64": "4.59.0", + "@rollup/rollup-freebsd-arm64": "4.59.0", + "@rollup/rollup-freebsd-x64": "4.59.0", + "@rollup/rollup-linux-arm-gnueabihf": "4.59.0", + "@rollup/rollup-linux-arm-musleabihf": "4.59.0", + "@rollup/rollup-linux-arm64-gnu": "4.59.0", + "@rollup/rollup-linux-arm64-musl": "4.59.0", + "@rollup/rollup-linux-loong64-gnu": "4.59.0", + "@rollup/rollup-linux-loong64-musl": "4.59.0", + "@rollup/rollup-linux-ppc64-gnu": "4.59.0", + "@rollup/rollup-linux-ppc64-musl": "4.59.0", + "@rollup/rollup-linux-riscv64-gnu": "4.59.0", + "@rollup/rollup-linux-riscv64-musl": "4.59.0", + "@rollup/rollup-linux-s390x-gnu": "4.59.0", + "@rollup/rollup-linux-x64-gnu": "4.59.0", + "@rollup/rollup-linux-x64-musl": "4.59.0", + "@rollup/rollup-openbsd-x64": "4.59.0", + "@rollup/rollup-openharmony-arm64": "4.59.0", + "@rollup/rollup-win32-arm64-msvc": "4.59.0", + "@rollup/rollup-win32-ia32-msvc": "4.59.0", + "@rollup/rollup-win32-x64-gnu": "4.59.0", + "@rollup/rollup-win32-x64-msvc": "4.59.0", + "fsevents": "~2.3.2" + } + }, + "node_modules/scheduler": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz", + "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==", + "license": "MIT" + }, + "node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "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==", + "dev": true, + "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==", + "dev": true, + "license": "MIT", + "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==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/tiny-invariant": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.3.tgz", + "integrity": "sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==", + "license": "MIT" + }, + "node_modules/tinyglobby": { + "version": "0.2.15", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz", + "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.3" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "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==", + "dev": true, + "license": "MIT", + "dependencies": { + "prelude-ls": "^1.2.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/typescript": { + "version": "5.9.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz", + "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/update-browserslist-db": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz", + "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==", + "dev": true, + "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==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/use-sync-external-store": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.6.0.tgz", + "integrity": "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==", + "license": "MIT", + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/victory-vendor": { + "version": "37.3.6", + "resolved": "https://registry.npmjs.org/victory-vendor/-/victory-vendor-37.3.6.tgz", + "integrity": "sha512-SbPDPdDBYp+5MJHhBCAyI7wKM3d5ivekigc2Dk2s7pgbZ9wIgIBYGVw4zGHBml/qTFbexrofXW6Gu4noGxrOwQ==", + "license": "MIT AND ISC", + "dependencies": { + "@types/d3-array": "^3.0.3", + "@types/d3-ease": "^3.0.0", + "@types/d3-interpolate": "^3.0.1", + "@types/d3-scale": "^4.0.2", + "@types/d3-shape": "^3.1.0", + "@types/d3-time": "^3.0.0", + "@types/d3-timer": "^3.0.0", + "d3-array": "^3.1.6", + "d3-ease": "^3.0.1", + "d3-interpolate": "^3.0.1", + "d3-scale": "^4.0.2", + "d3-shape": "^3.1.0", + "d3-time": "^3.0.0", + "d3-timer": "^3.0.1" + } + }, + "node_modules/vite": { + "version": "7.3.1", + "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz", + "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==", + "dev": true, + "license": "MIT", + "dependencies": { + "esbuild": "^0.27.0", + "fdir": "^6.5.0", + "picomatch": "^4.0.3", + "postcss": "^8.5.6", + "rollup": "^4.43.0", + "tinyglobby": "^0.2.15" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^20.19.0 || >=22.12.0", + "jiti": ">=1.21.0", + "less": "^4.0.0", + "lightningcss": "^1.21.0", + "sass": "^1.70.0", + "sass-embedded": "^1.70.0", + "stylus": ">=0.54.8", + "sugarss": "^5.0.0", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/which": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz", + "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==", + "dev": true, + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/word-wrap": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", + "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true, + "license": "ISC" + }, + "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==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/zod": { + "version": "4.3.6", + "resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz", + "integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/colinhacks" + } + }, + "node_modules/zod-validation-error": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/zod-validation-error/-/zod-validation-error-4.0.2.tgz", + "integrity": "sha512-Q6/nZLe6jxuU80qb/4uJ4t5v2VEZ44lzQjPDhYJNztRQ4wyWc6VF3D3Kb/fAuPetZQnhS3hnajCf9CsWesghLQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=18.0.0" + }, + "peerDependencies": { + "zod": "^3.25.0 || ^4.0.0" + } + } + } +} diff --git a/frontend/package.json b/frontend/package.json new file mode 100644 index 0000000000000000000000000000000000000000..a85baf1c8166ad868d69a003a7f0b4590eef488c --- /dev/null +++ b/frontend/package.json @@ -0,0 +1,30 @@ +{ + "name": "contextual-similarity-ui", + "private": true, + "version": "1.0.0", + "type": "module", + "scripts": { + "dev": "vite", + "build": "tsc -b && vite build", + "lint": "eslint .", + "preview": "vite preview" + }, + "dependencies": { + "axios": "^1.13.6", + "react": "^19.2.4", + "react-dom": "^19.2.4", + "recharts": "^3.8.0" + }, + "devDependencies": { + "@eslint/js": "^9.39.4", + "@types/react": "^19.2.14", + "@types/react-dom": "^19.2.3", + "@vitejs/plugin-react": "^5.1.4", + "eslint": "^9.39.4", + "eslint-plugin-react-hooks": "^7.0.1", + "eslint-plugin-react-refresh": "^0.5.2", + "globals": "^17.4.0", + "typescript": "~5.9.3", + "vite": "^7.3.1" + } +} diff --git a/frontend/public/vite.svg b/frontend/public/vite.svg new file mode 100644 index 0000000000000000000000000000000000000000..e7b8dfb1b2a60bd50538bec9f876511b9cac21e3 --- /dev/null +++ b/frontend/public/vite.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx new file mode 100644 index 0000000000000000000000000000000000000000..c8d14b815297a5b5f35c31d47502f2790102d728 --- /dev/null +++ b/frontend/src/App.tsx @@ -0,0 +1,182 @@ +import { useState, useEffect, Fragment } from "react"; +import type { CorpusStats } from "./types"; +import { api, checkConnection } from "./api"; +import TrainingPanel from "./components/TrainingPanel"; +import EngineSetup from "./components/EngineSetup"; +import SemanticSearch from "./components/SemanticSearch"; +import TextCompare from "./components/TextCompare"; +import KeywordAnalysis from "./components/KeywordAnalysis"; +import KeywordMatcher from "./components/KeywordMatcher"; +import BatchAnalysis from "./components/BatchAnalysis"; +import SimilarWords from "./components/SimilarWords"; +import ContextAnalysis from "./components/ContextAnalysis"; +import EvaluationDashboard from "./components/EvaluationDashboard"; +import Word2VecPanel from "./components/Word2VecPanel"; +import DatasetPanel from "./components/DatasetPanel"; +import "./styles.css"; + +type NavGroup = "data" | "training" | "analysis" | "evaluation"; +type TrainingTab = "model" | "w2v"; +type AnalysisTab = "context" | "words" | "search" | "compare" | "keyword" | "match" | "batch"; + +const STEPS: { id: NavGroup; label: string; needsIndex?: boolean }[] = [ + { id: "data", label: "Data & Setup" }, + { id: "training", label: "Training" }, + { id: "analysis", label: "Analysis", needsIndex: true }, + { id: "evaluation", label: "Evaluation", needsIndex: true }, +]; + +const TRAINING_TABS: { id: TrainingTab; label: string }[] = [ + { id: "model", label: "Fine-tune Model" }, + { id: "w2v", label: "Word2Vec Baseline" }, +]; + +const ANALYSIS_TABS: { id: AnalysisTab; label: string }[] = [ + { id: "context", label: "Context" }, + { id: "words", label: "Similar Words" }, + { id: "search", label: "Search" }, + { id: "compare", label: "Compare" }, + { id: "keyword", label: "Keywords" }, + { id: "match", label: "Matcher" }, + { id: "batch", label: "Batch" }, +]; + +export default function App() { + const [group, setGroup] = useState("data"); + const [trainingTab, setTrainingTab] = useState("model"); + const [analysisTab, setAnalysisTab] = useState("context"); + const [stats, setStats] = useState(null); + const [showManualSetup, setShowManualSetup] = useState(false); + const [serverError, setServerError] = useState(null); + const ready = stats !== null && stats.index_built; + + useEffect(() => { + checkConnection().then((err) => { + setServerError(err); + // If server is up, try to fetch stats (engine may have been auto-restored) + if (!err) { + api.getStats().then(setStats).catch(() => {}); + } + }); + const interval = setInterval(() => { + checkConnection().then(setServerError); + }, 15000); + return () => clearInterval(interval); + }, []); + + function handleStepClick(id: NavGroup, needsIndex?: boolean) { + if (needsIndex && !ready) return; + setGroup(id); + } + + return ( +
+
+

Contextual Similarity Engine

+ {stats && ( +
+ {stats.model_name} + {stats.total_documents} docs + {stats.total_chunks} chunks + + {stats.index_built ? "Index ready" : "Index not built"} + +
+ )} +
+ + {serverError && ( +
+ Server unavailable: {serverError} +
+ )} + + {/* Progress Stepper (serves as main navigation) */} + + + {/* Sub-tabs for groups with multiple views */} + {group === "training" && ( + + )} + + {group === "analysis" && ( + + )} + + {/* Content */} +
+ {group === "data" && ( + <> + + + {showManualSetup && } + + )} + + {group === "training" && trainingTab === "model" && } + {group === "training" && trainingTab === "w2v" && } + + {group === "analysis" && analysisTab === "context" && } + {group === "analysis" && analysisTab === "words" && } + {group === "analysis" && analysisTab === "search" && } + {group === "analysis" && analysisTab === "compare" && } + {group === "analysis" && analysisTab === "keyword" && } + {group === "analysis" && analysisTab === "match" && } + {group === "analysis" && analysisTab === "batch" && } + + {group === "evaluation" && } +
+
+ ); +} diff --git a/frontend/src/api.ts b/frontend/src/api.ts new file mode 100644 index 0000000000000000000000000000000000000000..983d9ef1f15b3e32842ef75fe676067d9117fcb8 --- /dev/null +++ b/frontend/src/api.ts @@ -0,0 +1,144 @@ +import axios from "axios"; +import type { + InitRequest, InitResponse, DocumentRequest, AddDocResponse, BuildIndexResponse, + QueryRequest, QueryResponse, CompareRequest, CompareResponse, + KeywordAnalysisRequest, KeywordAnalysisResponse, + KeywordMatchRequest, MatchResponse, BatchAnalysisRequest, + CorpusStats, SimilarityDistribution, DisambiguationMetric, RetrievalMetric, + TrainResponse, TrainEvalResponse, + W2VInitResponse, W2VQueryResult, W2VSimilarWord, + DatasetInfo, DatasetLoadRequest, DatasetLoadResponse, DatasetPreviewResponse, + ContextAnalysisResponse, +} from "./types"; + +const client = axios.create({ baseURL: "/api" }); +const long = { timeout: 600000 }; + +/** Extract a human-readable error message from an Axios error. */ +export function getErrorMessage(err: unknown): string { + if (axios.isAxiosError(err)) { + if (err.code === "ECONNABORTED") return "Request timed out. The server may be busy."; + if (!err.response) return "Cannot connect to server. Is it running? (uv run python server.py)"; + const detail = err.response.data?.detail; + if (typeof detail === "string") return detail; + if (typeof err.response.data === "string") return err.response.data; + return `Server error (${err.response.status})`; + } + if (err instanceof Error) return err.message; + return "An unexpected error occurred."; +} + +/** Check if the backend is reachable. Returns null on success or an error message. */ +export async function checkConnection(): Promise { + try { + await client.get("/stats", { timeout: 5000 }); + return null; + } catch (err) { + if (axios.isAxiosError(err) && err.response?.status === 400) { + // 400 = "Engine not initialized" — server is up, just no engine yet + return null; + } + return getErrorMessage(err); + } +} + +/** Shared shape for all training requests (matches server TrainRequest). */ +interface TrainRequestData { + corpus_texts: string[]; + base_model: string; + output_path: string; + epochs: number; + batch_size: number; +} + +export const api = { + // ---- Training ---- + trainUnsupervised: (data: TrainRequestData) => + client.post("/train/unsupervised", data, long).then(r => r.data), + + trainContrastive: (data: TrainRequestData) => + client.post("/train/contrastive", data, long).then(r => r.data), + + trainKeywords: (data: TrainRequestData & { keyword_meanings: Record }) => + client.post("/train/keywords", data, long).then(r => r.data), + + trainEvaluate: (data: { test_pairs: { text_a: string; text_b: string; expected: number }[]; trained_model_path: string; base_model: string; corpus_texts: string[] }) => + client.post("/train/evaluate", data).then(r => r.data), + + // ---- Engine ---- + init: (data: InitRequest) => + client.post("/init", data).then(r => r.data), + + addDocument: (data: DocumentRequest) => + client.post("/documents", data).then(r => r.data), + + buildIndex: () => + client.post("/index/build").then(r => r.data), + + query: (data: QueryRequest) => + client.post("/query", data).then(r => r.data), + + compare: (data: CompareRequest) => + client.post("/compare", data).then(r => r.data), + + analyzeKeyword: (data: KeywordAnalysisRequest) => + client.post("/analyze/keyword", data).then(r => r.data), + + batchAnalyze: (data: BatchAnalysisRequest) => + client.post>("/analyze/batch", data).then(r => r.data), + + matchKeyword: (data: KeywordMatchRequest) => + client.post("/match", data).then(r => r.data), + + analyzeContext: (data: { keyword: string; cluster_threshold?: number; top_words?: number }) => + client.post("/analyze/context", data).then(r => r.data), + + similarWords: (data: { word: string; top_k: number }) => + client.post<{ word: string; similar: { word: string; score: number }[] }>("/analyze/similar-words", data).then(r => r.data), + + getStats: () => + client.get("/stats").then(r => r.data), + + getCorpusTexts: (maxDocs: number = 500) => + client.get<{ documents: { doc_id: string; text: string }[]; count: number }>(`/corpus/texts?max_docs=${maxDocs}`).then(r => r.data), + + // ---- Engine persistence ---- + saveEngine: () => + client.post<{ status: string; chunks: number; documents: number }>("/engine/save").then(r => r.data), + + hasSavedState: () => + client.get<{ exists: boolean }>("/engine/has-saved-state").then(r => r.data), + + // ---- Evaluation ---- + getSimilarityDistribution: () => + client.get("/eval/similarity-distribution").then(r => r.data), + + evalDisambiguation: (data: { ground_truth: { keyword: string; text: string; true_meaning: string }[]; candidate_meanings: Record }) => + client.post<{ metrics: DisambiguationMetric[] }>("/eval/disambiguation", data).then(r => r.data), + + evalRetrieval: (data: { queries: { query: string; relevant_doc_ids?: string[]; relevant_texts?: string[] }[]; k_values: number[] }) => + client.post<{ metrics: RetrievalMetric[] }>("/eval/retrieval", data).then(r => r.data), + + // ---- Word2Vec ---- + w2vInit: (data: { corpus_texts: string[]; vector_size: number; window: number; epochs: number }) => + client.post("/w2v/init", data, long).then(r => r.data), + + w2vCompare: (data: { text_a: string; text_b: string }) => + client.post("/w2v/compare", data).then(r => r.data), + + w2vQuery: (data: { text: string; top_k: number }) => + client.post<{ query: string; results: W2VQueryResult[] }>("/w2v/query", data).then(r => r.data), + + w2vSimilarWords: (data: { word: string; top_k: number }) => + client.post<{ word: string; similar: W2VSimilarWord[] }>("/w2v/similar-words", data).then(r => r.data), + + // ---- Dataset (HuggingFace) ---- + datasetInfo: () => + client.get("/dataset/info").then(r => r.data), + + datasetLoad: (data: DatasetLoadRequest) => + client.post("/dataset/load", data, long).then(r => r.data), + + datasetPreview: (maxDocs: number = 10, sourceFilter?: string) => + client.post(`/dataset/preview?max_docs=${maxDocs}${sourceFilter ? `&source_filter=${sourceFilter}` : ""}`).then(r => r.data), +}; diff --git a/frontend/src/assets/react.svg b/frontend/src/assets/react.svg new file mode 100644 index 0000000000000000000000000000000000000000..6c87de9bb3358469122cc991d5cf578927246184 --- /dev/null +++ b/frontend/src/assets/react.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/frontend/src/components/BatchAnalysis.tsx b/frontend/src/components/BatchAnalysis.tsx new file mode 100644 index 0000000000000000000000000000000000000000..b32a822b46fa828c2c7ba671fd5c83c4c4cbf4cd --- /dev/null +++ b/frontend/src/components/BatchAnalysis.tsx @@ -0,0 +1,110 @@ +import { useState } from "react"; +import { api } from "../api"; +import type { KeywordAnalysisResponse } from "../types"; +import { useApiCall } from "../hooks/useApiCall"; +import ScoreBar from "./ScoreBar"; +import StatusMessage from "./StatusMessage"; + +export default function BatchAnalysis() { + const [keywordsText, setKeywordsText] = useState(""); + const [topK, setTopK] = useState(5); + const [threshold, setThreshold] = useState(0.4); + const { data: results, loading, error, run } = useApiCall>(); + + async function handleAnalyze() { + const keywords = keywordsText.split("\n").map((s) => s.trim()).filter(Boolean); + if (keywords.length === 0) return; + await run(() => api.batchAnalyze({ keywords, top_k: topK, cluster_threshold: threshold, compare_across: true })); + } + + return ( +
+
+

Batch Keyword Analysis

+

+ Analyze multiple keywords at once and compare their semantic relationships. +

+
+
+ +