.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..30e2137
--- /dev/null
+++ b/README.md
@@ -0,0 +1,142 @@
+
+
+
+(My) Pricecious
+
+
+ Price tracking using A-Eyes 🤦
+
+
+> [!WARNING]
+> This is 100% vibe-coded.
+
+**Pricecious** is a self-hosted, AI-powered price tracking application. It uses **GenAI Vision Models** (OpenAI, Anthropic, Ollama, etc.) to visually analyze product pages, detect prices, and monitor stock status.
+
+,
+ "currency": "USD",
+ "in_stock": ,
+ "price_confidence": <0.0 to 1.0>,
+ "in_stock_confidence": <0.0 to 1.0>,
+ "source_type": "both"
+}}
+
+{context_section}"""
+
+# Repair prompt template
+REPAIR_PROMPT_TEMPLATE = """Convert the following text into valid JSON matching this schema:
+
+{{
+ "price": ,
+ "currency": "",
+ "in_stock": ,
+ "price_confidence": ,
+ "in_stock_confidence": ,
+ "source_type": ""
+}}
+
+Rules:
+- Extract numeric price value only (no symbols)
+- Boolean values must be true, false, or null (not strings)
+- Confidence values must be numbers between 0.0 and 1.0
+- Respond with ONLY the JSON object, no other text
+
+Text to convert:
+{raw_output}"""
+
+
+def get_extraction_prompt(page_text: str | None = None) -> str:
+ """
+ Generate the extraction prompt with optional text context.
+
+ Args:
+ page_text: Optional webpage text to include as context
+
+ Returns:
+ Formatted prompt string
+ """
+ if page_text:
+ # Apply smart filtering to extract only relevant snippets
+ filtered_text = filter_relevant_text(page_text, max_length=1500)
+ context_section = f"""**Relevant text from page:**
+{filtered_text}"""
+ else:
+ context_section = ""
+
+ return EXTRACTION_PROMPT_TEMPLATE.format(context_section=context_section)
+
+
+def get_repair_prompt(raw_output: str) -> str:
+ """
+ Generate the repair prompt for fixing invalid JSON.
+
+ Args:
+ raw_output: Raw AI output that failed parsing
+
+ Returns:
+ Formatted repair prompt
+ """
+ return REPAIR_PROMPT_TEMPLATE.format(raw_output=raw_output[:1000])
diff --git a/app/alembic/env.py b/app/alembic/env.py
new file mode 100644
index 0000000..85d5e71
--- /dev/null
+++ b/app/alembic/env.py
@@ -0,0 +1,82 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config, pool
+
+from alembic import context
+from app.database import DATABASE_URL
+from app.models import Base
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+ fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+
+
+target_metadata = Base.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+ """Run migrations in 'offline' mode.
+
+ This configures the context with just a URL
+ and not an Engine, though an Engine is acceptable
+ here as well. By skipping the Engine creation
+ we don't even need a DBAPI to be available.
+
+ Calls to context.execute() here emit the given string to the
+ script output.
+
+ """
+ url = DATABASE_URL
+ context.configure(
+ url=url,
+ target_metadata=target_metadata,
+ literal_binds=True,
+ dialect_opts={"paramstyle": "named"},
+ )
+
+ with context.begin_transaction():
+ context.run_migrations()
+
+
+def run_migrations_online() -> None:
+ """Run migrations in 'online' mode.
+
+ In this scenario we need to create an Engine
+ and associate a connection with the context.
+
+ """
+ configuration = config.get_section(config.config_ini_section)
+ configuration["sqlalchemy.url"] = DATABASE_URL
+
+ connectable = engine_from_config(
+ configuration,
+ prefix="sqlalchemy.",
+ poolclass=pool.NullPool,
+ )
+
+ with connectable.connect() as connection:
+ context.configure(connection=connection, target_metadata=target_metadata)
+
+ with context.begin_transaction():
+ context.run_migrations()
+
+
+if context.is_offline_mode():
+ run_migrations_offline()
+else:
+ run_migrations_online()
diff --git a/app/alembic/script.py.mako b/app/alembic/script.py.mako
new file mode 100644
index 0000000..fbc4b07
--- /dev/null
+++ b/app/alembic/script.py.mako
@@ -0,0 +1,26 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+ ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+ ${downgrades if downgrades else "pass"}
diff --git a/app/alembic/versions/6ecb6f39fd8c_add_refresh_fields.py b/app/alembic/versions/6ecb6f39fd8c_add_refresh_fields.py
new file mode 100644
index 0000000..98c8256
--- /dev/null
+++ b/app/alembic/versions/6ecb6f39fd8c_add_refresh_fields.py
@@ -0,0 +1,37 @@
+"""Add refresh fields
+
+Revision ID: 6ecb6f39fd8c
+Revises: initial_migration
+Create Date: 2025-11-19 12:53:09.412700
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+
+from alembic import op
+from app.models import Base
+
+target_metadata = Base.metadata
+
+
+# revision identifiers, used by Alembic.
+revision: str = "6ecb6f39fd8c"
+down_revision: str | None = "initial_migration"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+ # ### commands auto generated by Alembic - please adjust! ###
+ op.add_column("items", sa.Column("is_refreshing", sa.Boolean(), nullable=True))
+ op.add_column("items", sa.Column("last_error", sa.String(), nullable=True))
+ # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+ # ### commands auto generated by Alembic - please adjust! ###
+ op.drop_column("items", "last_error")
+ op.drop_column("items", "is_refreshing")
+ # ### end Alembic commands ###
diff --git a/app/alembic/versions/7f8e9d2a1b3c_add_performance_indexes.py b/app/alembic/versions/7f8e9d2a1b3c_add_performance_indexes.py
new file mode 100644
index 0000000..c85b829
--- /dev/null
+++ b/app/alembic/versions/7f8e9d2a1b3c_add_performance_indexes.py
@@ -0,0 +1,39 @@
+"""add_performance_indexes
+
+Revision ID: 7f8e9d2a1b3c
+Revises: a1b2c3d4e5f6
+Create Date: 2025-11-19 19:14:00.000000
+
+"""
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "7f8e9d2a1b3c"
+down_revision = "a1b2c3d4e5f6"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+ # Add indexes for performance optimization
+ # Items table indexes
+ op.create_index("ix_items_last_checked", "items", ["last_checked"])
+ op.create_index("ix_items_is_active", "items", ["is_active"])
+ # Note: url already has an index from the model definition
+
+ # Composite index for common query pattern (active items due for refresh)
+ op.create_index("ix_items_active_last_checked", "items", ["is_active", "last_checked"])
+
+ # Price history indexes for time-series queries
+ op.create_index("ix_price_history_timestamp", "price_history", ["timestamp"])
+ op.create_index("ix_price_history_item_timestamp", "price_history", ["item_id", "timestamp"])
+
+
+def downgrade():
+ # Remove indexes in reverse order
+ op.drop_index("ix_price_history_item_timestamp", table_name="price_history")
+ op.drop_index("ix_price_history_timestamp", table_name="price_history")
+ op.drop_index("ix_items_active_last_checked", table_name="items")
+ op.drop_index("ix_items_is_active", table_name="items")
+ op.drop_index("ix_items_last_checked", table_name="items")
diff --git a/app/alembic/versions/a1b2c3d4e5f6_add_confidence_metadata.py b/app/alembic/versions/a1b2c3d4e5f6_add_confidence_metadata.py
new file mode 100644
index 0000000..7bd6fa3
--- /dev/null
+++ b/app/alembic/versions/a1b2c3d4e5f6_add_confidence_metadata.py
@@ -0,0 +1,55 @@
+"""Add confidence and AI metadata
+
+Revision ID: a1b2c3d4e5f6
+Revises: 6ecb6f39fd8c
+Create Date: 2025-11-19 13:55:00.000000
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+
+from alembic import op
+from app.models import Base
+
+target_metadata = Base.metadata
+
+
+# revision identifiers, used by Alembic.
+revision: str = "a1b2c3d4e5f6"
+down_revision: str | None = "6ecb6f39fd8c"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+ """Add confidence scores and AI metadata to price_history and items tables."""
+
+ # Add columns to price_history table
+ op.add_column("price_history", sa.Column("price_confidence", sa.Float(), nullable=True))
+ op.add_column("price_history", sa.Column("in_stock_confidence", sa.Float(), nullable=True))
+ op.add_column("price_history", sa.Column("ai_model", sa.String(), nullable=True))
+ op.add_column("price_history", sa.Column("ai_provider", sa.String(), nullable=True))
+ op.add_column("price_history", sa.Column("prompt_version", sa.String(), nullable=True))
+ op.add_column("price_history", sa.Column("repair_used", sa.Boolean(), nullable=True, server_default="false"))
+
+ # Add columns to items table for quick access to latest confidence
+ op.add_column("items", sa.Column("current_price_confidence", sa.Float(), nullable=True))
+ op.add_column("items", sa.Column("in_stock_confidence", sa.Float(), nullable=True))
+
+
+def downgrade() -> None:
+ """Remove confidence scores and AI metadata columns."""
+
+ # Remove columns from items table
+ op.drop_column("items", "in_stock_confidence")
+ op.drop_column("items", "current_price_confidence")
+
+ # Remove columns from price_history table
+ op.drop_column("price_history", "repair_used")
+ op.drop_column("price_history", "prompt_version")
+ op.drop_column("price_history", "ai_provider")
+ op.drop_column("price_history", "ai_model")
+ op.drop_column("price_history", "in_stock_confidence")
+ op.drop_column("price_history", "price_confidence")
diff --git a/app/alembic/versions/initial_migration.py b/app/alembic/versions/initial_migration.py
new file mode 100644
index 0000000..fa7d512
--- /dev/null
+++ b/app/alembic/versions/initial_migration.py
@@ -0,0 +1,116 @@
+"""Initial migration
+
+Revision ID: initial_migration
+Revises:
+Create Date: 2023-11-19 00:00:00.000000
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "initial_migration"
+down_revision: str | None = None
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+ # We are assuming the database is already created by the previous code
+ # But for a fresh install, we need to create tables.
+ # However, since we are retrofitting, we should use --autogenerate usually.
+ # But I cannot run that easily.
+ # So I will define the tables here to be safe.
+
+ # Check if tables exist before creating to avoid errors on existing DBs
+ # Actually, standard alembic practice is to define them.
+ # But since we had `Base.metadata.create_all`, tables might exist.
+ # Ideally we would use `alembic stamp head` on existing deployments.
+
+ # For now, I will leave this empty and assume the user will run
+ # `alembic revision --autogenerate` if they want to capture the state,
+ # or I should try to capture it.
+ # Given I can't run the DB, I'll leave it as a placeholder or try to define it.
+ # Let's define it properly so new installs work.
+
+ # ... actually, writing all create_table calls manually is error prone without running it.
+ # I will rely on the fact that I removed `create_all` from main.py, so this MUST do it.
+
+ op.create_table(
+ "notification_profiles",
+ sa.Column("id", sa.Integer(), nullable=False),
+ sa.Column("name", sa.String(), nullable=True),
+ sa.Column("apprise_url", sa.String(), nullable=True),
+ sa.Column("notify_on_price_drop", sa.Boolean(), nullable=True),
+ sa.Column("notify_on_target_price", sa.Boolean(), nullable=True),
+ sa.Column("price_drop_threshold_percent", sa.Float(), nullable=True),
+ sa.Column("notify_on_stock_change", sa.Boolean(), nullable=True),
+ sa.Column("check_interval_minutes", sa.Integer(), nullable=True),
+ sa.PrimaryKeyConstraint("id"),
+ )
+ op.create_index(op.f("ix_notification_profiles_id"), "notification_profiles", ["id"], unique=False)
+ op.create_index(op.f("ix_notification_profiles_name"), "notification_profiles", ["name"], unique=True)
+
+ op.create_table(
+ "items",
+ sa.Column("id", sa.Integer(), nullable=False),
+ sa.Column("url", sa.String(), nullable=True),
+ sa.Column("name", sa.String(), nullable=True),
+ sa.Column("selector", sa.String(), nullable=True),
+ sa.Column("target_price", sa.Float(), nullable=True),
+ sa.Column("check_interval_minutes", sa.Integer(), nullable=True),
+ sa.Column("current_price", sa.Float(), nullable=True),
+ sa.Column("in_stock", sa.Boolean(), nullable=True),
+ sa.Column("tags", sa.String(), nullable=True),
+ sa.Column("description", sa.String(), nullable=True),
+ sa.Column("is_active", sa.Boolean(), nullable=True),
+ sa.Column("last_checked", sa.DateTime(), nullable=True),
+ sa.Column("notification_profile_id", sa.Integer(), nullable=True),
+ sa.ForeignKeyConstraint(
+ ["notification_profile_id"],
+ ["notification_profiles.id"],
+ ),
+ sa.PrimaryKeyConstraint("id"),
+ )
+ op.create_index(op.f("ix_items_id"), "items", ["id"], unique=False)
+ op.create_index(op.f("ix_items_url"), "items", ["url"], unique=False)
+
+ op.create_table(
+ "price_history",
+ sa.Column("id", sa.Integer(), nullable=False),
+ sa.Column("item_id", sa.Integer(), nullable=True),
+ sa.Column("price", sa.Float(), nullable=True),
+ sa.Column("timestamp", sa.DateTime(), nullable=True),
+ sa.Column("screenshot_path", sa.String(), nullable=True),
+ sa.ForeignKeyConstraint(
+ ["item_id"],
+ ["items.id"],
+ ),
+ sa.PrimaryKeyConstraint("id"),
+ )
+ op.create_index(op.f("ix_price_history_id"), "price_history", ["id"], unique=False)
+
+ op.create_table(
+ "settings",
+ sa.Column("key", sa.String(), nullable=False),
+ sa.Column("value", sa.Text(), nullable=True),
+ sa.PrimaryKeyConstraint("key"),
+ )
+ op.create_index(op.f("ix_settings_key"), "settings", ["key"], unique=False)
+
+
+def downgrade() -> None:
+ op.drop_index(op.f("ix_settings_key"), table_name="settings")
+ op.drop_table("settings")
+ op.drop_index(op.f("ix_price_history_id"), table_name="price_history")
+ op.drop_table("price_history")
+ op.drop_index(op.f("ix_items_url"), table_name="items")
+ op.drop_index(op.f("ix_items_id"), table_name="items")
+ op.drop_table("items")
+ op.drop_index(op.f("ix_notification_profiles_name"), table_name="notification_profiles")
+ op.drop_index(op.f("ix_notification_profiles_id"), table_name="notification_profiles")
+ op.drop_table("notification_profiles")
diff --git a/app/alembic/versions/performance_indexes_v2.py b/app/alembic/versions/performance_indexes_v2.py
new file mode 100644
index 0000000..355df55
--- /dev/null
+++ b/app/alembic/versions/performance_indexes_v2.py
@@ -0,0 +1,46 @@
+"""Add performance indexes
+
+Revision ID: performance_indexes_v2
+Revises: 7f8e9d2a1b3c
+Create Date: 2025-11-19
+
+"""
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "performance_indexes_v2"
+down_revision = "7f8e9d2a1b3c"
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+ # Add indexes only if they don't exist
+ # Using raw SQL with IF NOT EXISTS for safety
+ op.execute(
+ """
+ CREATE INDEX IF NOT EXISTS ix_price_history_timestamp
+ ON price_history (timestamp)
+ """
+ )
+
+ op.execute(
+ """
+ CREATE INDEX IF NOT EXISTS ix_price_history_item_timestamp
+ ON price_history (item_id, timestamp)
+ """
+ )
+
+ op.execute(
+ """
+ CREATE INDEX IF NOT EXISTS ix_items_is_active
+ ON items (is_active)
+ """
+ )
+
+
+def downgrade():
+ op.drop_index("ix_items_is_active", table_name="items", if_exists=True)
+ op.drop_index("ix_price_history_item_timestamp", table_name="price_history", if_exists=True)
+ op.drop_index("ix_price_history_timestamp", table_name="price_history", if_exists=True)
diff --git a/app/database.py b/app/database.py
new file mode 100644
index 0000000..c555970
--- /dev/null
+++ b/app/database.py
@@ -0,0 +1,58 @@
+import logging
+import os
+
+from sqlalchemy import create_engine, event
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.pool import QueuePool
+
+logger = logging.getLogger(__name__)
+
+# Remove hardcoded credentials - require environment variable
+DATABASE_URL = os.getenv("DATABASE_URL")
+
+if not DATABASE_URL:
+ raise ValueError(
+ "DATABASE_URL environment variable is required. Example: postgresql://user:password@localhost:5432/pricewatch"
+ )
+
+# Connection pool configuration
+# pool_size: number of connections to maintain
+# max_overflow: max number of connections above pool_size
+# pool_pre_ping: verify connections before using (prevents stale connections)
+# pool_recycle: recycle connections after N seconds (prevents timeout issues)
+engine = create_engine(
+ DATABASE_URL,
+ poolclass=QueuePool,
+ pool_size=5,
+ max_overflow=10,
+ pool_pre_ping=True,
+ pool_recycle=3600, # 1 hour
+ echo=os.getenv("SQL_ECHO", "false").lower() == "true",
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+
+# Log database connection events for debugging
+@event.listens_for(engine, "connect")
+def receive_connect(dbapi_conn, connection_record):
+ logger.debug("Database connection established")
+
+
+@event.listens_for(engine, "close")
+def receive_close(dbapi_conn, connection_record):
+ logger.debug("Database connection closed")
+
+
+def get_db():
+ db = SessionLocal()
+ try:
+ yield db
+ except Exception:
+ db.rollback()
+ raise
+ finally:
+ db.close()
diff --git a/app/limiter.py b/app/limiter.py
new file mode 100644
index 0000000..38404a8
--- /dev/null
+++ b/app/limiter.py
@@ -0,0 +1,4 @@
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+limiter = Limiter(key_func=get_remote_address)
diff --git a/app/main.py b/app/main.py
new file mode 100644
index 0000000..fa7fe1a
--- /dev/null
+++ b/app/main.py
@@ -0,0 +1,89 @@
+import logging
+import os
+from contextlib import asynccontextmanager
+
+from apscheduler.triggers.interval import IntervalTrigger
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from slowapi import _rate_limit_exceeded_handler
+from slowapi.errors import RateLimitExceeded
+
+from app.limiter import limiter
+from app.routers import items, jobs, notifications, settings
+from app.services.scheduler_service import scheduled_refresh, scheduler
+
+# Configure logging
+logging.basicConfig(
+ level=os.getenv("LOG_LEVEL", "INFO").upper(),
+ format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+ logger.info("Starting smart scheduler (Heartbeat: 1 minute)")
+ scheduler.add_job(scheduled_refresh, IntervalTrigger(minutes=1), id="refresh_job", replace_existing=True)
+ scheduler.start()
+ logger.info("Application started")
+ yield
+ logger.info("Shutting down scheduler...")
+ scheduler.shutdown(wait=True)
+ logger.info("Application shutdown complete")
+
+
+app = FastAPI(title="Pricecious API", version="0.1.0", lifespan=lifespan)
+
+# Rate Limiting & CORS
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler) # type: ignore
+app.add_middleware(
+ CORSMiddleware,
+ allow_origins=os.getenv("CORS_ORIGINS", "*").split(","),
+ allow_credentials=True,
+ allow_methods=["*"],
+ allow_headers=["*"],
+)
+
+
+@app.middleware("http")
+async def log_requests(request: Request, call_next):
+ logger.debug(f"Request: {request.method} {request.url}")
+ response = await call_next(request)
+ logger.debug(f"Response: {response.status_code}")
+ return response
+
+
+# Static Files
+if os.path.exists("static"):
+ app.mount("/assets", StaticFiles(directory="static/assets"), name="assets")
+os.makedirs("screenshots", exist_ok=True)
+app.mount("/screenshots", StaticFiles(directory="screenshots"), name="screenshots")
+
+# Routers
+for router in [notifications.router, items.router, settings.router, jobs.router]:
+ app.include_router(router, prefix="/api")
+
+
+@app.get("/api/")
+def read_root():
+ return {"message": "Welcome to Pricecious API"}
+
+
+# Frontend Serving
+@app.get("/{full_path:path}")
+async def serve_spa(full_path: str):
+ if full_path.startswith(("api", "screenshots", "assets")):
+ return {"message": "Not found"}
+
+ # Serve static files from root (favicon, logo, etc.)
+ static_file_path = f"static/{full_path}"
+ if os.path.isfile(static_file_path):
+ return FileResponse(static_file_path)
+
+ # Default to SPA index.html
+ if os.path.exists("static/index.html"):
+ return FileResponse("static/index.html")
+ return {"message": "Frontend not built or not found"}
diff --git a/app/models.py b/app/models.py
new file mode 100644
index 0000000..335dcf5
--- /dev/null
+++ b/app/models.py
@@ -0,0 +1,79 @@
+from datetime import UTC, datetime
+
+from sqlalchemy import Boolean, Column, DateTime, Float, ForeignKey, Integer, String, Text
+from sqlalchemy.orm import relationship
+
+from .database import Base
+
+
+class NotificationProfile(Base):
+ __tablename__ = "notification_profiles"
+
+ id = Column(Integer, primary_key=True, index=True)
+ name = Column(String, unique=True, index=True)
+ apprise_url = Column(String)
+ notify_on_price_drop = Column(Boolean, default=True)
+ notify_on_target_price = Column(Boolean, default=True)
+ price_drop_threshold_percent = Column(Float, default=10.0)
+ notify_on_stock_change = Column(Boolean, default=True)
+ check_interval_minutes = Column(Integer, default=60)
+
+ items = relationship("Item", back_populates="notification_profile")
+
+
+class Item(Base):
+ __tablename__ = "items"
+
+ id: int = Column(Integer, primary_key=True, index=True) # type: ignore
+ url: str = Column(String, index=True) # type: ignore
+ name: str = Column(String) # type: ignore
+ selector: str | None = Column(String, nullable=True) # type: ignore
+ target_price: float | None = Column(Float, nullable=True) # type: ignore
+ check_interval_minutes: int = Column(Integer, default=60) # type: ignore
+
+ # New fields
+ current_price: float | None = Column(Float, nullable=True) # type: ignore
+ in_stock: bool | None = Column(Boolean, nullable=True) # type: ignore
+ tags: str | None = Column(String, nullable=True) # type: ignore
+ description: str | None = Column(String, nullable=True) # type: ignore
+
+ # Confidence scores for latest extraction
+ current_price_confidence: float | None = Column(Float, nullable=True) # type: ignore
+ in_stock_confidence: float | None = Column(Float, nullable=True) # type: ignore
+
+ is_active: bool = Column(Boolean, default=True) # type: ignore
+ last_checked: datetime | None = Column(DateTime, nullable=True) # type: ignore
+ is_refreshing: bool = Column(Boolean, default=False) # type: ignore
+ last_error: str | None = Column(String, nullable=True) # type: ignore
+
+ notification_profile_id: int | None = Column(Integer, ForeignKey("notification_profiles.id"), nullable=True) # type: ignore
+ notification_profile = relationship("NotificationProfile", back_populates="items")
+
+ price_history = relationship("PriceHistory", back_populates="item", cascade="all, delete-orphan")
+
+
+class PriceHistory(Base):
+ __tablename__ = "price_history"
+
+ id: int = Column(Integer, primary_key=True, index=True) # type: ignore
+ item_id: int = Column(Integer, ForeignKey("items.id")) # type: ignore
+ price: float = Column(Float) # type: ignore
+ timestamp: datetime = Column(DateTime, default=lambda: datetime.now(UTC)) # type: ignore
+ screenshot_path: str | None = Column(String, nullable=True) # type: ignore
+
+ # Confidence scores and AI metadata
+ price_confidence: float | None = Column(Float, nullable=True) # type: ignore
+ in_stock_confidence: float | None = Column(Float, nullable=True) # type: ignore
+ ai_model: str | None = Column(String, nullable=True) # type: ignore
+ ai_provider: str | None = Column(String, nullable=True) # type: ignore
+ prompt_version: str | None = Column(String, nullable=True) # type: ignore
+ repair_used: bool | None = Column(Boolean, nullable=True, default=False) # type: ignore
+
+ item = relationship("Item", back_populates="price_history")
+
+
+class Settings(Base):
+ __tablename__ = "settings"
+
+ key = Column(String, primary_key=True, index=True)
+ value = Column(Text)
diff --git a/app/notification_sender.py b/app/notification_sender.py
new file mode 100644
index 0000000..da6d77b
--- /dev/null
+++ b/app/notification_sender.py
@@ -0,0 +1,36 @@
+import asyncio
+import logging
+
+import apprise
+
+logger = logging.getLogger(__name__)
+
+
+def _send_sync(urls: list, title: str, body: str):
+ """
+ Synchronous notification sending.
+ """
+ if not urls:
+ return
+
+ apobj = apprise.Apprise()
+
+ for url in urls:
+ apobj.add(url)
+
+ try:
+ apobj.notify(
+ body=body,
+ title=title,
+ )
+ logger.info(f"Notification sent: {title}")
+ except Exception as e:
+ logger.error(f"Error sending notification: {e}")
+
+
+async def send_notification(urls: list, title: str, body: str):
+ """
+ Async wrapper for sending notifications.
+ """
+ loop = asyncio.get_running_loop()
+ await loop.run_in_executor(None, _send_sync, urls, title, body)
diff --git a/app/routers/items.py b/app/routers/items.py
new file mode 100644
index 0000000..e048c0b
--- /dev/null
+++ b/app/routers/items.py
@@ -0,0 +1,46 @@
+from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Request
+from sqlalchemy.orm import Session
+
+from app import database, schemas
+from app.limiter import limiter
+from app.services.item_service import ItemService
+from app.services.scheduler_service import process_item_check
+
+router = APIRouter(prefix="/items", tags=["items"])
+
+
+@router.get("", response_model=list[schemas.ItemResponse])
+def get_items(db: Session = Depends(database.get_db)):
+ return ItemService.get_items(db)
+
+
+@router.post("", response_model=schemas.ItemResponse)
+def create_item(item: schemas.ItemCreate, db: Session = Depends(database.get_db)):
+ return ItemService.create_item(db, item)
+
+
+@router.put("/{item_id}", response_model=schemas.ItemResponse)
+def update_item(item_id: int, item_update: schemas.ItemCreate, db: Session = Depends(database.get_db)):
+ return ItemService.update_item(db, item_id, item_update)
+
+
+@router.delete("/{item_id}")
+def delete_item(item_id: int, db: Session = Depends(database.get_db)):
+ return ItemService.delete_item(db, item_id)
+
+
+@router.post("/{item_id}/check")
+@limiter.limit("10/minute")
+def check_item(
+ request: Request, item_id: int, background_tasks: BackgroundTasks, db: Session = Depends(database.get_db)
+):
+ item = ItemService.get_item(db, item_id)
+ if not item:
+ raise HTTPException(status_code=404, detail="Item not found")
+
+ item.is_refreshing = True
+ item.last_error = None
+ db.commit()
+
+ background_tasks.add_task(process_item_check, item_id)
+ return {"message": "Check triggered"}
diff --git a/app/routers/jobs.py b/app/routers/jobs.py
new file mode 100644
index 0000000..d9d7698
--- /dev/null
+++ b/app/routers/jobs.py
@@ -0,0 +1,61 @@
+from apscheduler.triggers.interval import IntervalTrigger
+from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Request
+from sqlalchemy.orm import Session
+
+from app import database, models, schemas
+from app.limiter import limiter
+from app.services.scheduler_service import process_item_check, scheduled_refresh, scheduler
+from app.services.settings_service import SettingsService
+
+router = APIRouter(prefix="/jobs", tags=["jobs"])
+
+
+@router.get("/config")
+def get_job_config(db: Session = Depends(database.get_db)):
+ interval = int(SettingsService.get_setting_value(db, "refresh_interval_minutes", "60"))
+
+ next_run = None
+ job = scheduler.get_job("refresh_job")
+ if job:
+ next_run = job.next_run_time
+
+ return {"refresh_interval_minutes": interval, "next_run": next_run, "running": scheduler.running}
+
+
+@router.post("/config")
+def update_job_config(config: schemas.SettingsUpdate, db: Session = Depends(database.get_db)):
+ if config.key != "refresh_interval_minutes":
+ raise HTTPException(status_code=400, detail="Invalid setting key for job config")
+
+ try:
+ interval = int(config.value)
+ if interval < 1:
+ raise ValueError("Interval must be at least 1 minute")
+ except ValueError as e:
+ raise HTTPException(status_code=400, detail="Invalid interval value") from e
+
+ SettingsService.update_setting(db, config)
+
+ try:
+ scheduler.reschedule_job("refresh_job", trigger=IntervalTrigger(minutes=interval))
+ except Exception:
+ scheduler.add_job(scheduled_refresh, IntervalTrigger(minutes=interval), id="refresh_job", replace_existing=True)
+
+ return {"message": "Job configuration updated", "refresh_interval_minutes": interval}
+
+
+@router.post("/refresh-all")
+@limiter.limit("5/minute")
+def refresh_all_items(request: Request, background_tasks: BackgroundTasks, db: Session = Depends(database.get_db)):
+ items = db.query(models.Item).filter(models.Item.is_active).all()
+
+ # Mark all items as refreshing immediately so UI updates persist
+ for item in items:
+ item.is_refreshing = True
+ db.commit()
+
+ for item in items:
+ if item.id is not None:
+ background_tasks.add_task(process_item_check, int(item.id))
+
+ return {"message": f"Triggered refresh for {len(items)} items"}
diff --git a/app/routers/notifications.py b/app/routers/notifications.py
new file mode 100644
index 0000000..c497a59
--- /dev/null
+++ b/app/routers/notifications.py
@@ -0,0 +1,29 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+from app import database, schemas
+from app.services.notification_service import NotificationService
+
+router = APIRouter(prefix="/notification-profiles", tags=["notifications"])
+
+
+@router.get("", response_model=list[schemas.NotificationProfileResponse])
+def get_notification_profiles(db: Session = Depends(database.get_db)):
+ return NotificationService.get_notification_profiles(db)
+
+
+@router.post("", response_model=schemas.NotificationProfileResponse)
+def create_notification_profile(profile: schemas.NotificationProfileCreate, db: Session = Depends(database.get_db)):
+ return NotificationService.create_notification_profile(db, profile)
+
+
+@router.delete("/{profile_id}")
+def delete_notification_profile(profile_id: int, db: Session = Depends(database.get_db)):
+ return NotificationService.delete_notification_profile(db, profile_id)
+
+
+@router.put("/{profile_id}", response_model=schemas.NotificationProfileResponse)
+def update_notification_profile(
+ profile_id: int, profile: schemas.NotificationProfileUpdate, db: Session = Depends(database.get_db)
+):
+ return NotificationService.update_notification_profile(db, profile_id, profile)
diff --git a/app/routers/settings.py b/app/routers/settings.py
new file mode 100644
index 0000000..d3f0419
--- /dev/null
+++ b/app/routers/settings.py
@@ -0,0 +1,17 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+from app import database, schemas
+from app.services.settings_service import SettingsService
+
+router = APIRouter(prefix="/settings", tags=["settings"])
+
+
+@router.get("")
+def get_settings(db: Session = Depends(database.get_db)):
+ return SettingsService.get_settings(db)
+
+
+@router.post("", response_model=schemas.SettingsUpdate)
+def update_setting(setting: schemas.SettingsUpdate, db: Session = Depends(database.get_db)):
+ return SettingsService.update_setting(db, setting)
diff --git a/app/schemas.py b/app/schemas.py
new file mode 100644
index 0000000..0a7fc29
--- /dev/null
+++ b/app/schemas.py
@@ -0,0 +1,52 @@
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict
+
+
+class NotificationProfileCreate(BaseModel):
+ name: str
+ apprise_url: str
+ notify_on_price_drop: bool = True
+ notify_on_target_price: bool = True
+ price_drop_threshold_percent: float = 10.0
+ notify_on_stock_change: bool = True
+ check_interval_minutes: int = 60
+
+
+class NotificationProfileUpdate(NotificationProfileCreate):
+ pass
+
+
+class NotificationProfileResponse(NotificationProfileCreate):
+ id: int
+ model_config = ConfigDict(from_attributes=True)
+
+
+class ItemCreate(BaseModel):
+ url: str
+ name: str
+ selector: str | None = None
+ target_price: float | None = None
+ check_interval_minutes: int = 60
+ tags: str | None = None
+ description: str | None = None
+ notification_profile_id: int | None = None
+
+
+class ItemResponse(ItemCreate):
+ id: int
+ current_price: float | None
+ in_stock: bool | None
+ current_price_confidence: float | None = None
+ in_stock_confidence: float | None = None
+ is_active: bool
+ last_checked: datetime | None
+ is_refreshing: bool = False
+ last_error: str | None = None
+ screenshot_url: str | None = None
+ model_config = ConfigDict(from_attributes=True)
+
+
+class SettingsUpdate(BaseModel):
+ key: str
+ value: str
diff --git a/app/services/ai_service.py b/app/services/ai_service.py
new file mode 100644
index 0000000..8d00327
--- /dev/null
+++ b/app/services/ai_service.py
@@ -0,0 +1,352 @@
+import asyncio
+import json
+import logging
+import re
+import time
+from typing import Any, TypedDict
+
+from litellm import acompletion
+from pydantic import ValidationError
+from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_exponential
+
+from app import models
+from app.ai_schema import (
+ PROMPT_VERSION,
+ AIExtractionMetadata,
+ AIExtractionResponse,
+ get_extraction_prompt,
+ get_repair_prompt,
+)
+from app.database import SessionLocal
+from app.utils.image import encode_image
+from app.utils.text import clean_text
+
+# Default configuration (can be overridden by DB settings)
+DEFAULT_PROVIDER = "ollama"
+DEFAULT_MODEL = "gemma3:4b"
+DEFAULT_API_BASE = "http://ollama:11434"
+DEFAULT_TEMPERATURE = 0.1
+DEFAULT_MAX_TOKENS = 300
+DEFAULT_TIMEOUT = 30 # seconds
+MAX_TEXT_LENGTH = 5000 # Will be filtered to ~1500-2000 relevant chars
+
+# Config caching
+_config_cache: dict[str, Any] = {"data": None, "timestamp": 0.0}
+CONFIG_CACHE_TTL = 60 # seconds
+
+logger = logging.getLogger(__name__)
+
+
+class AIConfig(TypedDict):
+ provider: str
+ model: str
+ api_key: str
+ api_base: str
+ temperature: float
+ max_tokens: int
+ timeout: int
+ enable_json_repair: bool
+ enable_multi_sample: bool
+ multi_sample_threshold: float
+
+
+MIN_API_KEY_LENGTH = 12
+
+
+def _sanitize_api_key(key: str) -> str:
+ """Redact API key for logging (show first/last 4 chars only)."""
+ if not key or len(key) < MIN_API_KEY_LENGTH:
+ return "***"
+ return f"{key[:4]}...{key[-4:]}"
+
+
+class AIService:
+ @staticmethod
+ def get_ai_config() -> AIConfig:
+ """
+ Fetches AI configuration from the database with caching.
+ Returns a dict with: provider, model, api_key, api_base, temperature, max_tokens, timeout
+ """
+ # Check cache
+ now = time.time()
+ if _config_cache["data"] and (now - _config_cache["timestamp"]) < CONFIG_CACHE_TTL:
+ return _config_cache["data"] # type: ignore
+
+ # Fetch from DB
+ session = SessionLocal()
+ try:
+ settings = session.query(models.Settings).all()
+ settings_map = {s.key: s.value for s in settings}
+
+ config: AIConfig = {
+ "provider": settings_map.get("ai_provider", DEFAULT_PROVIDER),
+ "model": settings_map.get("ai_model", DEFAULT_MODEL),
+ "api_key": settings_map.get("ai_api_key", ""),
+ "api_base": settings_map.get("ai_api_base", DEFAULT_API_BASE),
+ "temperature": float(settings_map.get("ai_temperature", str(DEFAULT_TEMPERATURE))),
+ "max_tokens": int(settings_map.get("ai_max_tokens", str(DEFAULT_MAX_TOKENS))),
+ "timeout": int(settings_map.get("ai_timeout", str(DEFAULT_TIMEOUT))),
+ "enable_json_repair": settings_map.get("enable_json_repair", "true").lower() == "true",
+ "enable_multi_sample": settings_map.get("enable_multi_sample", "false").lower() == "true",
+ "multi_sample_threshold": float(settings_map.get("multi_sample_confidence_threshold", "0.6")),
+ }
+
+ # Update cache
+ _config_cache["data"] = config # type: ignore
+ _config_cache["timestamp"] = now
+
+ return config
+ except Exception as e:
+ logger.error(f"Error fetching AI config: {e}")
+ return {
+ "provider": DEFAULT_PROVIDER,
+ "model": DEFAULT_MODEL,
+ "api_key": "",
+ "api_base": DEFAULT_API_BASE,
+ "temperature": DEFAULT_TEMPERATURE,
+ "max_tokens": DEFAULT_MAX_TOKENS,
+ "timeout": DEFAULT_TIMEOUT,
+ "enable_json_repair": True,
+ "enable_multi_sample": False,
+ "multi_sample_threshold": 0.6,
+ }
+ finally:
+ session.close()
+
+ @staticmethod
+ def parse_and_validate_response(response_text: str) -> AIExtractionResponse:
+ """
+ Parse and validate AI response against schema.
+
+ Pipeline:
+ 1. Extract JSON from response (handle markdown code blocks)
+ 2. Parse JSON
+ 3. Validate against Pydantic schema (includes normalization and clamping)
+
+ Raises:
+ ValidationError: If response doesn't match schema
+ json.JSONDecodeError: If JSON is invalid
+ """
+ # Try to extract JSON from markdown code blocks
+ json_match = re.search(r"```(?:json)?\s*(\{.*?\})\s*```", response_text, re.DOTALL)
+ if json_match:
+ json_str = json_match.group(1)
+ else:
+ # Try to find raw JSON object
+ json_match = re.search(r"\{.*\}", response_text, re.DOTALL)
+ if json_match:
+ json_str = json_match.group(0)
+ else:
+ json_str = response_text
+
+ # Parse JSON
+ data = json.loads(json_str)
+
+ # Validate and normalize through Pydantic
+ return AIExtractionResponse(**data)
+
+ @classmethod
+ async def repair_json_response(
+ cls,
+ raw_output: str,
+ config: AIConfig,
+ ) -> AIExtractionResponse:
+ """
+ Attempt to repair invalid JSON using a second LLM call.
+
+ Args:
+ raw_output: The raw AI output that failed parsing
+ config: AI configuration dict
+
+ Returns:
+ Validated AIExtractionResponse
+
+ Raises:
+ Exception: If repair also fails
+ """
+ logger.warning("Attempting JSON repair with second LLM call")
+
+ repair_prompt = get_repair_prompt(raw_output)
+
+ # Use a simpler, cheaper model for repair if possible
+ # For now, use the same model
+ kwargs = {
+ "model": config["model"] if config["provider"] != "ollama" else f"ollama/{config['model']}",
+ "messages": [{"role": "user", "content": repair_prompt}],
+ "max_tokens": 300,
+ "temperature": 0.0, # Very deterministic for repair
+ "timeout": config["timeout"],
+ }
+
+ if config["api_key"]:
+ kwargs["api_key"] = config["api_key"]
+
+ if config["provider"] == "ollama":
+ kwargs["api_base"] = config["api_base"]
+ kwargs["format"] = "json"
+ elif config["provider"] == "openai" and config["api_base"]:
+ kwargs["api_base"] = config["api_base"]
+
+ response = await acompletion(**kwargs)
+ repaired_text = response.choices[0].message.content
+
+ # Validate repaired response
+ return cls.parse_and_validate_response(repaired_text)
+
+ @staticmethod
+ @retry(
+ retry=retry_if_exception_type((TimeoutError, ConnectionError)),
+ stop=stop_after_attempt(3),
+ wait=wait_exponential(multiplier=1, min=2, max=10),
+ reraise=True,
+ )
+ async def call_llm(
+ prompt: str,
+ image_data_url: str,
+ config: AIConfig,
+ ) -> str:
+ """
+ Call LLM with structured output settings and retry logic.
+
+ Returns:
+ Raw response text from the model
+
+ Raises:
+ TimeoutError: If request times out after retries
+ ConnectionError: If connection fails after retries
+ """
+ messages = [
+ {
+ "role": "user",
+ "content": [
+ {"type": "text", "text": prompt},
+ {"type": "image_url", "image_url": {"url": image_data_url}},
+ ],
+ }
+ ]
+
+ # Prepare kwargs for litellm
+ kwargs: dict[str, Any] = {
+ "model": config["model"] if config["provider"] != "ollama" else f"ollama/{config['model']}",
+ "messages": messages,
+ "max_tokens": config["max_tokens"],
+ "temperature": config["temperature"],
+ "timeout": config["timeout"],
+ }
+
+ if config["api_key"]:
+ kwargs["api_key"] = config["api_key"]
+
+ # Provider-specific structured output features
+ if config["provider"] == "ollama":
+ kwargs["api_base"] = config["api_base"]
+ kwargs["format"] = "json" # Force JSON mode for Ollama
+ elif config["provider"] == "openai":
+ # Use OpenAI's JSON mode
+ kwargs["response_format"] = {"type": "json_object"}
+ if config["api_base"]:
+ kwargs["api_base"] = config["api_base"]
+ elif config["provider"] == "anthropic":
+ # Anthropic doesn't have native JSON mode yet, rely on prompt
+ if config["api_base"]:
+ kwargs["api_base"] = config["api_base"]
+ # Other providers - rely on prompt engineering
+ elif config["api_base"]:
+ kwargs["api_base"] = config["api_base"]
+
+ # Call litellm asynchronously
+ sanitized_key = _sanitize_api_key(config["api_key"]) if config["api_key"] else "(none)"
+ logger.info(
+ f"Calling {config['provider']}/{config['model']} "
+ f"(temp={config['temperature']}, max_tokens={config['max_tokens']}, "
+ f"timeout={config['timeout']}s, key={sanitized_key})"
+ )
+ response = await acompletion(**kwargs)
+
+ content = response.choices[0].message.content
+ return content or ""
+
+ @classmethod
+ async def analyze_image(
+ cls,
+ image_path: str,
+ page_text: str = "",
+ ) -> tuple[AIExtractionResponse, AIExtractionMetadata] | None:
+ """
+ Analyze image and extract price/stock information.
+
+ Args:
+ image_path: Path to screenshot
+ page_text: Optional webpage text context
+
+ Returns:
+ Tuple of (AIExtractionResponse, AIExtractionMetadata) or None on failure
+ """
+ try:
+ # Get AI config
+ loop = asyncio.get_running_loop()
+ config = await loop.run_in_executor(None, cls.get_ai_config)
+
+ logger.info(
+ f"Analyzing image with Provider: {config['provider']}, "
+ f"Model: {config['model']}, Timeout: {config['timeout']}s"
+ )
+
+ # Encode image
+ base64_image = await encode_image(image_path)
+ data_url = f"data:image/jpeg;base64,{base64_image}"
+
+ # Prepare prompt with optional text context
+ cleaned_text = ""
+ if page_text:
+ cleaned_text = clean_text(page_text)
+ if len(cleaned_text) > MAX_TEXT_LENGTH:
+ cleaned_text = cleaned_text[:MAX_TEXT_LENGTH] + "...(truncated)"
+ logger.info(f"Added text context (original: {len(page_text)}, cleaned: {len(cleaned_text)})")
+
+ prompt = get_extraction_prompt(cleaned_text if cleaned_text else None)
+
+ # Call LLM
+ response_text = await cls.call_llm(prompt, data_url, config)
+
+ logger.info(f"AI Response: {response_text[:200]}...")
+
+ # Parse and validate response
+ repair_used = False
+ try:
+ extraction_result = cls.parse_and_validate_response(response_text)
+ except (ValidationError, json.JSONDecodeError) as e:
+ logger.warning(f"Primary parsing failed: {e}")
+
+ if config["enable_json_repair"]:
+ try:
+ extraction_result = await cls.repair_json_response(response_text, config)
+ repair_used = True
+ logger.info("JSON repair successful")
+ except Exception as repair_error:
+ logger.error(f"JSON repair also failed: {repair_error}")
+ raise
+ else:
+ raise
+
+ # Create metadata
+ metadata = AIExtractionMetadata(
+ model_name=config["model"],
+ provider=config["provider"],
+ prompt_version=PROMPT_VERSION,
+ repair_used=repair_used,
+ multi_sample=False,
+ sample_count=1,
+ )
+
+ logger.info(
+ f"Extraction successful: price={extraction_result.price} "
+ f"(conf={extraction_result.price_confidence:.2f}), "
+ f"stock={extraction_result.in_stock} (conf={extraction_result.in_stock_confidence:.2f})"
+ )
+
+ return extraction_result, metadata
+
+ except Exception as e:
+ logger.error(f"Error in analyze_image: {e}", exc_info=True)
+ return None
diff --git a/app/services/item_service.py b/app/services/item_service.py
new file mode 100644
index 0000000..fb948ce
--- /dev/null
+++ b/app/services/item_service.py
@@ -0,0 +1,135 @@
+import logging
+import os
+from datetime import UTC, datetime
+
+from fastapi import HTTPException
+from sqlalchemy.orm import Session
+
+from app import models, schemas
+from app.services.settings_service import SettingsService
+from app.url_validation import URLValidationError, validate_url
+
+logger = logging.getLogger(__name__)
+
+
+class ItemService:
+ @staticmethod
+ def get_items(db: Session):
+ items = db.query(models.Item).all()
+ return [
+ {
+ **item.__dict__,
+ "screenshot_url": f"/screenshots/item_{item.id}.png"
+ if os.path.exists(f"screenshots/item_{item.id}.png")
+ else None,
+ }
+ for item in items
+ ]
+
+ @staticmethod
+ def create_item(db: Session, item: schemas.ItemCreate):
+ logger.info(f"Creating item: {item.name} - {item.url}")
+ try:
+ validate_url(item.url)
+ except URLValidationError as e:
+ raise HTTPException(status_code=400, detail=f"Invalid URL: {e}") from e
+
+ db_item = models.Item(**item.model_dump())
+ db.add(db_item)
+ db.commit()
+ db.refresh(db_item)
+ return db_item
+
+ @staticmethod
+ def update_item(db: Session, item_id: int, item_update: schemas.ItemCreate):
+ db_item = db.query(models.Item).filter(models.Item.id == item_id).first()
+ if not db_item:
+ raise HTTPException(status_code=404, detail="Item not found")
+
+ for key, value in item_update.model_dump().items():
+ setattr(db_item, key, value)
+
+ db.commit()
+ db.refresh(db_item)
+ return db_item
+
+ @staticmethod
+ def delete_item(db: Session, item_id: int):
+ item = db.query(models.Item).filter(models.Item.id == item_id).first()
+ if not item:
+ raise HTTPException(status_code=404, detail="Item not found")
+
+ if os.path.exists(f"screenshots/item_{item_id}.png"):
+ try:
+ os.remove(f"screenshots/item_{item_id}.png")
+ except OSError:
+ pass
+
+ db.delete(item)
+ db.commit()
+ return {"ok": True}
+
+ @staticmethod
+ def get_item(db: Session, item_id: int):
+ return db.query(models.Item).filter(models.Item.id == item_id).first()
+
+ @staticmethod
+ def get_item_data_for_checking(db: Session, item_id: int):
+ item = db.query(models.Item).filter(models.Item.id == item_id).first()
+ if not item:
+ return None, None
+
+ settings = {s.key: s.value for s in db.query(models.Settings).all()}
+ profile = item.notification_profile
+
+ item_data = {
+ "id": item.id,
+ "url": item.url,
+ "selector": item.selector,
+ "name": item.name,
+ "current_price": item.current_price,
+ "in_stock": item.in_stock,
+ "target_price": item.target_price,
+ "notification_profile": profile.__dict__ if profile else None,
+ }
+
+ config = {
+ "smart_scroll": settings.get("smart_scroll_enabled", "false").lower() == "true",
+ "smart_scroll_pixels": int(settings.get("smart_scroll_pixels", "350")),
+ "text_context_enabled": settings.get("text_context_enabled", "false").lower() == "true",
+ "text_length": int(settings.get("text_context_length", "5000"))
+ if settings.get("text_context_enabled", "false").lower() == "true"
+ else 0,
+ "scraper_timeout": int(settings.get("scraper_timeout", "90000")),
+ }
+ return item_data, config
+
+ @staticmethod
+ def get_due_items(db: Session):
+ items = db.query(models.Item).filter(models.Item.is_active).all()
+ global_interval = int(SettingsService.get_setting_value(db, "refresh_interval_minutes", "60"))
+ due_items = []
+ now = datetime.now(UTC)
+
+ for item in items:
+ if item.is_refreshing:
+ continue
+
+ interval = (
+ item.notification_profile.check_interval_minutes
+ if item.notification_profile and item.notification_profile.check_interval_minutes
+ else global_interval
+ )
+
+ if not item.last_checked:
+ due_items.append((item.id, interval, -1))
+ continue
+
+ last_checked = (
+ item.last_checked.replace(tzinfo=UTC) if item.last_checked.tzinfo is None else item.last_checked
+ )
+ time_since = (now - last_checked).total_seconds() / 60
+ if time_since >= interval:
+ due_items.append((item.id, interval, int(time_since)))
+
+ return due_items
diff --git a/app/services/notification_service.py b/app/services/notification_service.py
new file mode 100644
index 0000000..79f6988
--- /dev/null
+++ b/app/services/notification_service.py
@@ -0,0 +1,89 @@
+from fastapi import HTTPException
+from sqlalchemy.orm import Session
+
+from app import models, notification_sender, schemas
+
+
+class NotificationService:
+ @staticmethod
+ def get_notification_profiles(db: Session):
+ return db.query(models.NotificationProfile).all()
+
+ @staticmethod
+ def create_notification_profile(db: Session, profile: schemas.NotificationProfileCreate):
+ db_profile = models.NotificationProfile(**profile.model_dump())
+ db.add(db_profile)
+ db.commit()
+ db.refresh(db_profile)
+ return db_profile
+
+ @staticmethod
+ def delete_notification_profile(db: Session, profile_id: int):
+ profile = db.query(models.NotificationProfile).filter(models.NotificationProfile.id == profile_id).first()
+ if not profile:
+ raise HTTPException(status_code=404, detail="Profile not found")
+ db.delete(profile)
+ db.commit()
+ db.delete(profile)
+ db.commit()
+ return {"ok": True}
+
+ @staticmethod
+ def update_notification_profile(db: Session, profile_id: int, profile_data: schemas.NotificationProfileUpdate):
+ profile = db.query(models.NotificationProfile).filter(models.NotificationProfile.id == profile_id).first()
+ if not profile:
+ raise HTTPException(status_code=404, detail="Profile not found")
+
+ for key, value in profile_data.model_dump().items():
+ setattr(profile, key, value)
+
+ db.commit()
+ db.refresh(profile)
+ return profile
+
+ @staticmethod
+ async def send_item_notifications(
+ item_data: dict,
+ price: float | None,
+ old_price: float | None,
+ in_stock: bool | None,
+ old_stock: bool | None,
+ ):
+ profile = item_data["notification_profile"]
+ if not profile:
+ return
+
+ if profile["notify_on_price_drop"] and price is not None and old_price is not None:
+ if price < old_price:
+ drop_percent = ((old_price - price) / old_price) * 100
+ if drop_percent >= profile["price_drop_threshold_percent"]:
+ await notification_sender.send_notification(
+ [profile["apprise_url"]],
+ f"Price Drop Alert: {item_data['name']}",
+ f"Price dropped by {drop_percent:.1f}%! Now ${price} (was ${old_price})",
+ )
+
+ if (
+ profile["notify_on_target_price"]
+ and price is not None
+ and item_data["target_price"]
+ and price <= item_data["target_price"]
+ ):
+ await notification_sender.send_notification(
+ [profile["apprise_url"]],
+ f"Target Price Alert: {item_data['name']}",
+ f"Price is ${price} (Target: ${item_data['target_price']})",
+ )
+
+ if (
+ profile["notify_on_stock_change"]
+ and in_stock is not None
+ and old_stock is not None
+ and in_stock != old_stock
+ ):
+ status = "In Stock" if in_stock else "Out of Stock"
+ await notification_sender.send_notification(
+ [profile["apprise_url"]],
+ f"Stock Alert: {item_data['name']}",
+ f"Item is now {status}",
+ )
diff --git a/app/services/scheduler_service.py b/app/services/scheduler_service.py
new file mode 100644
index 0000000..ff9d537
--- /dev/null
+++ b/app/services/scheduler_service.py
@@ -0,0 +1,147 @@
+import asyncio
+import logging
+from datetime import UTC, datetime
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+
+from app import database, models
+from app.ai_schema import AIExtractionMetadata, AIExtractionResponse
+from app.services.ai_service import AIService
+from app.services.item_service import ItemService
+from app.services.notification_service import NotificationService
+from app.services.scraper_service import ScraperService
+
+logger = logging.getLogger(__name__)
+scheduler = AsyncIOScheduler()
+
+PRICE_CHANGE_THRESHOLD_PERCENT = 20.0
+LOW_CONFIDENCE_THRESHOLD = 0.7
+
+
+def _get_thresholds():
+ with database.SessionLocal() as session:
+ settings = {s.key: s.value for s in session.query(models.Settings).all()}
+ return {
+ "price": float(settings.get("confidence_threshold_price", "0.5")),
+ "stock": float(settings.get("confidence_threshold_stock", "0.5")),
+ }
+
+
+def _update_db_result(
+ item_id: int,
+ extraction: AIExtractionResponse,
+ metadata: AIExtractionMetadata,
+ thresholds: dict,
+ screenshot_path: str,
+):
+ with database.SessionLocal() as session:
+ item = session.query(models.Item).filter(models.Item.id == item_id).first()
+ if not item:
+ return None, None
+
+ old_price, old_stock = item.current_price, item.in_stock
+ price, in_stock = extraction.price, extraction.in_stock
+ p_conf, s_conf = extraction.price_confidence, extraction.in_stock_confidence
+
+ if price is not None:
+ if p_conf >= thresholds["price"]:
+ if (
+ old_price
+ and (abs(price - old_price) / old_price * 100 > PRICE_CHANGE_THRESHOLD_PERCENT)
+ and p_conf < LOW_CONFIDENCE_THRESHOLD
+ ):
+ item.last_error = f"Uncertain: Large price change with low confidence ({p_conf:.2f})"
+ else:
+ item.last_error = None
+ item.current_price = price
+ item.current_price_confidence = p_conf
+
+ session.add(
+ models.PriceHistory(
+ item_id=item.id,
+ price=price,
+ screenshot_path=screenshot_path,
+ price_confidence=p_conf,
+ in_stock_confidence=s_conf,
+ ai_model=metadata.model_name,
+ ai_provider=metadata.provider,
+ prompt_version=metadata.prompt_version,
+ repair_used=metadata.repair_used,
+ )
+ )
+
+ if in_stock is not None and s_conf >= thresholds["stock"]:
+ item.in_stock = in_stock
+ item.in_stock_confidence = s_conf
+
+ item.last_checked = datetime.now(UTC)
+ item.is_refreshing = False
+ if item.last_error and not item.last_error.startswith("Uncertain:"):
+ item.last_error = None
+
+ session.commit()
+ return old_price, old_stock
+
+
+def _update_db_error(item_id, error_msg):
+ with database.SessionLocal() as session:
+ if item := session.query(models.Item).filter(models.Item.id == item_id).first():
+ item.is_refreshing = False
+ item.last_error = error_msg
+ item.last_checked = datetime.now(UTC)
+ session.commit()
+
+
+async def process_item_check(item_id: int):
+ loop = asyncio.get_running_loop()
+ with database.SessionLocal() as session:
+ item_data, config = await loop.run_in_executor(None, ItemService.get_item_data_for_checking, session, item_id)
+
+ if not item_data:
+ logger.error(f"process_item_check: Item ID {item_id} not found")
+ return
+
+ try:
+ logger.info(f"Checking item: {item_data['name']} ({item_data['url']})")
+ screenshot_path, page_text = await ScraperService.scrape_item(
+ item_data["url"],
+ item_data["selector"],
+ item_id,
+ smart_scroll=config["smart_scroll"],
+ scroll_pixels=config["smart_scroll_pixels"],
+ text_length=config["text_length"],
+ timeout=config["scraper_timeout"],
+ )
+
+ if not screenshot_path:
+ raise Exception("Failed to capture screenshot")
+
+ if not (ai_result := await AIService.analyze_image(screenshot_path, page_text=page_text)):
+ raise Exception("AI analysis failed")
+
+ extraction, metadata = ai_result
+ thresholds = await loop.run_in_executor(None, _get_thresholds)
+ old_price, old_stock = await loop.run_in_executor(
+ None, _update_db_result, item_id, extraction, metadata, thresholds, screenshot_path
+ )
+
+ await NotificationService.send_item_notifications(
+ item_data, extraction.price, old_price, extraction.in_stock, old_stock
+ )
+
+ except Exception as e:
+ logger.error(f"Error in process_item_check: {e}")
+ await loop.run_in_executor(None, _update_db_error, item_id, str(e))
+
+
+async def scheduled_refresh():
+ logger.info("Heartbeat: Checking for items due for refresh")
+ loop = asyncio.get_running_loop()
+ try:
+ with database.SessionLocal() as session:
+ due_items = await loop.run_in_executor(None, ItemService.get_due_items, session)
+
+ for item_id, _, _ in due_items:
+ await process_item_check(item_id)
+ except Exception as e:
+ logger.error(f"Error in scheduled refresh: {e}", exc_info=True)
diff --git a/app/services/scraper_service.py b/app/services/scraper_service.py
new file mode 100644
index 0000000..31ef0b7
--- /dev/null
+++ b/app/services/scraper_service.py
@@ -0,0 +1,185 @@
+import asyncio
+import logging
+import os
+
+from playwright.async_api import TimeoutError as PlaywrightTimeoutError
+from playwright.async_api import async_playwright
+
+logger = logging.getLogger(__name__)
+
+BROWSERLESS_URL = os.getenv("BROWSERLESS_URL", "ws://browserless:3000")
+
+
+class ScraperService:
+ @staticmethod
+ async def scrape_item( # noqa: PLR0913, PLR0912, PLR0915
+ url: str,
+ selector: str | None = None,
+ item_id: int | None = None,
+ smart_scroll: bool = False,
+ scroll_pixels: int = 350,
+ text_length: int = 0,
+ timeout: int = 90000,
+ ) -> tuple[str | None, str]:
+ """
+ Scrapes the given URL using Browserless and Playwright.
+ Returns a tuple: (screenshot_path, page_text)
+
+ Args:
+ url: Target URL to scrape
+ selector: Optional CSS selector to focus on
+ item_id: Optional item ID for screenshot naming
+ smart_scroll: Enable scrolling to load lazy content
+ scroll_pixels: Number of pixels to scroll (must be positive)
+ text_length: Number of characters to extract (0 = disabled)
+ timeout: Page load timeout in milliseconds
+ """
+ # Input validation
+ if scroll_pixels <= 0:
+ logger.warning(f"Invalid scroll_pixels value: {scroll_pixels}, using default 350")
+ scroll_pixels = 350
+
+ if timeout <= 0:
+ logger.warning(f"Invalid timeout value: {timeout}, using default 90000")
+ timeout = 90000
+ async with async_playwright() as p:
+ browser = None
+ try:
+ logger.info(f"Connecting to Browserless at {BROWSERLESS_URL}")
+ browser = await p.chromium.connect_over_cdp(BROWSERLESS_URL)
+ context = await browser.new_context(
+ viewport={"width": 1920, "height": 1080},
+ user_agent=(
+ "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+ "AppleWebKit/537.36 (KHTML, like Gecko) "
+ "Chrome/120.0.0.0 Safari/537.36"
+ ),
+ )
+
+ # Stealth mode / Ad blocking attempts
+ await context.route("**/*", lambda route: route.continue_())
+
+ page = await context.new_page()
+
+ logger.info(f"Navigating to {url} (Timeout: {timeout}ms)")
+ try:
+ # First wait for domcontentloaded - this is the minimum we need
+ await page.goto(url, wait_until="domcontentloaded", timeout=timeout)
+ logger.info(f"Page loaded (domcontentloaded): {url}")
+
+ # Then try to wait for networkidle, but don't fail if it times out
+ # This helps with heavy pages that never fully settle
+ try:
+ await page.wait_for_load_state("networkidle", timeout=5000)
+ logger.info("Network idle reached")
+ except PlaywrightTimeoutError:
+ logger.info("Network idle timed out (non-critical), proceeding...")
+
+ except Exception as e:
+ logger.error(f"Error navigating to {url}: {e}")
+ # Try to take screenshot anyway if page partially loaded
+ pass
+
+ # Wait a bit for dynamic content if needed
+ await page.wait_for_timeout(2000)
+
+ # Try to close common popups
+ logger.info("Attempting to close popups...")
+ popup_selectors = [
+ "button[aria-label='Close']",
+ "button[aria-label='close']",
+ ".close-button",
+ ".modal-close",
+ "svg[data-name='Close']",
+ "[class*='popup'] button",
+ "[class*='modal'] button",
+ "button:has-text('No, thanks')",
+ "button:has-text('No thanks')",
+ "a:has-text('No, thanks')",
+ "div[role='dialog'] button[aria-label='Close']",
+ ]
+
+ for popup_selector in popup_selectors:
+ try:
+ if await page.locator(popup_selector).count() > 0:
+ logger.info(f"Found popup close button: {popup_selector}")
+ # Try to click it. If it fails, catch and continue
+ await page.locator(popup_selector).first.click(timeout=2000)
+ await page.wait_for_timeout(1000) # Wait for animation
+ except Exception as e:
+ logger.debug(f"Could not close popup with selector {popup_selector}: {e}")
+
+ # Also try pressing Escape
+ try:
+ await page.keyboard.press("Escape")
+ except Exception as e:
+ logger.debug(f"Could not press Escape key: {e}")
+
+ if selector:
+ try:
+ logger.info(f"Waiting for selector: {selector}")
+ await page.wait_for_selector(selector, timeout=5000)
+ # Scroll to element
+ element = page.locator(selector).first
+ await element.scroll_into_view_if_needed()
+ logger.info(f"Scrolled to selector: {selector}")
+ except Exception as e:
+ logger.warning(f"Selector {selector} not found or timed out: {e}")
+ else:
+ # Auto-detect price if no selector
+ logger.info("No selector provided. Attempting to find price element...")
+ try:
+ # Look for common price patterns
+ price_locator = page.locator("text=/$[0-9,]+(\\.[0-9]{2})?/")
+ if await price_locator.count() > 0:
+ # Pick the first one that looks visible and reasonable size
+ # This is heuristic
+ await price_locator.first.scroll_into_view_if_needed()
+ logger.info("Scrolled to potential price element")
+ except Exception as e:
+ logger.warning(f"Auto-price detection failed: {e}")
+
+ # Smart Scroll
+ if smart_scroll:
+ logger.info(f"Performing smart scroll ({scroll_pixels}px)...")
+ try:
+ await page.evaluate(f"window.scrollBy(0, {scroll_pixels})")
+ await page.wait_for_timeout(1000)
+ except Exception as e:
+ logger.warning(f"Smart scroll failed: {e}")
+
+ # Text Extraction
+ page_text = ""
+ if text_length > 0:
+ try:
+ logger.info(f"Extracting text (limit: {text_length} chars)...")
+ # Get text from body
+ raw_text = await page.inner_text("body")
+ # Simple truncation
+ page_text = raw_text[:text_length]
+ logger.info(f"Extracted {len(page_text)} characters")
+ except Exception as e:
+ logger.error(f"Text extraction failed: {e}")
+
+ # Take screenshot
+ screenshot_dir = "screenshots"
+ os.makedirs(screenshot_dir, exist_ok=True)
+ if item_id:
+ filename = f"{screenshot_dir}/item_{item_id}.png"
+ else:
+ url_part = url.split("//")[-1].replace("/", "_")
+ timestamp = asyncio.get_event_loop().time()
+ filename = f"{screenshot_dir}/{url_part}_{timestamp}.png"
+
+ await page.screenshot(path=filename, full_page=False)
+ logger.info(f"Screenshot saved to {filename}")
+
+ return filename, page_text
+
+ except Exception as e:
+ logger.error(f"Error scraping {url}: {e}")
+ return None, ""
+
+ finally:
+ if browser:
+ await browser.close()
diff --git a/app/services/settings_service.py b/app/services/settings_service.py
new file mode 100644
index 0000000..7264de6
--- /dev/null
+++ b/app/services/settings_service.py
@@ -0,0 +1,25 @@
+from sqlalchemy.orm import Session
+
+from app import models, schemas
+
+
+class SettingsService:
+ @staticmethod
+ def get_settings(db: Session):
+ return db.query(models.Settings).all()
+
+ @staticmethod
+ def update_setting(db: Session, setting: schemas.SettingsUpdate):
+ db_setting = db.query(models.Settings).filter(models.Settings.key == setting.key).first()
+ if db_setting:
+ db_setting.value = setting.value
+ else:
+ db_setting = models.Settings(key=setting.key, value=setting.value)
+ db.add(db_setting)
+ db.commit()
+ return db_setting
+
+ @staticmethod
+ def get_setting_value(db: Session, key: str, default: str | None = None):
+ setting = db.query(models.Settings).filter(models.Settings.key == key).first()
+ return setting.value if setting else default
diff --git a/app/url_validation.py b/app/url_validation.py
new file mode 100644
index 0000000..5359698
--- /dev/null
+++ b/app/url_validation.py
@@ -0,0 +1,69 @@
+"""URL validation utilities for security."""
+
+import re
+from urllib.parse import urlparse
+
+
+class URLValidationError(Exception):
+ """Raised when URL validation fails."""
+
+ pass
+
+
+# Blocked schemes that could be used for SSRF
+BLOCKED_SCHEMES = {"file", "javascript", "data", "ftp"}
+
+# Private IP ranges (RFC 1918, RFC 4193, loopback)
+PRIVATE_IP_PATTERNS = [
+ re.compile(r"^127\."), # Loopback
+ re.compile(r"^10\."), # Private Class A
+ re.compile(r"^172\.(1[6-9]|2[0-9]|3[0-1])\."), # Private Class B
+ re.compile(r"^192\.168\."), # Private Class C
+ re.compile(r"^169\.254\."), # Link-local
+ re.compile(r"^::1$"), # IPv6 loopback
+ re.compile(r"^fc00:"), # IPv6 private
+ re.compile(r"^fe80:"), # IPv6 link-local
+ re.compile(r"^localhost$", re.IGNORECASE),
+ re.compile(r"^0\.0\.0\.0$"), # Any address
+]
+
+
+def validate_url(url: str, allow_private: bool = False) -> None:
+ """
+ Validate URL for security (SSRF prevention).
+
+ Args:
+ url: URL to validate
+ allow_private: Allow private/internal IPs (default: False)
+
+ Raises:
+ URLValidationError: If URL is invalid or blocked
+ """
+ if not url or not isinstance(url, str):
+ raise URLValidationError("URL must be a non-empty string")
+
+ try:
+ parsed = urlparse(url.strip())
+ except Exception as e:
+ raise URLValidationError(f"Invalid URL format: {e}") from e
+
+ # Check scheme
+ if not parsed.scheme:
+ raise URLValidationError("URL must include a scheme (http:// or https://)")
+
+ if parsed.scheme.lower() in BLOCKED_SCHEMES:
+ raise URLValidationError(f"Blocked URL scheme: {parsed.scheme}")
+
+ if parsed.scheme.lower() not in {"http", "https"}:
+ raise URLValidationError(f"Only HTTP/HTTPS schemes allowed, got: {parsed.scheme}")
+
+ # Check hostname
+ if not parsed.hostname:
+ raise URLValidationError("URL must include a hostname")
+
+ # Check for private IPs unless explicitly allowed
+ if not allow_private:
+ hostname = parsed.hostname.lower()
+ for pattern in PRIVATE_IP_PATTERNS:
+ if pattern.match(hostname):
+ raise URLValidationError(f"Private/internal IPs not allowed: {hostname}")
diff --git a/app/utils/image.py b/app/utils/image.py
new file mode 100644
index 0000000..785b75a
--- /dev/null
+++ b/app/utils/image.py
@@ -0,0 +1,45 @@
+import asyncio
+import base64
+import io
+import logging
+
+from PIL import Image
+
+logger = logging.getLogger(__name__)
+
+# Image processing constants
+MAX_IMAGE_SIZE = 1024
+JPEG_QUALITY = 85
+
+
+def _process_image(image_path: str) -> str:
+ """
+ Synchronous image processing function to be run in an executor.
+ """
+ try:
+ with Image.open(image_path) as img:
+ # Resize if too large (e.g., max dimension 1024)
+ if max(img.size) > MAX_IMAGE_SIZE:
+ img.thumbnail((MAX_IMAGE_SIZE, MAX_IMAGE_SIZE))
+ logger.info(f"Resized image to {img.size}")
+
+ # Convert to RGB if necessary (e.g. for PNGs with alpha)
+ if img.mode in ("RGBA", "P"):
+ img_to_process = img.convert("RGB")
+ else:
+ img_to_process = img
+
+ buffered = io.BytesIO()
+ img_to_process.save(buffered, format="JPEG", quality=JPEG_QUALITY)
+ return base64.b64encode(buffered.getvalue()).decode("utf-8")
+ except Exception as e:
+ logger.error(f"Error encoding image: {e}")
+ raise
+
+
+async def encode_image(image_path: str) -> str:
+ """
+ Asynchronously encode image by running blocking code in a thread.
+ """
+ loop = asyncio.get_running_loop()
+ return await loop.run_in_executor(None, _process_image, image_path)
diff --git a/app/utils/text.py b/app/utils/text.py
new file mode 100644
index 0000000..bbc7c56
--- /dev/null
+++ b/app/utils/text.py
@@ -0,0 +1,144 @@
+import re
+
+# Text filtering constants
+MIN_SNIPPET_LENGTH = 10
+SNIPPET_MERGE_DISTANCE = 50
+SNIPPET_CONTEXT_WINDOW = 100
+
+
+def clean_text(text: str) -> str:
+ """
+ Cleans the text by removing code blocks, HTML tags, and excessive whitespace.
+ """
+ if not text:
+ return ""
+
+ # Remove code blocks (```...```)
+ text = re.sub(r"```.*?```", "", text, flags=re.DOTALL)
+
+ # Remove HTML tags (basic)
+ text = re.sub(r"<[^>]+>", "", text)
+
+ # Remove non-printable characters (keep newlines and tabs)
+ text = re.sub(r"[^\x20-\x7E\n\t]", "", text)
+
+ # Collapse excessive whitespace
+ text = re.sub(r"\s+", " ", text).strip()
+
+ return text
+
+
+def _find_matches(text: str, text_lower: str, keyword: str) -> list[tuple[int, str]]:
+ snippets = []
+ if keyword.startswith("r\\"):
+ pattern = keyword[1:] # Remove 'r' prefix
+ for match in re.finditer(pattern, text_lower, re.IGNORECASE):
+ start = max(0, match.start() - SNIPPET_CONTEXT_WINDOW)
+ end = min(len(text), match.end() + SNIPPET_CONTEXT_WINDOW)
+ snippet = text[start:end].strip()
+ if snippet and len(snippet) > MIN_SNIPPET_LENGTH:
+ snippets.append((start, snippet))
+ else:
+ pos = 0
+ while True:
+ pos = text_lower.find(keyword.lower(), pos)
+ if pos == -1:
+ break
+ start = max(0, pos - SNIPPET_CONTEXT_WINDOW)
+ end = min(len(text), pos + len(keyword) + SNIPPET_CONTEXT_WINDOW)
+ snippet = text[start:end].strip()
+ if snippet and len(snippet) > MIN_SNIPPET_LENGTH:
+ snippets.append((start, snippet))
+ pos += 1
+ return snippets
+
+
+def filter_relevant_text(text: str, max_length: int = 2000) -> str:
+ """
+ Filter text to extract only relevant snippets around price and stock indicators.
+
+ Args:
+ text: Full cleaned webpage text
+ max_length: Maximum total length of filtered output
+
+ Returns:
+ Filtered text containing only relevant snippets
+ """
+ if not text:
+ return ""
+
+ # Keywords to search for (case-insensitive)
+ price_keywords = [
+ r"\$\d+\.?\d*", # $XX.XX pattern
+ r"\d+\.\d{2}\s*(usd|eur|gbp|cad)", # XX.XX USD pattern
+ "price:",
+ "cost:",
+ "sale:",
+ "msrp:",
+ "save:",
+ "discount:",
+ r"\$", # Any dollar sign
+ ]
+
+ stock_keywords = [
+ "add to cart",
+ "buy now",
+ "purchase",
+ "order now",
+ "in stock",
+ "out of stock",
+ "available",
+ "unavailable",
+ "sold out",
+ "notify me",
+ "back in stock",
+ "pre-order",
+ "ships",
+ "delivery",
+ "get it by",
+ ]
+
+ all_keywords = price_keywords + stock_keywords
+ snippets = []
+
+ text_lower = text.lower()
+
+ # Find all matches and extract context
+ for keyword in all_keywords:
+ snippets.extend(_find_matches(text, text_lower, keyword))
+
+ if not snippets:
+ # No matches found, return beginning of text
+ if len(text) > max_length:
+ return text[:max_length] + "...(truncated)"
+ return text
+
+ # Sort by position and deduplicate overlapping snippets
+ snippets.sort(key=lambda x: x[0])
+ merged_snippets = []
+ current_start, current_text = snippets[0]
+ current_end = current_start + len(current_text)
+
+ for start, snippet in snippets[1:]:
+ end = start + len(snippet)
+ # If overlapping or close together, merge
+ if start <= current_end + SNIPPET_MERGE_DISTANCE:
+ # Extend current snippet
+ if end > current_end:
+ # Merge overlapping text
+ current_text = current_text + " " + snippet[max(0, current_end - start) :]
+ current_end = end
+ else:
+ # Save current and start new
+ merged_snippets.append(current_text)
+ current_start, current_text = start, snippet
+ current_end = end
+
+ merged_snippets.append(current_text)
+
+ # Join snippets with separator and limit total length
+ result = " ... ".join(merged_snippets)
+ if len(result) > max_length:
+ result = result[:max_length] + "...(truncated)"
+
+ return result
diff --git a/docker-entrypoint.sh b/docker-entrypoint.sh
new file mode 100644
index 0000000..1514d4a
--- /dev/null
+++ b/docker-entrypoint.sh
@@ -0,0 +1,11 @@
+#!/bin/sh
+set -e
+
+echo "Setting up screenshots directory..."
+mkdir -p screenshots
+
+echo "Running database migrations..."
+alembic upgrade head
+
+echo "Starting application..."
+exec uvicorn app.main:app --host 0.0.0.0 --port 8000
diff --git a/frontend/index.html b/frontend/index.html
new file mode 100644
index 0000000..12eae17
--- /dev/null
+++ b/frontend/index.html
@@ -0,0 +1,17 @@
+
+
+
+
+ Pricecious
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
new file mode 100644
index 0000000..e4f8bb8
--- /dev/null
+++ b/frontend/package-lock.json
@@ -0,0 +1,3577 @@
+{
+ "name": "pricecious-frontend",
+ "version": "0.1.0",
+ "lockfileVersion": 3,
+ "requires": true,
+ "packages": {
+ "": {
+ "name": "pricecious-frontend",
+ "version": "0.1.0",
+ "dependencies": {
+ "@radix-ui/react-dialog": "^1.1.15",
+ "@radix-ui/react-label": "^2.1.8",
+ "@radix-ui/react-select": "^2.2.6",
+ "@radix-ui/react-slot": "^1.2.4",
+ "@radix-ui/react-switch": "^1.2.6",
+ "axios": "^1.6.0",
+ "class-variance-authority": "^0.7.1",
+ "clsx": "^2.1.1",
+ "lucide-react": "^0.292.0",
+ "react": "^18.2.0",
+ "react-dom": "^18.2.0",
+ "react-router-dom": "^6.30.2",
+ "sonner": "^1.4.0",
+ "tailwind-merge": "^3.4.0",
+ "tailwindcss-animate": "^1.0.7"
+ },
+ "devDependencies": {
+ "@types/react": "^18.2.37",
+ "@types/react-dom": "^18.2.15",
+ "@vitejs/plugin-react": "^4.2.0",
+ "tailwindcss": "^3.3.5",
+ "vite": "^7.2.4"
+ }
+ },
+ "node_modules/@alloc/quick-lru": {
+ "version": "5.2.0",
+ "resolved": "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz",
+ "integrity": "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/@babel/code-frame": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz",
+ "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==",
+ "dev": true,
+ "dependencies": {
+ "@babel/helper-validator-identifier": "^7.27.1",
+ "js-tokens": "^4.0.0",
+ "picocolors": "^1.1.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/compat-data": {
+ "version": "7.28.5",
+ "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.28.5.tgz",
+ "integrity": "sha512-6uFXyCayocRbqhZOB+6XcuZbkMNimwfVGFji8CTZnCzOHVGvDqzvitu1re2AU5LROliz7eQPhB8CpAMvnx9EjA==",
+ "dev": true,
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/core": {
+ "version": "7.28.5",
+ "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.5.tgz",
+ "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==",
+ "dev": true,
+ "dependencies": {
+ "@babel/code-frame": "^7.27.1",
+ "@babel/generator": "^7.28.5",
+ "@babel/helper-compilation-targets": "^7.27.2",
+ "@babel/helper-module-transforms": "^7.28.3",
+ "@babel/helpers": "^7.28.4",
+ "@babel/parser": "^7.28.5",
+ "@babel/template": "^7.27.2",
+ "@babel/traverse": "^7.28.5",
+ "@babel/types": "^7.28.5",
+ "@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.28.5",
+ "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.5.tgz",
+ "integrity": "sha512-3EwLFhZ38J4VyIP6WNtt2kUdW9dokXA9Cr4IVIFHuCpZ3H8/YFOl5JjZHisrn1fATPBmKKqXzDFvh9fUwHz6CQ==",
+ "dev": true,
+ "dependencies": {
+ "@babel/parser": "^7.28.5",
+ "@babel/types": "^7.28.5",
+ "@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.27.2",
+ "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz",
+ "integrity": "sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==",
+ "dev": true,
+ "dependencies": {
+ "@babel/compat-data": "^7.27.2",
+ "@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,
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-module-imports": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz",
+ "integrity": "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==",
+ "dev": true,
+ "dependencies": {
+ "@babel/traverse": "^7.27.1",
+ "@babel/types": "^7.27.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-module-transforms": {
+ "version": "7.28.3",
+ "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.3.tgz",
+ "integrity": "sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw==",
+ "dev": true,
+ "dependencies": {
+ "@babel/helper-module-imports": "^7.27.1",
+ "@babel/helper-validator-identifier": "^7.27.1",
+ "@babel/traverse": "^7.28.3"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0"
+ }
+ },
+ "node_modules/@babel/helper-plugin-utils": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz",
+ "integrity": "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==",
+ "dev": true,
+ "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,
+ "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,
+ "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,
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helpers": {
+ "version": "7.28.4",
+ "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.4.tgz",
+ "integrity": "sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w==",
+ "dev": true,
+ "dependencies": {
+ "@babel/template": "^7.27.2",
+ "@babel/types": "^7.28.4"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/parser": {
+ "version": "7.28.5",
+ "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.5.tgz",
+ "integrity": "sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==",
+ "dev": true,
+ "dependencies": {
+ "@babel/types": "^7.28.5"
+ },
+ "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,
+ "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,
+ "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.27.2",
+ "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.2.tgz",
+ "integrity": "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==",
+ "dev": true,
+ "dependencies": {
+ "@babel/code-frame": "^7.27.1",
+ "@babel/parser": "^7.27.2",
+ "@babel/types": "^7.27.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/traverse": {
+ "version": "7.28.5",
+ "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.5.tgz",
+ "integrity": "sha512-TCCj4t55U90khlYkVV/0TfkJkAkUg3jZFA3Neb7unZT8CPok7iiRfaX0F+WnqWqt7OxhOn0uBKXCw4lbL8W0aQ==",
+ "dev": true,
+ "dependencies": {
+ "@babel/code-frame": "^7.27.1",
+ "@babel/generator": "^7.28.5",
+ "@babel/helper-globals": "^7.28.0",
+ "@babel/parser": "^7.28.5",
+ "@babel/template": "^7.27.2",
+ "@babel/types": "^7.28.5",
+ "debug": "^4.3.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/types": {
+ "version": "7.28.5",
+ "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.5.tgz",
+ "integrity": "sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==",
+ "dev": true,
+ "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.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.12.tgz",
+ "integrity": "sha512-Hhmwd6CInZ3dwpuGTF8fJG6yoWmsToE+vYgD4nytZVxcu1ulHpUQRAB1UJ8+N1Am3Mz4+xOByoQoSZf4D+CpkA==",
+ "cpu": [
+ "ppc64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "aix"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/android-arm": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.12.tgz",
+ "integrity": "sha512-VJ+sKvNA/GE7Ccacc9Cha7bpS8nyzVv0jdVgwNDaR4gDMC/2TTRc33Ip8qrNYUcpkOHUT5OZ0bUcNNVZQ9RLlg==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/android-arm64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.12.tgz",
+ "integrity": "sha512-6AAmLG7zwD1Z159jCKPvAxZd4y/VTO0VkprYy+3N2FtJ8+BQWFXU+OxARIwA46c5tdD9SsKGZ/1ocqBS/gAKHg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/android-x64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.12.tgz",
+ "integrity": "sha512-5jbb+2hhDHx5phYR2By8GTWEzn6I9UqR11Kwf22iKbNpYrsmRB18aX/9ivc5cabcUiAT/wM+YIZ6SG9QO6a8kg==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/darwin-arm64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.12.tgz",
+ "integrity": "sha512-N3zl+lxHCifgIlcMUP5016ESkeQjLj/959RxxNYIthIg+CQHInujFuXeWbWMgnTo4cp5XVHqFPmpyu9J65C1Yg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/darwin-x64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.12.tgz",
+ "integrity": "sha512-HQ9ka4Kx21qHXwtlTUVbKJOAnmG1ipXhdWTmNXiPzPfWKpXqASVcWdnf2bnL73wgjNrFXAa3yYvBSd9pzfEIpA==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/freebsd-arm64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.12.tgz",
+ "integrity": "sha512-gA0Bx759+7Jve03K1S0vkOu5Lg/85dou3EseOGUes8flVOGxbhDDh/iZaoek11Y8mtyKPGF3vP8XhnkDEAmzeg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "freebsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/freebsd-x64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.12.tgz",
+ "integrity": "sha512-TGbO26Yw2xsHzxtbVFGEXBFH0FRAP7gtcPE7P5yP7wGy7cXK2oO7RyOhL5NLiqTlBh47XhmIUXuGciXEqYFfBQ==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "freebsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-arm": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.12.tgz",
+ "integrity": "sha512-lPDGyC1JPDou8kGcywY0YILzWlhhnRjdof3UlcoqYmS9El818LLfJJc3PXXgZHrHCAKs/Z2SeZtDJr5MrkxtOw==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-arm64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.12.tgz",
+ "integrity": "sha512-8bwX7a8FghIgrupcxb4aUmYDLp8pX06rGh5HqDT7bB+8Rdells6mHvrFHHW2JAOPZUbnjUpKTLg6ECyzvas2AQ==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-ia32": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.12.tgz",
+ "integrity": "sha512-0y9KrdVnbMM2/vG8KfU0byhUN+EFCny9+8g202gYqSSVMonbsCfLjUO+rCci7pM0WBEtz+oK/PIwHkzxkyharA==",
+ "cpu": [
+ "ia32"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-loong64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.12.tgz",
+ "integrity": "sha512-h///Lr5a9rib/v1GGqXVGzjL4TMvVTv+s1DPoxQdz7l/AYv6LDSxdIwzxkrPW438oUXiDtwM10o9PmwS/6Z0Ng==",
+ "cpu": [
+ "loong64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-mips64el": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.12.tgz",
+ "integrity": "sha512-iyRrM1Pzy9GFMDLsXn1iHUm18nhKnNMWscjmp4+hpafcZjrr2WbT//d20xaGljXDBYHqRcl8HnxbX6uaA/eGVw==",
+ "cpu": [
+ "mips64el"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-ppc64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.12.tgz",
+ "integrity": "sha512-9meM/lRXxMi5PSUqEXRCtVjEZBGwB7P/D4yT8UG/mwIdze2aV4Vo6U5gD3+RsoHXKkHCfSxZKzmDssVlRj1QQA==",
+ "cpu": [
+ "ppc64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-riscv64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.12.tgz",
+ "integrity": "sha512-Zr7KR4hgKUpWAwb1f3o5ygT04MzqVrGEGXGLnj15YQDJErYu/BGg+wmFlIDOdJp0PmB0lLvxFIOXZgFRrdjR0w==",
+ "cpu": [
+ "riscv64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-s390x": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.12.tgz",
+ "integrity": "sha512-MsKncOcgTNvdtiISc/jZs/Zf8d0cl/t3gYWX8J9ubBnVOwlk65UIEEvgBORTiljloIWnBzLs4qhzPkJcitIzIg==",
+ "cpu": [
+ "s390x"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-x64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.12.tgz",
+ "integrity": "sha512-uqZMTLr/zR/ed4jIGnwSLkaHmPjOjJvnm6TVVitAa08SLS9Z0VM8wIRx7gWbJB5/J54YuIMInDquWyYvQLZkgw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/netbsd-arm64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.12.tgz",
+ "integrity": "sha512-xXwcTq4GhRM7J9A8Gv5boanHhRa/Q9KLVmcyXHCTaM4wKfIpWkdXiMog/KsnxzJ0A1+nD+zoecuzqPmCRyBGjg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "netbsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/netbsd-x64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.12.tgz",
+ "integrity": "sha512-Ld5pTlzPy3YwGec4OuHh1aCVCRvOXdH8DgRjfDy/oumVovmuSzWfnSJg+VtakB9Cm0gxNO9BzWkj6mtO1FMXkQ==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "netbsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/openbsd-arm64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.12.tgz",
+ "integrity": "sha512-fF96T6KsBo/pkQI950FARU9apGNTSlZGsv1jZBAlcLL1MLjLNIWPBkj5NlSz8aAzYKg+eNqknrUJ24QBybeR5A==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "openbsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/openbsd-x64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.12.tgz",
+ "integrity": "sha512-MZyXUkZHjQxUvzK7rN8DJ3SRmrVrke8ZyRusHlP+kuwqTcfWLyqMOE3sScPPyeIXN/mDJIfGXvcMqCgYKekoQw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "openbsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/openharmony-arm64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.25.12.tgz",
+ "integrity": "sha512-rm0YWsqUSRrjncSXGA7Zv78Nbnw4XL6/dzr20cyrQf7ZmRcsovpcRBdhD43Nuk3y7XIoW2OxMVvwuRvk9XdASg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "openharmony"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/sunos-x64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.12.tgz",
+ "integrity": "sha512-3wGSCDyuTHQUzt0nV7bocDy72r2lI33QL3gkDNGkod22EsYl04sMf0qLb8luNKTOmgF/eDEDP5BFNwoBKH441w==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "sunos"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/win32-arm64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.12.tgz",
+ "integrity": "sha512-rMmLrur64A7+DKlnSuwqUdRKyd3UE7oPJZmnljqEptesKM8wx9J8gx5u0+9Pq0fQQW8vqeKebwNXdfOyP+8Bsg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/win32-ia32": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.12.tgz",
+ "integrity": "sha512-HkqnmmBoCbCwxUKKNPBixiWDGCpQGVsrQfJoVGYLPT41XWF8lHuE5N6WhVia2n4o5QK5M4tYr21827fNhi4byQ==",
+ "cpu": [
+ "ia32"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/win32-x64": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.12.tgz",
+ "integrity": "sha512-alJC0uCZpTFrSL0CCDjcgleBXPnCrEAhTBILpeAp7M/OFgoqtAetfBzX0xM00MUsVVPpVjlPuMbREqnZCXaTnA==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@floating-ui/core": {
+ "version": "1.7.3",
+ "resolved": "https://registry.npmjs.org/@floating-ui/core/-/core-1.7.3.tgz",
+ "integrity": "sha512-sGnvb5dmrJaKEZ+LDIpguvdX3bDlEllmv4/ClQ9awcmCZrlx5jQyyMWFM5kBI+EyNOCDDiKk8il0zeuX3Zlg/w==",
+ "dependencies": {
+ "@floating-ui/utils": "^0.2.10"
+ }
+ },
+ "node_modules/@floating-ui/dom": {
+ "version": "1.7.4",
+ "resolved": "https://registry.npmjs.org/@floating-ui/dom/-/dom-1.7.4.tgz",
+ "integrity": "sha512-OOchDgh4F2CchOX94cRVqhvy7b3AFb+/rQXyswmzmGakRfkMgoWVjfnLWkRirfLEfuD4ysVW16eXzwt3jHIzKA==",
+ "dependencies": {
+ "@floating-ui/core": "^1.7.3",
+ "@floating-ui/utils": "^0.2.10"
+ }
+ },
+ "node_modules/@floating-ui/react-dom": {
+ "version": "2.1.6",
+ "resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.6.tgz",
+ "integrity": "sha512-4JX6rEatQEvlmgU80wZyq9RT96HZJa88q8hp0pBd+LrczeDI4o6uA2M+uvxngVHo4Ihr8uibXxH6+70zhAFrVw==",
+ "dependencies": {
+ "@floating-ui/dom": "^1.7.4"
+ },
+ "peerDependencies": {
+ "react": ">=16.8.0",
+ "react-dom": ">=16.8.0"
+ }
+ },
+ "node_modules/@floating-ui/utils": {
+ "version": "0.2.10",
+ "resolved": "https://registry.npmjs.org/@floating-ui/utils/-/utils-0.2.10.tgz",
+ "integrity": "sha512-aGTxbpbg8/b5JfU1HXSrbH3wXZuLPJcNEcZQFMxLs3oSzgtVu6nFPkbbGGUvBcUjKV2YyB9Wxxabo+HEH9tcRQ=="
+ },
+ "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==",
+ "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,
+ "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==",
+ "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=="
+ },
+ "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==",
+ "dependencies": {
+ "@jridgewell/resolve-uri": "^3.1.0",
+ "@jridgewell/sourcemap-codec": "^1.4.14"
+ }
+ },
+ "node_modules/@nodelib/fs.scandir": {
+ "version": "2.1.5",
+ "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+ "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+ "dependencies": {
+ "@nodelib/fs.stat": "2.0.5",
+ "run-parallel": "^1.1.9"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/@nodelib/fs.stat": {
+ "version": "2.0.5",
+ "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+ "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/@nodelib/fs.walk": {
+ "version": "1.2.8",
+ "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+ "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+ "dependencies": {
+ "@nodelib/fs.scandir": "2.1.5",
+ "fastq": "^1.6.0"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/@radix-ui/number": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/@radix-ui/number/-/number-1.1.1.tgz",
+ "integrity": "sha512-MkKCwxlXTgz6CFoJx3pCwn07GKp36+aZyu/u2Ln2VrA5DcdyCZkASEDBTd8x5whTQQL5CiYf4prXKLcgQdv29g=="
+ },
+ "node_modules/@radix-ui/primitive": {
+ "version": "1.1.3",
+ "resolved": "https://registry.npmjs.org/@radix-ui/primitive/-/primitive-1.1.3.tgz",
+ "integrity": "sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg=="
+ },
+ "node_modules/@radix-ui/react-arrow": {
+ "version": "1.1.7",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-arrow/-/react-arrow-1.1.7.tgz",
+ "integrity": "sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==",
+ "dependencies": {
+ "@radix-ui/react-primitive": "2.1.3"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "@types/react-dom": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+ "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ },
+ "@types/react-dom": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-collection": {
+ "version": "1.1.7",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-collection/-/react-collection-1.1.7.tgz",
+ "integrity": "sha512-Fh9rGN0MoI4ZFUNyfFVNU4y9LUz93u9/0K+yLgA2bwRojxM8JU1DyvvMBabnZPBgMWREAJvU2jjVzq+LrFUglw==",
+ "dependencies": {
+ "@radix-ui/react-compose-refs": "1.1.2",
+ "@radix-ui/react-context": "1.1.2",
+ "@radix-ui/react-primitive": "2.1.3",
+ "@radix-ui/react-slot": "1.2.3"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "@types/react-dom": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+ "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ },
+ "@types/react-dom": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-collection/node_modules/@radix-ui/react-slot": {
+ "version": "1.2.3",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz",
+ "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==",
+ "dependencies": {
+ "@radix-ui/react-compose-refs": "1.1.2"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-compose-refs": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-compose-refs/-/react-compose-refs-1.1.2.tgz",
+ "integrity": "sha512-z4eqJvfiNnFMHIIvXP3CY57y2WJs5g2v3X0zm9mEJkrkNv4rDxu+sg9Jh8EkXyeqBkB7SOcboo9dMVqhyrACIg==",
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-context": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-context/-/react-context-1.1.2.tgz",
+ "integrity": "sha512-jCi/QKUM2r1Ju5a3J64TH2A5SpKAgh0LpknyqdQ4m6DCV0xJ2HG1xARRwNGPQfi1SLdLWZ1OJz6F4OMBBNiGJA==",
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-dialog": {
+ "version": "1.1.15",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-dialog/-/react-dialog-1.1.15.tgz",
+ "integrity": "sha512-TCglVRtzlffRNxRMEyR36DGBLJpeusFcgMVD9PZEzAKnUs1lKCgX5u9BmC2Yg+LL9MgZDugFFs1Vl+Jp4t/PGw==",
+ "dependencies": {
+ "@radix-ui/primitive": "1.1.3",
+ "@radix-ui/react-compose-refs": "1.1.2",
+ "@radix-ui/react-context": "1.1.2",
+ "@radix-ui/react-dismissable-layer": "1.1.11",
+ "@radix-ui/react-focus-guards": "1.1.3",
+ "@radix-ui/react-focus-scope": "1.1.7",
+ "@radix-ui/react-id": "1.1.1",
+ "@radix-ui/react-portal": "1.1.9",
+ "@radix-ui/react-presence": "1.1.5",
+ "@radix-ui/react-primitive": "2.1.3",
+ "@radix-ui/react-slot": "1.2.3",
+ "@radix-ui/react-use-controllable-state": "1.2.2",
+ "aria-hidden": "^1.2.4",
+ "react-remove-scroll": "^2.6.3"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "@types/react-dom": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+ "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ },
+ "@types/react-dom": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-slot": {
+ "version": "1.2.3",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz",
+ "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==",
+ "dependencies": {
+ "@radix-ui/react-compose-refs": "1.1.2"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-direction": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-direction/-/react-direction-1.1.1.tgz",
+ "integrity": "sha512-1UEWRX6jnOA2y4H5WczZ44gOOjTEmlqv1uNW4GAJEO5+bauCBhv8snY65Iw5/VOS/ghKN9gr2KjnLKxrsvoMVw==",
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-dismissable-layer": {
+ "version": "1.1.11",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-dismissable-layer/-/react-dismissable-layer-1.1.11.tgz",
+ "integrity": "sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==",
+ "dependencies": {
+ "@radix-ui/primitive": "1.1.3",
+ "@radix-ui/react-compose-refs": "1.1.2",
+ "@radix-ui/react-primitive": "2.1.3",
+ "@radix-ui/react-use-callback-ref": "1.1.1",
+ "@radix-ui/react-use-escape-keydown": "1.1.1"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "@types/react-dom": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+ "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ },
+ "@types/react-dom": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-focus-guards": {
+ "version": "1.1.3",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-focus-guards/-/react-focus-guards-1.1.3.tgz",
+ "integrity": "sha512-0rFg/Rj2Q62NCm62jZw0QX7a3sz6QCQU0LpZdNrJX8byRGaGVTqbrW9jAoIAHyMQqsNpeZ81YgSizOt5WXq0Pw==",
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-focus-scope": {
+ "version": "1.1.7",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-focus-scope/-/react-focus-scope-1.1.7.tgz",
+ "integrity": "sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw==",
+ "dependencies": {
+ "@radix-ui/react-compose-refs": "1.1.2",
+ "@radix-ui/react-primitive": "2.1.3",
+ "@radix-ui/react-use-callback-ref": "1.1.1"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "@types/react-dom": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+ "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ },
+ "@types/react-dom": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-id": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-id/-/react-id-1.1.1.tgz",
+ "integrity": "sha512-kGkGegYIdQsOb4XjsfM97rXsiHaBwco+hFI66oO4s9LU+PLAC5oJ7khdOVFxkhsmlbpUqDAvXw11CluXP+jkHg==",
+ "dependencies": {
+ "@radix-ui/react-use-layout-effect": "1.1.1"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-label": {
+ "version": "2.1.8",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-label/-/react-label-2.1.8.tgz",
+ "integrity": "sha512-FmXs37I6hSBVDlO4y764TNz1rLgKwjJMQ0EGte6F3Cb3f4bIuHB/iLa/8I9VKkmOy+gNHq8rql3j686ACVV21A==",
+ "dependencies": {
+ "@radix-ui/react-primitive": "2.1.4"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "@types/react-dom": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+ "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ },
+ "@types/react-dom": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-label/node_modules/@radix-ui/react-primitive": {
+ "version": "2.1.4",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-primitive/-/react-primitive-2.1.4.tgz",
+ "integrity": "sha512-9hQc4+GNVtJAIEPEqlYqW5RiYdrr8ea5XQ0ZOnD6fgru+83kqT15mq2OCcbe8KnjRZl5vF3ks69AKz3kh1jrhg==",
+ "dependencies": {
+ "@radix-ui/react-slot": "1.2.4"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "@types/react-dom": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+ "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ },
+ "@types/react-dom": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-popper": {
+ "version": "1.2.8",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-popper/-/react-popper-1.2.8.tgz",
+ "integrity": "sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==",
+ "dependencies": {
+ "@floating-ui/react-dom": "^2.0.0",
+ "@radix-ui/react-arrow": "1.1.7",
+ "@radix-ui/react-compose-refs": "1.1.2",
+ "@radix-ui/react-context": "1.1.2",
+ "@radix-ui/react-primitive": "2.1.3",
+ "@radix-ui/react-use-callback-ref": "1.1.1",
+ "@radix-ui/react-use-layout-effect": "1.1.1",
+ "@radix-ui/react-use-rect": "1.1.1",
+ "@radix-ui/react-use-size": "1.1.1",
+ "@radix-ui/rect": "1.1.1"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "@types/react-dom": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+ "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ },
+ "@types/react-dom": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-portal": {
+ "version": "1.1.9",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-portal/-/react-portal-1.1.9.tgz",
+ "integrity": "sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ==",
+ "dependencies": {
+ "@radix-ui/react-primitive": "2.1.3",
+ "@radix-ui/react-use-layout-effect": "1.1.1"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "@types/react-dom": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+ "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ },
+ "@types/react-dom": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-presence": {
+ "version": "1.1.5",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-presence/-/react-presence-1.1.5.tgz",
+ "integrity": "sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==",
+ "dependencies": {
+ "@radix-ui/react-compose-refs": "1.1.2",
+ "@radix-ui/react-use-layout-effect": "1.1.1"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "@types/react-dom": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+ "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ },
+ "@types/react-dom": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-primitive": {
+ "version": "2.1.3",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-primitive/-/react-primitive-2.1.3.tgz",
+ "integrity": "sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ==",
+ "dependencies": {
+ "@radix-ui/react-slot": "1.2.3"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "@types/react-dom": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+ "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ },
+ "@types/react-dom": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-primitive/node_modules/@radix-ui/react-slot": {
+ "version": "1.2.3",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz",
+ "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==",
+ "dependencies": {
+ "@radix-ui/react-compose-refs": "1.1.2"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-select": {
+ "version": "2.2.6",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-select/-/react-select-2.2.6.tgz",
+ "integrity": "sha512-I30RydO+bnn2PQztvo25tswPH+wFBjehVGtmagkU78yMdwTwVf12wnAOF+AeP8S2N8xD+5UPbGhkUfPyvT+mwQ==",
+ "dependencies": {
+ "@radix-ui/number": "1.1.1",
+ "@radix-ui/primitive": "1.1.3",
+ "@radix-ui/react-collection": "1.1.7",
+ "@radix-ui/react-compose-refs": "1.1.2",
+ "@radix-ui/react-context": "1.1.2",
+ "@radix-ui/react-direction": "1.1.1",
+ "@radix-ui/react-dismissable-layer": "1.1.11",
+ "@radix-ui/react-focus-guards": "1.1.3",
+ "@radix-ui/react-focus-scope": "1.1.7",
+ "@radix-ui/react-id": "1.1.1",
+ "@radix-ui/react-popper": "1.2.8",
+ "@radix-ui/react-portal": "1.1.9",
+ "@radix-ui/react-primitive": "2.1.3",
+ "@radix-ui/react-slot": "1.2.3",
+ "@radix-ui/react-use-callback-ref": "1.1.1",
+ "@radix-ui/react-use-controllable-state": "1.2.2",
+ "@radix-ui/react-use-layout-effect": "1.1.1",
+ "@radix-ui/react-use-previous": "1.1.1",
+ "@radix-ui/react-visually-hidden": "1.2.3",
+ "aria-hidden": "^1.2.4",
+ "react-remove-scroll": "^2.6.3"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "@types/react-dom": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+ "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ },
+ "@types/react-dom": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-select/node_modules/@radix-ui/react-slot": {
+ "version": "1.2.3",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz",
+ "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==",
+ "dependencies": {
+ "@radix-ui/react-compose-refs": "1.1.2"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-slot": {
+ "version": "1.2.4",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.4.tgz",
+ "integrity": "sha512-Jl+bCv8HxKnlTLVrcDE8zTMJ09R9/ukw4qBs/oZClOfoQk/cOTbDn+NceXfV7j09YPVQUryJPHurafcSg6EVKA==",
+ "dependencies": {
+ "@radix-ui/react-compose-refs": "1.1.2"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-switch": {
+ "version": "1.2.6",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-switch/-/react-switch-1.2.6.tgz",
+ "integrity": "sha512-bByzr1+ep1zk4VubeEVViV592vu2lHE2BZY5OnzehZqOOgogN80+mNtCqPkhn2gklJqOpxWgPoYTSnhBCqpOXQ==",
+ "dependencies": {
+ "@radix-ui/primitive": "1.1.3",
+ "@radix-ui/react-compose-refs": "1.1.2",
+ "@radix-ui/react-context": "1.1.2",
+ "@radix-ui/react-primitive": "2.1.3",
+ "@radix-ui/react-use-controllable-state": "1.2.2",
+ "@radix-ui/react-use-previous": "1.1.1",
+ "@radix-ui/react-use-size": "1.1.1"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "@types/react-dom": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+ "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ },
+ "@types/react-dom": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-use-callback-ref": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-use-callback-ref/-/react-use-callback-ref-1.1.1.tgz",
+ "integrity": "sha512-FkBMwD+qbGQeMu1cOHnuGB6x4yzPjho8ap5WtbEJ26umhgqVXbhekKUQO+hZEL1vU92a3wHwdp0HAcqAUF5iDg==",
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-use-controllable-state": {
+ "version": "1.2.2",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-use-controllable-state/-/react-use-controllable-state-1.2.2.tgz",
+ "integrity": "sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg==",
+ "dependencies": {
+ "@radix-ui/react-use-effect-event": "0.0.2",
+ "@radix-ui/react-use-layout-effect": "1.1.1"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-use-effect-event": {
+ "version": "0.0.2",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-use-effect-event/-/react-use-effect-event-0.0.2.tgz",
+ "integrity": "sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA==",
+ "dependencies": {
+ "@radix-ui/react-use-layout-effect": "1.1.1"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-use-escape-keydown": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-use-escape-keydown/-/react-use-escape-keydown-1.1.1.tgz",
+ "integrity": "sha512-Il0+boE7w/XebUHyBjroE+DbByORGR9KKmITzbR7MyQ4akpORYP/ZmbhAr0DG7RmmBqoOnZdy2QlvajJ2QA59g==",
+ "dependencies": {
+ "@radix-ui/react-use-callback-ref": "1.1.1"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-use-layout-effect": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-use-layout-effect/-/react-use-layout-effect-1.1.1.tgz",
+ "integrity": "sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ==",
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-use-previous": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-use-previous/-/react-use-previous-1.1.1.tgz",
+ "integrity": "sha512-2dHfToCj/pzca2Ck724OZ5L0EVrr3eHRNsG/b3xQJLA2hZpVCS99bLAX+hm1IHXDEnzU6by5z/5MIY794/a8NQ==",
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-use-rect": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-use-rect/-/react-use-rect-1.1.1.tgz",
+ "integrity": "sha512-QTYuDesS0VtuHNNvMh+CjlKJ4LJickCMUAqjlE3+j8w+RlRpwyX3apEQKGFzbZGdo7XNG1tXa+bQqIE7HIXT2w==",
+ "dependencies": {
+ "@radix-ui/rect": "1.1.1"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-use-size": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-use-size/-/react-use-size-1.1.1.tgz",
+ "integrity": "sha512-ewrXRDTAqAXlkl6t/fkXWNAhFX9I+CkKlw6zjEwk86RSPKwZr3xpBRso655aqYafwtnbpHLj6toFzmd6xdVptQ==",
+ "dependencies": {
+ "@radix-ui/react-use-layout-effect": "1.1.1"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/react-visually-hidden": {
+ "version": "1.2.3",
+ "resolved": "https://registry.npmjs.org/@radix-ui/react-visually-hidden/-/react-visually-hidden-1.2.3.tgz",
+ "integrity": "sha512-pzJq12tEaaIhqjbzpCuv/OypJY/BPavOofm+dbab+MHLajy277+1lLm6JFcGgF5eskJ6mquGirhXY2GD/8u8Ug==",
+ "dependencies": {
+ "@radix-ui/react-primitive": "2.1.3"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "@types/react-dom": "*",
+ "react": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc",
+ "react-dom": "^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ },
+ "@types/react-dom": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@radix-ui/rect": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/@radix-ui/rect/-/rect-1.1.1.tgz",
+ "integrity": "sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw=="
+ },
+ "node_modules/@remix-run/router": {
+ "version": "1.23.1",
+ "resolved": "https://registry.npmjs.org/@remix-run/router/-/router-1.23.1.tgz",
+ "integrity": "sha512-vDbaOzF7yT2Qs4vO6XV1MHcJv+3dgR1sT+l3B8xxOVhUC336prMvqrvsLL/9Dnw2xr6Qhz4J0dmS0llNAbnUmQ==",
+ "engines": {
+ "node": ">=14.0.0"
+ }
+ },
+ "node_modules/@rolldown/pluginutils": {
+ "version": "1.0.0-beta.27",
+ "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz",
+ "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==",
+ "dev": true
+ },
+ "node_modules/@rollup/rollup-android-arm-eabi": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.53.3.tgz",
+ "integrity": "sha512-mRSi+4cBjrRLoaal2PnqH82Wqyb+d3HsPUN/W+WslCXsZsyHa9ZeQQX/pQsZaVIWDkPcpV6jJ+3KLbTbgnwv8w==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "android"
+ ]
+ },
+ "node_modules/@rollup/rollup-android-arm64": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.53.3.tgz",
+ "integrity": "sha512-CbDGaMpdE9sh7sCmTrTUyllhrg65t6SwhjlMJsLr+J8YjFuPmCEjbBSx4Z/e4SmDyH3aB5hGaJUP2ltV/vcs4w==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "android"
+ ]
+ },
+ "node_modules/@rollup/rollup-darwin-arm64": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.53.3.tgz",
+ "integrity": "sha512-Nr7SlQeqIBpOV6BHHGZgYBuSdanCXuw09hon14MGOLGmXAFYjx1wNvquVPmpZnl0tLjg25dEdr4IQ6GgyToCUA==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "darwin"
+ ]
+ },
+ "node_modules/@rollup/rollup-darwin-x64": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.53.3.tgz",
+ "integrity": "sha512-DZ8N4CSNfl965CmPktJ8oBnfYr3F8dTTNBQkRlffnUarJ2ohudQD17sZBa097J8xhQ26AwhHJ5mvUyQW8ddTsQ==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "darwin"
+ ]
+ },
+ "node_modules/@rollup/rollup-freebsd-arm64": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.53.3.tgz",
+ "integrity": "sha512-yMTrCrK92aGyi7GuDNtGn2sNW+Gdb4vErx4t3Gv/Tr+1zRb8ax4z8GWVRfr3Jw8zJWvpGHNpss3vVlbF58DZ4w==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "freebsd"
+ ]
+ },
+ "node_modules/@rollup/rollup-freebsd-x64": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.53.3.tgz",
+ "integrity": "sha512-lMfF8X7QhdQzseM6XaX0vbno2m3hlyZFhwcndRMw8fbAGUGL3WFMBdK0hbUBIUYcEcMhVLr1SIamDeuLBnXS+Q==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "freebsd"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.53.3.tgz",
+ "integrity": "sha512-k9oD15soC/Ln6d2Wv/JOFPzZXIAIFLp6B+i14KhxAfnq76ajt0EhYc5YPeX6W1xJkAdItcVT+JhKl1QZh44/qw==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.53.3.tgz",
+ "integrity": "sha512-vTNlKq+N6CK/8UktsrFuc+/7NlEYVxgaEgRXVUVK258Z5ymho29skzW1sutgYjqNnquGwVUObAaxae8rZ6YMhg==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-arm64-gnu": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.53.3.tgz",
+ "integrity": "sha512-RGrFLWgMhSxRs/EWJMIFM1O5Mzuz3Xy3/mnxJp/5cVhZ2XoCAxJnmNsEyeMJtpK+wu0FJFWz+QF4mjCA7AUQ3w==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-arm64-musl": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.53.3.tgz",
+ "integrity": "sha512-kASyvfBEWYPEwe0Qv4nfu6pNkITLTb32p4yTgzFCocHnJLAHs+9LjUu9ONIhvfT/5lv4YS5muBHyuV84epBo/A==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-loong64-gnu": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.53.3.tgz",
+ "integrity": "sha512-JiuKcp2teLJwQ7vkJ95EwESWkNRFJD7TQgYmCnrPtlu50b4XvT5MOmurWNrCj3IFdyjBQ5p9vnrX4JM6I8OE7g==",
+ "cpu": [
+ "loong64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.53.3.tgz",
+ "integrity": "sha512-EoGSa8nd6d3T7zLuqdojxC20oBfNT8nexBbB/rkxgKj5T5vhpAQKKnD+h3UkoMuTyXkP5jTjK/ccNRmQrPNDuw==",
+ "cpu": [
+ "ppc64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.53.3.tgz",
+ "integrity": "sha512-4s+Wped2IHXHPnAEbIB0YWBv7SDohqxobiiPA1FIWZpX+w9o2i4LezzH/NkFUl8LRci/8udci6cLq+jJQlh+0g==",
+ "cpu": [
+ "riscv64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-riscv64-musl": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.53.3.tgz",
+ "integrity": "sha512-68k2g7+0vs2u9CxDt5ktXTngsxOQkSEV/xBbwlqYcUrAVh6P9EgMZvFsnHy4SEiUl46Xf0IObWVbMvPrr2gw8A==",
+ "cpu": [
+ "riscv64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-s390x-gnu": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.53.3.tgz",
+ "integrity": "sha512-VYsFMpULAz87ZW6BVYw3I6sWesGpsP9OPcyKe8ofdg9LHxSbRMd7zrVrr5xi/3kMZtpWL/wC+UIJWJYVX5uTKg==",
+ "cpu": [
+ "s390x"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-x64-gnu": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.53.3.tgz",
+ "integrity": "sha512-3EhFi1FU6YL8HTUJZ51imGJWEX//ajQPfqWLI3BQq4TlvHy4X0MOr5q3D2Zof/ka0d5FNdPwZXm3Yyib/UEd+w==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-x64-musl": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.53.3.tgz",
+ "integrity": "sha512-eoROhjcc6HbZCJr+tvVT8X4fW3/5g/WkGvvmwz/88sDtSJzO7r/blvoBDgISDiCjDRZmHpwud7h+6Q9JxFwq1Q==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-openharmony-arm64": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.53.3.tgz",
+ "integrity": "sha512-OueLAWgrNSPGAdUdIjSWXw+u/02BRTcnfw9PN41D2vq/JSEPnJnVuBgw18VkN8wcd4fjUs+jFHVM4t9+kBSNLw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "openharmony"
+ ]
+ },
+ "node_modules/@rollup/rollup-win32-arm64-msvc": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.53.3.tgz",
+ "integrity": "sha512-GOFuKpsxR/whszbF/bzydebLiXIHSgsEUp6M0JI8dWvi+fFa1TD6YQa4aSZHtpmh2/uAlj/Dy+nmby3TJ3pkTw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "win32"
+ ]
+ },
+ "node_modules/@rollup/rollup-win32-ia32-msvc": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.53.3.tgz",
+ "integrity": "sha512-iah+THLcBJdpfZ1TstDFbKNznlzoxa8fmnFYK4V67HvmuNYkVdAywJSoteUszvBQ9/HqN2+9AZghbajMsFT+oA==",
+ "cpu": [
+ "ia32"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "win32"
+ ]
+ },
+ "node_modules/@rollup/rollup-win32-x64-gnu": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.53.3.tgz",
+ "integrity": "sha512-J9QDiOIZlZLdcot5NXEepDkstocktoVjkaKUtqzgzpt2yWjGlbYiKyp05rWwk4nypbYUNoFAztEgixoLaSETkg==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "win32"
+ ]
+ },
+ "node_modules/@rollup/rollup-win32-x64-msvc": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.53.3.tgz",
+ "integrity": "sha512-UhTd8u31dXadv0MopwGgNOBpUVROFKWVQgAg5N1ESyCz8AuBcMqm4AuTjrwgQKGDfoFuz02EuMRHQIw/frmYKQ==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "optional": true,
+ "os": [
+ "win32"
+ ]
+ },
+ "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,
+ "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,
+ "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,
+ "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,
+ "dependencies": {
+ "@babel/types": "^7.28.2"
+ }
+ },
+ "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
+ },
+ "node_modules/@types/prop-types": {
+ "version": "15.7.15",
+ "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz",
+ "integrity": "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==",
+ "devOptional": true
+ },
+ "node_modules/@types/react": {
+ "version": "18.3.27",
+ "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.27.tgz",
+ "integrity": "sha512-cisd7gxkzjBKU2GgdYrTdtQx1SORymWyaAFhaxQPK9bYO9ot3Y5OikQRvY0VYQtvwjeQnizCINJAenh/V7MK2w==",
+ "devOptional": true,
+ "dependencies": {
+ "@types/prop-types": "*",
+ "csstype": "^3.2.2"
+ }
+ },
+ "node_modules/@types/react-dom": {
+ "version": "18.3.7",
+ "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.7.tgz",
+ "integrity": "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==",
+ "devOptional": true,
+ "peerDependencies": {
+ "@types/react": "^18.0.0"
+ }
+ },
+ "node_modules/@vitejs/plugin-react": {
+ "version": "4.7.0",
+ "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz",
+ "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==",
+ "dev": true,
+ "dependencies": {
+ "@babel/core": "^7.28.0",
+ "@babel/plugin-transform-react-jsx-self": "^7.27.1",
+ "@babel/plugin-transform-react-jsx-source": "^7.27.1",
+ "@rolldown/pluginutils": "1.0.0-beta.27",
+ "@types/babel__core": "^7.20.5",
+ "react-refresh": "^0.17.0"
+ },
+ "engines": {
+ "node": "^14.18.0 || >=16.0.0"
+ },
+ "peerDependencies": {
+ "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+ }
+ },
+ "node_modules/any-promise": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz",
+ "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A=="
+ },
+ "node_modules/anymatch": {
+ "version": "3.1.3",
+ "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+ "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+ "dependencies": {
+ "normalize-path": "^3.0.0",
+ "picomatch": "^2.0.4"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/arg": {
+ "version": "5.0.2",
+ "resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz",
+ "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg=="
+ },
+ "node_modules/aria-hidden": {
+ "version": "1.2.6",
+ "resolved": "https://registry.npmjs.org/aria-hidden/-/aria-hidden-1.2.6.tgz",
+ "integrity": "sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA==",
+ "dependencies": {
+ "tslib": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/asynckit": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+ "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="
+ },
+ "node_modules/axios": {
+ "version": "1.13.2",
+ "resolved": "https://registry.npmjs.org/axios/-/axios-1.13.2.tgz",
+ "integrity": "sha512-VPk9ebNqPcy5lRGuSlKx752IlDatOjT9paPlm8A7yOuW2Fbvp4X3JznJtT4f0GzGLLiWE9W8onz51SqLYwzGaA==",
+ "dependencies": {
+ "follow-redirects": "^1.15.6",
+ "form-data": "^4.0.4",
+ "proxy-from-env": "^1.1.0"
+ }
+ },
+ "node_modules/baseline-browser-mapping": {
+ "version": "2.8.29",
+ "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.8.29.tgz",
+ "integrity": "sha512-sXdt2elaVnhpDNRDz+1BDx1JQoJRuNk7oVlAlbGiFkLikHCAQiccexF/9e91zVi6RCgqspl04aP+6Cnl9zRLrA==",
+ "dev": true,
+ "bin": {
+ "baseline-browser-mapping": "dist/cli.js"
+ }
+ },
+ "node_modules/binary-extensions": {
+ "version": "2.3.0",
+ "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
+ "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/braces": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+ "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+ "dependencies": {
+ "fill-range": "^7.1.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/browserslist": {
+ "version": "4.28.0",
+ "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.0.tgz",
+ "integrity": "sha512-tbydkR/CxfMwelN0vwdP/pLkDwyAASZ+VfWm4EOwlB6SWhx1sYnWLqo8N5j0rAzPfzfRaxt0mM/4wPU/Su84RQ==",
+ "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"
+ }
+ ],
+ "dependencies": {
+ "baseline-browser-mapping": "^2.8.25",
+ "caniuse-lite": "^1.0.30001754",
+ "electron-to-chromium": "^1.5.249",
+ "node-releases": "^2.0.27",
+ "update-browserslist-db": "^1.1.4"
+ },
+ "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==",
+ "dependencies": {
+ "es-errors": "^1.3.0",
+ "function-bind": "^1.1.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/camelcase-css": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz",
+ "integrity": "sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==",
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/caniuse-lite": {
+ "version": "1.0.30001756",
+ "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001756.tgz",
+ "integrity": "sha512-4HnCNKbMLkLdhJz3TToeVWHSnfJvPaq6vu/eRP0Ahub/07n484XHhBF5AJoSGHdVrS8tKFauUQz8Bp9P7LVx7A==",
+ "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"
+ }
+ ]
+ },
+ "node_modules/chokidar": {
+ "version": "3.6.0",
+ "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
+ "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+ "dependencies": {
+ "anymatch": "~3.1.2",
+ "braces": "~3.0.2",
+ "glob-parent": "~5.1.2",
+ "is-binary-path": "~2.1.0",
+ "is-glob": "~4.0.1",
+ "normalize-path": "~3.0.0",
+ "readdirp": "~3.6.0"
+ },
+ "engines": {
+ "node": ">= 8.10.0"
+ },
+ "funding": {
+ "url": "https://paulmillr.com/funding/"
+ },
+ "optionalDependencies": {
+ "fsevents": "~2.3.2"
+ }
+ },
+ "node_modules/chokidar/node_modules/glob-parent": {
+ "version": "5.1.2",
+ "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+ "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+ "dependencies": {
+ "is-glob": "^4.0.1"
+ },
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/class-variance-authority": {
+ "version": "0.7.1",
+ "resolved": "https://registry.npmjs.org/class-variance-authority/-/class-variance-authority-0.7.1.tgz",
+ "integrity": "sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg==",
+ "dependencies": {
+ "clsx": "^2.1.1"
+ },
+ "funding": {
+ "url": "https://polar.sh/cva"
+ }
+ },
+ "node_modules/clsx": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
+ "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "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==",
+ "dependencies": {
+ "delayed-stream": "~1.0.0"
+ },
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/commander": {
+ "version": "4.1.1",
+ "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz",
+ "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==",
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/convert-source-map": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+ "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+ "dev": true
+ },
+ "node_modules/cssesc": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
+ "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==",
+ "bin": {
+ "cssesc": "bin/cssesc"
+ },
+ "engines": {
+ "node": ">=4"
+ }
+ },
+ "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
+ },
+ "node_modules/debug": {
+ "version": "4.4.3",
+ "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+ "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+ "dev": true,
+ "dependencies": {
+ "ms": "^2.1.3"
+ },
+ "engines": {
+ "node": ">=6.0"
+ },
+ "peerDependenciesMeta": {
+ "supports-color": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/delayed-stream": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+ "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+ "engines": {
+ "node": ">=0.4.0"
+ }
+ },
+ "node_modules/detect-node-es": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/detect-node-es/-/detect-node-es-1.1.0.tgz",
+ "integrity": "sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ=="
+ },
+ "node_modules/didyoumean": {
+ "version": "1.2.2",
+ "resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz",
+ "integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw=="
+ },
+ "node_modules/dlv": {
+ "version": "1.1.3",
+ "resolved": "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz",
+ "integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA=="
+ },
+ "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==",
+ "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.257",
+ "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.257.tgz",
+ "integrity": "sha512-VNSOB6JZan5IQNMqaurYpZC4bDPXcvKlUwVD/ztMeVD7SwOpMYGOY7dgt+4lNiIHIpvv/FdULnZKqKEy2KcuHQ==",
+ "dev": true
+ },
+ "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==",
+ "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==",
+ "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==",
+ "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==",
+ "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/esbuild": {
+ "version": "0.25.12",
+ "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.25.12.tgz",
+ "integrity": "sha512-bbPBYYrtZbkt6Os6FiTLCTFxvq4tt3JKall1vRwshA3fdVztsLAatFaZobhkBC8/BrPetoa0oksYoKXoG4ryJg==",
+ "dev": true,
+ "hasInstallScript": true,
+ "bin": {
+ "esbuild": "bin/esbuild"
+ },
+ "engines": {
+ "node": ">=18"
+ },
+ "optionalDependencies": {
+ "@esbuild/aix-ppc64": "0.25.12",
+ "@esbuild/android-arm": "0.25.12",
+ "@esbuild/android-arm64": "0.25.12",
+ "@esbuild/android-x64": "0.25.12",
+ "@esbuild/darwin-arm64": "0.25.12",
+ "@esbuild/darwin-x64": "0.25.12",
+ "@esbuild/freebsd-arm64": "0.25.12",
+ "@esbuild/freebsd-x64": "0.25.12",
+ "@esbuild/linux-arm": "0.25.12",
+ "@esbuild/linux-arm64": "0.25.12",
+ "@esbuild/linux-ia32": "0.25.12",
+ "@esbuild/linux-loong64": "0.25.12",
+ "@esbuild/linux-mips64el": "0.25.12",
+ "@esbuild/linux-ppc64": "0.25.12",
+ "@esbuild/linux-riscv64": "0.25.12",
+ "@esbuild/linux-s390x": "0.25.12",
+ "@esbuild/linux-x64": "0.25.12",
+ "@esbuild/netbsd-arm64": "0.25.12",
+ "@esbuild/netbsd-x64": "0.25.12",
+ "@esbuild/openbsd-arm64": "0.25.12",
+ "@esbuild/openbsd-x64": "0.25.12",
+ "@esbuild/openharmony-arm64": "0.25.12",
+ "@esbuild/sunos-x64": "0.25.12",
+ "@esbuild/win32-arm64": "0.25.12",
+ "@esbuild/win32-ia32": "0.25.12",
+ "@esbuild/win32-x64": "0.25.12"
+ }
+ },
+ "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,
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/fast-glob": {
+ "version": "3.3.3",
+ "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
+ "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
+ "dependencies": {
+ "@nodelib/fs.stat": "^2.0.2",
+ "@nodelib/fs.walk": "^1.2.3",
+ "glob-parent": "^5.1.2",
+ "merge2": "^1.3.0",
+ "micromatch": "^4.0.8"
+ },
+ "engines": {
+ "node": ">=8.6.0"
+ }
+ },
+ "node_modules/fast-glob/node_modules/glob-parent": {
+ "version": "5.1.2",
+ "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+ "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+ "dependencies": {
+ "is-glob": "^4.0.1"
+ },
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/fastq": {
+ "version": "1.19.1",
+ "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.19.1.tgz",
+ "integrity": "sha512-GwLTyxkCXjXbxqIhTsMI2Nui8huMPtnxg7krajPJAjnEG/iiOS7i+zCtWGZR9G0NBKbXKh6X9m9UIsYX/N6vvQ==",
+ "dependencies": {
+ "reusify": "^1.0.4"
+ }
+ },
+ "node_modules/fill-range": {
+ "version": "7.1.1",
+ "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+ "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+ "dependencies": {
+ "to-regex-range": "^5.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "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"
+ }
+ ],
+ "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==",
+ "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==",
+ "hasInstallScript": true,
+ "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==",
+ "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,
+ "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==",
+ "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-nonce": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/get-nonce/-/get-nonce-1.0.1.tgz",
+ "integrity": "sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q==",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "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==",
+ "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==",
+ "dependencies": {
+ "is-glob": "^4.0.3"
+ },
+ "engines": {
+ "node": ">=10.13.0"
+ }
+ },
+ "node_modules/gopd": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+ "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/has-symbols": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+ "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+ "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==",
+ "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==",
+ "dependencies": {
+ "function-bind": "^1.1.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/is-binary-path": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+ "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+ "dependencies": {
+ "binary-extensions": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/is-core-module": {
+ "version": "2.16.1",
+ "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz",
+ "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
+ "dependencies": {
+ "hasown": "^2.0.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/is-extglob": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+ "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+ "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==",
+ "dependencies": {
+ "is-extglob": "^2.1.1"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/is-number": {
+ "version": "7.0.0",
+ "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+ "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+ "engines": {
+ "node": ">=0.12.0"
+ }
+ },
+ "node_modules/jiti": {
+ "version": "1.21.7",
+ "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
+ "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==",
+ "bin": {
+ "jiti": "bin/jiti.js"
+ }
+ },
+ "node_modules/js-tokens": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+ "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="
+ },
+ "node_modules/jsesc": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+ "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+ "dev": true,
+ "bin": {
+ "jsesc": "bin/jsesc"
+ },
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "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,
+ "bin": {
+ "json5": "lib/cli.js"
+ },
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/lilconfig": {
+ "version": "3.1.3",
+ "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
+ "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==",
+ "engines": {
+ "node": ">=14"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/antonk52"
+ }
+ },
+ "node_modules/lines-and-columns": {
+ "version": "1.2.4",
+ "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
+ "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg=="
+ },
+ "node_modules/loose-envify": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+ "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+ "dependencies": {
+ "js-tokens": "^3.0.0 || ^4.0.0"
+ },
+ "bin": {
+ "loose-envify": "cli.js"
+ }
+ },
+ "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,
+ "dependencies": {
+ "yallist": "^3.0.2"
+ }
+ },
+ "node_modules/lucide-react": {
+ "version": "0.292.0",
+ "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.292.0.tgz",
+ "integrity": "sha512-rRgUkpEHWpa5VCT66YscInCQmQuPCB1RFRzkkxMxg4b+jaL0V12E3riWWR2Sh5OIiUhCwGW/ZExuEO4Az32E6Q==",
+ "peerDependencies": {
+ "react": "^16.5.1 || ^17.0.0 || ^18.0.0"
+ }
+ },
+ "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==",
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/merge2": {
+ "version": "1.4.1",
+ "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
+ "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/micromatch": {
+ "version": "4.0.8",
+ "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+ "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
+ "dependencies": {
+ "braces": "^3.0.3",
+ "picomatch": "^2.3.1"
+ },
+ "engines": {
+ "node": ">=8.6"
+ }
+ },
+ "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==",
+ "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==",
+ "dependencies": {
+ "mime-db": "1.52.0"
+ },
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "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
+ },
+ "node_modules/mz": {
+ "version": "2.7.0",
+ "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz",
+ "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==",
+ "dependencies": {
+ "any-promise": "^1.0.0",
+ "object-assign": "^4.0.1",
+ "thenify-all": "^1.0.0"
+ }
+ },
+ "node_modules/nanoid": {
+ "version": "3.3.11",
+ "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+ "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "bin": {
+ "nanoid": "bin/nanoid.cjs"
+ },
+ "engines": {
+ "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+ }
+ },
+ "node_modules/node-releases": {
+ "version": "2.0.27",
+ "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz",
+ "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==",
+ "dev": true
+ },
+ "node_modules/normalize-path": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+ "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/object-assign": {
+ "version": "4.1.1",
+ "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+ "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/object-hash": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz",
+ "integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==",
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/path-parse": {
+ "version": "1.0.7",
+ "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+ "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="
+ },
+ "node_modules/picocolors": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+ "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="
+ },
+ "node_modules/picomatch": {
+ "version": "2.3.1",
+ "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz",
+ "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==",
+ "engines": {
+ "node": ">=8.6"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/jonschlinkert"
+ }
+ },
+ "node_modules/pify": {
+ "version": "2.3.0",
+ "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
+ "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/pirates": {
+ "version": "4.0.7",
+ "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz",
+ "integrity": "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==",
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/postcss": {
+ "version": "8.5.6",
+ "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.6.tgz",
+ "integrity": "sha512-3Ybi1tAuwAP9s0r1UQ2J4n5Y0G05bJkpUIO0/bI9MhwmD70S5aTWbXGBwxHrelT+XM1k6dM0pk+SwNkpTRN7Pg==",
+ "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"
+ }
+ ],
+ "dependencies": {
+ "nanoid": "^3.3.11",
+ "picocolors": "^1.1.1",
+ "source-map-js": "^1.2.1"
+ },
+ "engines": {
+ "node": "^10 || ^12 || >=14"
+ }
+ },
+ "node_modules/postcss-import": {
+ "version": "15.1.0",
+ "resolved": "https://registry.npmjs.org/postcss-import/-/postcss-import-15.1.0.tgz",
+ "integrity": "sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==",
+ "dependencies": {
+ "postcss-value-parser": "^4.0.0",
+ "read-cache": "^1.0.0",
+ "resolve": "^1.1.7"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "peerDependencies": {
+ "postcss": "^8.0.0"
+ }
+ },
+ "node_modules/postcss-js": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.1.0.tgz",
+ "integrity": "sha512-oIAOTqgIo7q2EOwbhb8UalYePMvYoIeRY2YKntdpFQXNosSu3vLrniGgmH9OKs/qAkfoj5oB3le/7mINW1LCfw==",
+ "funding": [
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/postcss/"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "dependencies": {
+ "camelcase-css": "^2.0.1"
+ },
+ "engines": {
+ "node": "^12 || ^14 || >= 16"
+ },
+ "peerDependencies": {
+ "postcss": "^8.4.21"
+ }
+ },
+ "node_modules/postcss-load-config": {
+ "version": "6.0.1",
+ "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-6.0.1.tgz",
+ "integrity": "sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==",
+ "funding": [
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/postcss/"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "dependencies": {
+ "lilconfig": "^3.1.1"
+ },
+ "engines": {
+ "node": ">= 18"
+ },
+ "peerDependencies": {
+ "jiti": ">=1.21.0",
+ "postcss": ">=8.0.9",
+ "tsx": "^4.8.1",
+ "yaml": "^2.4.2"
+ },
+ "peerDependenciesMeta": {
+ "jiti": {
+ "optional": true
+ },
+ "postcss": {
+ "optional": true
+ },
+ "tsx": {
+ "optional": true
+ },
+ "yaml": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/postcss-nested": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.2.0.tgz",
+ "integrity": "sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==",
+ "funding": [
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/postcss/"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "dependencies": {
+ "postcss-selector-parser": "^6.1.1"
+ },
+ "engines": {
+ "node": ">=12.0"
+ },
+ "peerDependencies": {
+ "postcss": "^8.2.14"
+ }
+ },
+ "node_modules/postcss-selector-parser": {
+ "version": "6.1.2",
+ "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
+ "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+ "dependencies": {
+ "cssesc": "^3.0.0",
+ "util-deprecate": "^1.0.2"
+ },
+ "engines": {
+ "node": ">=4"
+ }
+ },
+ "node_modules/postcss-value-parser": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
+ "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ=="
+ },
+ "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=="
+ },
+ "node_modules/queue-microtask": {
+ "version": "1.2.3",
+ "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
+ "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ]
+ },
+ "node_modules/react": {
+ "version": "18.3.1",
+ "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
+ "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
+ "dependencies": {
+ "loose-envify": "^1.1.0"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/react-dom": {
+ "version": "18.3.1",
+ "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
+ "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
+ "dependencies": {
+ "loose-envify": "^1.1.0",
+ "scheduler": "^0.23.2"
+ },
+ "peerDependencies": {
+ "react": "^18.3.1"
+ }
+ },
+ "node_modules/react-refresh": {
+ "version": "0.17.0",
+ "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",
+ "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==",
+ "dev": true,
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/react-remove-scroll": {
+ "version": "2.7.1",
+ "resolved": "https://registry.npmjs.org/react-remove-scroll/-/react-remove-scroll-2.7.1.tgz",
+ "integrity": "sha512-HpMh8+oahmIdOuS5aFKKY6Pyog+FNaZV/XyJOq7b4YFwsFHe5yYfdbIalI4k3vU2nSDql7YskmUseHsRrJqIPA==",
+ "dependencies": {
+ "react-remove-scroll-bar": "^2.3.7",
+ "react-style-singleton": "^2.2.3",
+ "tslib": "^2.1.0",
+ "use-callback-ref": "^1.3.3",
+ "use-sidecar": "^1.1.3"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/react-remove-scroll-bar": {
+ "version": "2.3.8",
+ "resolved": "https://registry.npmjs.org/react-remove-scroll-bar/-/react-remove-scroll-bar-2.3.8.tgz",
+ "integrity": "sha512-9r+yi9+mgU33AKcj6IbT9oRCO78WriSj6t/cF8DWBZJ9aOGPOTEDvdUDz1FwKim7QXWwmHqtdHnRJfhAxEG46Q==",
+ "dependencies": {
+ "react-style-singleton": "^2.2.2",
+ "tslib": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/react-router": {
+ "version": "6.30.2",
+ "resolved": "https://registry.npmjs.org/react-router/-/react-router-6.30.2.tgz",
+ "integrity": "sha512-H2Bm38Zu1bm8KUE5NVWRMzuIyAV8p/JrOaBJAwVmp37AXG72+CZJlEBw6pdn9i5TBgLMhNDgijS4ZlblpHyWTA==",
+ "dependencies": {
+ "@remix-run/router": "1.23.1"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "peerDependencies": {
+ "react": ">=16.8"
+ }
+ },
+ "node_modules/react-router-dom": {
+ "version": "6.30.2",
+ "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-6.30.2.tgz",
+ "integrity": "sha512-l2OwHn3UUnEVUqc6/1VMmR1cvZryZ3j3NzapC2eUXO1dB0sYp5mvwdjiXhpUbRb21eFow3qSxpP8Yv6oAU824Q==",
+ "dependencies": {
+ "@remix-run/router": "1.23.1",
+ "react-router": "6.30.2"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "peerDependencies": {
+ "react": ">=16.8",
+ "react-dom": ">=16.8"
+ }
+ },
+ "node_modules/react-style-singleton": {
+ "version": "2.2.3",
+ "resolved": "https://registry.npmjs.org/react-style-singleton/-/react-style-singleton-2.2.3.tgz",
+ "integrity": "sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ==",
+ "dependencies": {
+ "get-nonce": "^1.0.0",
+ "tslib": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/read-cache": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz",
+ "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==",
+ "dependencies": {
+ "pify": "^2.3.0"
+ }
+ },
+ "node_modules/readdirp": {
+ "version": "3.6.0",
+ "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+ "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+ "dependencies": {
+ "picomatch": "^2.2.1"
+ },
+ "engines": {
+ "node": ">=8.10.0"
+ }
+ },
+ "node_modules/resolve": {
+ "version": "1.22.11",
+ "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz",
+ "integrity": "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==",
+ "dependencies": {
+ "is-core-module": "^2.16.1",
+ "path-parse": "^1.0.7",
+ "supports-preserve-symlinks-flag": "^1.0.0"
+ },
+ "bin": {
+ "resolve": "bin/resolve"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/reusify": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
+ "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
+ "engines": {
+ "iojs": ">=1.0.0",
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/rollup": {
+ "version": "4.53.3",
+ "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.53.3.tgz",
+ "integrity": "sha512-w8GmOxZfBmKknvdXU1sdM9NHcoQejwF/4mNgj2JuEEdRaHwwF12K7e9eXn1nLZ07ad+du76mkVsyeb2rKGllsA==",
+ "dev": true,
+ "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.53.3",
+ "@rollup/rollup-android-arm64": "4.53.3",
+ "@rollup/rollup-darwin-arm64": "4.53.3",
+ "@rollup/rollup-darwin-x64": "4.53.3",
+ "@rollup/rollup-freebsd-arm64": "4.53.3",
+ "@rollup/rollup-freebsd-x64": "4.53.3",
+ "@rollup/rollup-linux-arm-gnueabihf": "4.53.3",
+ "@rollup/rollup-linux-arm-musleabihf": "4.53.3",
+ "@rollup/rollup-linux-arm64-gnu": "4.53.3",
+ "@rollup/rollup-linux-arm64-musl": "4.53.3",
+ "@rollup/rollup-linux-loong64-gnu": "4.53.3",
+ "@rollup/rollup-linux-ppc64-gnu": "4.53.3",
+ "@rollup/rollup-linux-riscv64-gnu": "4.53.3",
+ "@rollup/rollup-linux-riscv64-musl": "4.53.3",
+ "@rollup/rollup-linux-s390x-gnu": "4.53.3",
+ "@rollup/rollup-linux-x64-gnu": "4.53.3",
+ "@rollup/rollup-linux-x64-musl": "4.53.3",
+ "@rollup/rollup-openharmony-arm64": "4.53.3",
+ "@rollup/rollup-win32-arm64-msvc": "4.53.3",
+ "@rollup/rollup-win32-ia32-msvc": "4.53.3",
+ "@rollup/rollup-win32-x64-gnu": "4.53.3",
+ "@rollup/rollup-win32-x64-msvc": "4.53.3",
+ "fsevents": "~2.3.2"
+ }
+ },
+ "node_modules/run-parallel": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
+ "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ],
+ "dependencies": {
+ "queue-microtask": "^1.2.2"
+ }
+ },
+ "node_modules/scheduler": {
+ "version": "0.23.2",
+ "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
+ "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
+ "dependencies": {
+ "loose-envify": "^1.1.0"
+ }
+ },
+ "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,
+ "bin": {
+ "semver": "bin/semver.js"
+ }
+ },
+ "node_modules/sonner": {
+ "version": "1.7.4",
+ "resolved": "https://registry.npmjs.org/sonner/-/sonner-1.7.4.tgz",
+ "integrity": "sha512-DIS8z4PfJRbIyfVFDVnK9rO3eYDtse4Omcm6bt0oEr5/jtLgysmjuBl1frJ9E/EQZrFmKx2A8m/s5s9CRXIzhw==",
+ "peerDependencies": {
+ "react": "^18.0.0 || ^19.0.0 || ^19.0.0-rc",
+ "react-dom": "^18.0.0 || ^19.0.0 || ^19.0.0-rc"
+ }
+ },
+ "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==",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/sucrase": {
+ "version": "3.35.1",
+ "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.1.tgz",
+ "integrity": "sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw==",
+ "dependencies": {
+ "@jridgewell/gen-mapping": "^0.3.2",
+ "commander": "^4.0.0",
+ "lines-and-columns": "^1.1.6",
+ "mz": "^2.7.0",
+ "pirates": "^4.0.1",
+ "tinyglobby": "^0.2.11",
+ "ts-interface-checker": "^0.1.9"
+ },
+ "bin": {
+ "sucrase": "bin/sucrase",
+ "sucrase-node": "bin/sucrase-node"
+ },
+ "engines": {
+ "node": ">=16 || 14 >=14.17"
+ }
+ },
+ "node_modules/supports-preserve-symlinks-flag": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+ "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/tailwind-merge": {
+ "version": "3.4.0",
+ "resolved": "https://registry.npmjs.org/tailwind-merge/-/tailwind-merge-3.4.0.tgz",
+ "integrity": "sha512-uSaO4gnW+b3Y2aWoWfFpX62vn2sR3skfhbjsEnaBI81WD1wBLlHZe5sWf0AqjksNdYTbGBEd0UasQMT3SNV15g==",
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/dcastil"
+ }
+ },
+ "node_modules/tailwindcss": {
+ "version": "3.4.18",
+ "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.18.tgz",
+ "integrity": "sha512-6A2rnmW5xZMdw11LYjhcI5846rt9pbLSabY5XPxo+XWdxwZaFEn47Go4NzFiHu9sNNmr/kXivP1vStfvMaK1GQ==",
+ "dependencies": {
+ "@alloc/quick-lru": "^5.2.0",
+ "arg": "^5.0.2",
+ "chokidar": "^3.6.0",
+ "didyoumean": "^1.2.2",
+ "dlv": "^1.1.3",
+ "fast-glob": "^3.3.2",
+ "glob-parent": "^6.0.2",
+ "is-glob": "^4.0.3",
+ "jiti": "^1.21.7",
+ "lilconfig": "^3.1.3",
+ "micromatch": "^4.0.8",
+ "normalize-path": "^3.0.0",
+ "object-hash": "^3.0.0",
+ "picocolors": "^1.1.1",
+ "postcss": "^8.4.47",
+ "postcss-import": "^15.1.0",
+ "postcss-js": "^4.0.1",
+ "postcss-load-config": "^4.0.2 || ^5.0 || ^6.0",
+ "postcss-nested": "^6.2.0",
+ "postcss-selector-parser": "^6.1.2",
+ "resolve": "^1.22.8",
+ "sucrase": "^3.35.0"
+ },
+ "bin": {
+ "tailwind": "lib/cli.js",
+ "tailwindcss": "lib/cli.js"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ }
+ },
+ "node_modules/tailwindcss-animate": {
+ "version": "1.0.7",
+ "resolved": "https://registry.npmjs.org/tailwindcss-animate/-/tailwindcss-animate-1.0.7.tgz",
+ "integrity": "sha512-bl6mpH3T7I3UFxuvDEXLxy/VuFxBk5bbzplh7tXI68mwMokNYd1t9qPBHlnyTwfa4JGC4zP516I1hYYtQ/vspA==",
+ "peerDependencies": {
+ "tailwindcss": ">=3.0.0 || insiders"
+ }
+ },
+ "node_modules/thenify": {
+ "version": "3.3.1",
+ "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz",
+ "integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==",
+ "dependencies": {
+ "any-promise": "^1.0.0"
+ }
+ },
+ "node_modules/thenify-all": {
+ "version": "1.6.0",
+ "resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz",
+ "integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==",
+ "dependencies": {
+ "thenify": ">= 3.1.0 < 4"
+ },
+ "engines": {
+ "node": ">=0.8"
+ }
+ },
+ "node_modules/tinyglobby": {
+ "version": "0.2.15",
+ "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+ "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+ "dependencies": {
+ "fdir": "^6.5.0",
+ "picomatch": "^4.0.3"
+ },
+ "engines": {
+ "node": ">=12.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/SuperchupuDev"
+ }
+ },
+ "node_modules/tinyglobby/node_modules/fdir": {
+ "version": "6.5.0",
+ "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+ "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+ "engines": {
+ "node": ">=12.0.0"
+ },
+ "peerDependencies": {
+ "picomatch": "^3 || ^4"
+ },
+ "peerDependenciesMeta": {
+ "picomatch": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/tinyglobby/node_modules/picomatch": {
+ "version": "4.0.3",
+ "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+ "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+ "engines": {
+ "node": ">=12"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/jonschlinkert"
+ }
+ },
+ "node_modules/to-regex-range": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+ "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+ "dependencies": {
+ "is-number": "^7.0.0"
+ },
+ "engines": {
+ "node": ">=8.0"
+ }
+ },
+ "node_modules/ts-interface-checker": {
+ "version": "0.1.13",
+ "resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz",
+ "integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA=="
+ },
+ "node_modules/tslib": {
+ "version": "2.8.1",
+ "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+ "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="
+ },
+ "node_modules/update-browserslist-db": {
+ "version": "1.1.4",
+ "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.4.tgz",
+ "integrity": "sha512-q0SPT4xyU84saUX+tomz1WLkxUbuaJnR1xWt17M7fJtEJigJeWUNGUqrauFXsHnqev9y9JTRGwk13tFBuKby4A==",
+ "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"
+ }
+ ],
+ "dependencies": {
+ "escalade": "^3.2.0",
+ "picocolors": "^1.1.1"
+ },
+ "bin": {
+ "update-browserslist-db": "cli.js"
+ },
+ "peerDependencies": {
+ "browserslist": ">= 4.21.0"
+ }
+ },
+ "node_modules/use-callback-ref": {
+ "version": "1.3.3",
+ "resolved": "https://registry.npmjs.org/use-callback-ref/-/use-callback-ref-1.3.3.tgz",
+ "integrity": "sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg==",
+ "dependencies": {
+ "tslib": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/use-sidecar": {
+ "version": "1.1.3",
+ "resolved": "https://registry.npmjs.org/use-sidecar/-/use-sidecar-1.1.3.tgz",
+ "integrity": "sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ==",
+ "dependencies": {
+ "detect-node-es": "^1.1.0",
+ "tslib": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "peerDependencies": {
+ "@types/react": "*",
+ "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/util-deprecate": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+ "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="
+ },
+ "node_modules/vite": {
+ "version": "7.2.4",
+ "resolved": "https://registry.npmjs.org/vite/-/vite-7.2.4.tgz",
+ "integrity": "sha512-NL8jTlbo0Tn4dUEXEsUg8KeyG/Lkmc4Fnzb8JXN/Ykm9G4HNImjtABMJgkQoVjOBN/j2WAwDTRytdqJbZsah7w==",
+ "dev": true,
+ "dependencies": {
+ "esbuild": "^0.25.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/vite/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,
+ "engines": {
+ "node": ">=12.0.0"
+ },
+ "peerDependencies": {
+ "picomatch": "^3 || ^4"
+ },
+ "peerDependenciesMeta": {
+ "picomatch": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/vite/node_modules/picomatch": {
+ "version": "4.0.3",
+ "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+ "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+ "dev": true,
+ "engines": {
+ "node": ">=12"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/jonschlinkert"
+ }
+ },
+ "node_modules/yallist": {
+ "version": "3.1.1",
+ "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+ "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+ "dev": true
+ }
+ }
+}
diff --git a/frontend/package.json b/frontend/package.json
new file mode 100644
index 0000000..129bd64
--- /dev/null
+++ b/frontend/package.json
@@ -0,0 +1,37 @@
+{
+ "name": "pricecious-frontend",
+ "private": true,
+ "version": "0.1.0",
+ "type": "module",
+ "scripts": {
+ "dev": "vite",
+ "build": "vite build",
+ "preview": "vite preview"
+ },
+ "dependencies": {
+ "@radix-ui/react-dialog": "^1.1.15",
+ "@radix-ui/react-label": "^2.1.8",
+ "@radix-ui/react-select": "^2.2.6",
+ "@radix-ui/react-slot": "^1.2.4",
+ "@radix-ui/react-switch": "^1.2.6",
+ "axios": "^1.6.0",
+ "class-variance-authority": "^0.7.1",
+ "clsx": "^2.1.1",
+ "lucide-react": "^0.292.0",
+ "react": "^18.2.0",
+ "react-dom": "^18.2.0",
+ "react-router-dom": "^6.30.2",
+ "sonner": "^1.4.0",
+ "tailwind-merge": "^3.4.0",
+ "tailwindcss-animate": "^1.0.7"
+ },
+ "devDependencies": {
+ "@types/react": "^18.2.37",
+ "@types/react-dom": "^18.2.15",
+ "@vitejs/plugin-react": "^4.2.0",
+ "autoprefixer": "^10.4.16",
+ "postcss": "^8.4.31",
+ "tailwindcss": "^3.3.5",
+ "vite": "^7.2.4"
+ }
+}
\ No newline at end of file
diff --git a/frontend/postcss.config.js b/frontend/postcss.config.js
new file mode 100644
index 0000000..d41ad63
--- /dev/null
+++ b/frontend/postcss.config.js
@@ -0,0 +1,6 @@
+export default {
+ plugins: {
+ tailwindcss: {},
+ autoprefixer: {},
+ },
+}
diff --git a/frontend/public/apple-touch-icon.png b/frontend/public/apple-touch-icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..8aceb70fc400562cff173cdac3671d29222dab87
GIT binary patch
literal 40428
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 
+