before maj scrap

CHANGELOG.md

@@ -53,11 +53,14 @@ Le format est basé sur [Keep a Changelog](https://keepachangelog.com/fr/1.0.0/)
 - Web UI: popup ajout produit central + favicon
 - API: logs Uvicorn exposes pour l UI
 - Parsing prix: gestion des separateurs de milliers (espace, NBSP, point)
-- API/DB: description + msrp + images/specs exposes, reduction calculee
+- API/DB: exposition des champs Amazon enrichis (note, badge, stock texte, modele)
+- Web UI: carte produit analytique avec resume, historique plein format et actions compactes
+- Web UI: slider colonnes responsive + modal ajout produit scrollable avec footer sticky
 
 ### Corrigé
 - Migration Alembic: down_revision aligne sur 20260114_02
 - Amazon: extraction images via data-a-dynamic-image + filtrage logos
+- API: suppression du calcul automatique des reductions (valeurs explicites uniquement)
 
 ---
 

README.md

@@ -152,6 +152,8 @@ Guide de migration JSON -> DB: `MIGRATION_GUIDE.md`
 
 L'API est protegee par un token simple.
 
+Note: l endpoint `/products` expose des champs Amazon explicites (asin, note, badge Choix d Amazon, stock_text/in_stock, model_number/model_name, main_image/gallery_images). Les reductions ne sont plus calculees cote API.
+
 ```bash
 export PW_API_TOKEN=change_me
 docker compose up -d api

TODO.md

@@ -170,6 +170,7 @@ Liste des tâches priorisées pour le développement de PriceWatch.
 - [x] Tests performance (100+ produits)
 - [x] CRUD produits
 - [x] Historique prix
+- [ ] Ajouter migration DB pour les nouveaux champs Amazon (note, badge, stock texte, modele)
 
 ### Documentation
 - [x] Migration guide (JSON -> DB)

analytics-ui/app.py

@@ -76,6 +76,81 @@ def _serialize_decimal(value):
     return value
 
 
+def fetch_product_history(product_id: int) -> Tuple[List[Dict[str, Any]], Optional[str]]:
+    """Récupère l'historique complet des scraps pour un produit."""
+    rows: List[Dict[str, Any]] = []
+    try:
+        with get_db_connection() as conn:
+            with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                cur.execute(
+                    """
+                    SELECT
+                        ph.id,
+                        ph.price,
+                        ph.shipping_cost,
+                        ph.stock_status,
+                        ph.fetch_method,
+                        ph.fetch_status,
+                        ph.fetched_at
+                    FROM price_history ph
+                    WHERE ph.product_id = %s
+                    ORDER BY ph.fetched_at DESC
+                    """,
+                    (product_id,),
+                )
+                fetched = cur.fetchall()
+                for item in fetched:
+                    serialized = {key: _serialize_decimal(value) for key, value in item.items()}
+                    if serialized.get("fetched_at"):
+                        serialized["fetched_at"] = serialized["fetched_at"].strftime(
+                            "%Y-%m-%d %H:%M:%S"
+                        )
+                    rows.append(serialized)
+        return rows, None
+    except Exception as exc:
+        return rows, str(exc)
+
+
+def fetch_all_price_history(limit: int = 500) -> Tuple[List[Dict[str, Any]], Optional[str]]:
+    """Récupère toutes les entrées de price_history avec infos produit."""
+    rows: List[Dict[str, Any]] = []
+    try:
+        with get_db_connection() as conn:
+            with conn.cursor(cursor_factory=RealDictCursor) as cur:
+                cur.execute(
+                    """
+                    SELECT
+                        ph.id,
+                        ph.product_id,
+                        p.source,
+                        p.reference,
+                        p.title,
+                        ph.price,
+                        ph.shipping_cost,
+                        ph.stock_status,
+                        ph.fetch_method,
+                        ph.fetch_status,
+                        ph.fetched_at
+                    FROM price_history ph
+                    LEFT JOIN products p ON p.id = ph.product_id
+                    ORDER BY ph.fetched_at DESC
+                    LIMIT %s
+                    """,
+                    (limit,),
+                )
+                fetched = cur.fetchall()
+                for item in fetched:
+                    serialized = {key: _serialize_decimal(value) for key, value in item.items()}
+                    if serialized.get("fetched_at"):
+                        serialized["fetched_at"] = serialized["fetched_at"].strftime(
+                            "%Y-%m-%d %H:%M:%S"
+                        )
+                    rows.append(serialized)
+        return rows, None
+    except Exception as exc:
+        return rows, str(exc)
+
+
 def fetch_products_list(limit: int = 200) -> Tuple[List[Dict[str, Any]], Optional[str]]:
     rows: List[Dict[str, Any]] = []
     try:
@@ -260,6 +335,68 @@ TEMPLATE = """
         </dl>
       </div>
     </section>
+    <section>
+      <h2>Historique complet des scraps</h2>
+      <div class="browser-panel">
+        <div class="browser-controls">
+          <button id="load-history">Charger l'historique du produit sélectionné</button>
+          <span class="muted" id="history-message"></span>
+        </div>
+        <div class="history-table-container" style="max-height: 400px; overflow-y: auto; margin-top: 12px;">
+          <table id="history-table">
+            <thead>
+              <tr>
+                <th>Date</th>
+                <th>Prix</th>
+                <th>Frais port</th>
+                <th>Stock</th>
+                <th>Méthode</th>
+                <th>Statut</th>
+              </tr>
+            </thead>
+            <tbody id="history-body">
+              <tr><td colspan="6" class="muted">Sélectionnez un produit puis cliquez sur "Charger l'historique"</td></tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+    </section>
+    <section>
+      <h2>Parcourir la table price_history</h2>
+      <div class="browser-panel">
+        <div class="browser-controls">
+          <button id="load-price-history">Charger price_history</button>
+          <button id="ph-prev" disabled>Précédent</button>
+          <button id="ph-next" disabled>Suivant</button>
+          <strong class="browser-indicator" id="ph-indicator">0 / 0</strong>
+          <span class="muted" id="ph-message"></span>
+        </div>
+        <dl class="browser-display" id="ph-details">
+          <dt>ID</dt>
+          <dd id="ph-id">-</dd>
+          <dt>Product ID</dt>
+          <dd id="ph-product-id">-</dd>
+          <dt>Store</dt>
+          <dd id="ph-source">-</dd>
+          <dt>Référence</dt>
+          <dd id="ph-reference">-</dd>
+          <dt>Titre produit</dt>
+          <dd id="ph-title">-</dd>
+          <dt>Prix</dt>
+          <dd id="ph-price">-</dd>
+          <dt>Frais de port</dt>
+          <dd id="ph-shipping">-</dd>
+          <dt>Stock</dt>
+          <dd id="ph-stock">-</dd>
+          <dt>Méthode</dt>
+          <dd id="ph-method">-</dd>
+          <dt>Statut</dt>
+          <dd id="ph-status">-</dd>
+          <dt>Date scraping</dt>
+          <dd id="ph-fetched-at">-</dd>
+        </dl>
+      </div>
+    </section>
   </main>
   <script>
     document.addEventListener("DOMContentLoaded", () => {
@@ -348,6 +485,177 @@ TEMPLATE = """
           renderProduct();
         }
       });
+
+      // Historique des scraps
+      const loadHistoryBtn = document.getElementById("load-history");
+      const historyMessage = document.getElementById("history-message");
+      const historyBody = document.getElementById("history-body");
+
+      const setHistoryStatus = (text) => {
+        historyMessage.textContent = text || "";
+      };
+
+      const formatStock = (status) => {
+        const stockMap = {
+          "in_stock": "✓ En stock",
+          "out_of_stock": "✗ Rupture",
+          "limited": "⚠ Limité",
+          "preorder": "⏳ Précommande",
+          "unknown": "? Inconnu"
+        };
+        return stockMap[status] || status || "-";
+      };
+
+      const formatMethod = (method) => {
+        return method === "playwright" ? "🎭 Playwright" : "📡 HTTP";
+      };
+
+      const formatStatus = (status) => {
+        const statusMap = {
+          "success": "✓ Succès",
+          "partial": "⚠ Partiel",
+          "failed": "✗ Échec"
+        };
+        return statusMap[status] || status || "-";
+      };
+
+      const renderHistory = (history) => {
+        if (!history.length) {
+          historyBody.innerHTML = '<tr><td colspan="6" class="muted">Aucun historique disponible pour ce produit.</td></tr>';
+          return;
+        }
+        historyBody.innerHTML = history.map(entry => `
+          <tr>
+            <td>${entry.fetched_at || "-"}</td>
+            <td>${entry.price !== null ? entry.price + " €" : "-"}</td>
+            <td>${entry.shipping_cost !== null ? entry.shipping_cost + " €" : "-"}</td>
+            <td>${formatStock(entry.stock_status)}</td>
+            <td>${formatMethod(entry.fetch_method)}</td>
+            <td>${formatStatus(entry.fetch_status)}</td>
+          </tr>
+        `).join("");
+      };
+
+      const fetchHistory = async () => {
+        if (!products.length) {
+          setHistoryStatus("Chargez d'abord les produits.");
+          return;
+        }
+        const current = products[cursor];
+        if (!current || !current.id) {
+          setHistoryStatus("Aucun produit sélectionné.");
+          return;
+        }
+        setHistoryStatus(`Chargement de l'historique pour le produit #${current.id}…`);
+        try {
+          const response = await fetch(`/product/${current.id}/history.json`);
+          if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+          }
+          const data = await response.json();
+          if (!Array.isArray(data)) {
+            throw new Error("Réponse invalide");
+          }
+          setHistoryStatus(`${data.length} entrée(s) pour "${(current.title || "Sans titre").slice(0, 30)}…"`);
+          renderHistory(data);
+        } catch (err) {
+          setHistoryStatus(`Erreur: ${err.message}`);
+          historyBody.innerHTML = '<tr><td colspan="6" class="muted">Erreur lors du chargement.</td></tr>';
+        }
+      };
+
+      loadHistoryBtn.addEventListener("click", fetchHistory);
+
+      // Parcourir price_history
+      const loadPhBtn = document.getElementById("load-price-history");
+      const phPrevBtn = document.getElementById("ph-prev");
+      const phNextBtn = document.getElementById("ph-next");
+      const phIndicator = document.getElementById("ph-indicator");
+      const phMessage = document.getElementById("ph-message");
+      let priceHistoryData = [];
+      let phCursor = 0;
+
+      const setPhStatus = (text) => {
+        phMessage.textContent = text || "";
+      };
+
+      const renderPriceHistory = () => {
+        const els = {
+          id: document.getElementById("ph-id"),
+          productId: document.getElementById("ph-product-id"),
+          source: document.getElementById("ph-source"),
+          reference: document.getElementById("ph-reference"),
+          title: document.getElementById("ph-title"),
+          price: document.getElementById("ph-price"),
+          shipping: document.getElementById("ph-shipping"),
+          stock: document.getElementById("ph-stock"),
+          method: document.getElementById("ph-method"),
+          status: document.getElementById("ph-status"),
+          fetchedAt: document.getElementById("ph-fetched-at"),
+        };
+
+        if (!priceHistoryData.length) {
+          phIndicator.textContent = "0 / 0";
+          Object.values(els).forEach((el) => (el.textContent = "-"));
+          phPrevBtn.disabled = true;
+          phNextBtn.disabled = true;
+          return;
+        }
+
+        const current = priceHistoryData[phCursor];
+        phIndicator.textContent = `${phCursor + 1} / ${priceHistoryData.length}`;
+
+        els.id.textContent = current.id || "-";
+        els.productId.textContent = current.product_id || "-";
+        els.source.textContent = current.source || "-";
+        els.reference.textContent = current.reference || "-";
+        els.title.textContent = current.title ? (current.title.length > 60 ? current.title.slice(0, 60) + "…" : current.title) : "-";
+        els.price.textContent = current.price !== null ? current.price + " €" : "-";
+        els.shipping.textContent = current.shipping_cost !== null ? current.shipping_cost + " €" : "-";
+        els.stock.textContent = formatStock(current.stock_status);
+        els.method.textContent = formatMethod(current.fetch_method);
+        els.status.textContent = formatStatus(current.fetch_status);
+        els.fetchedAt.textContent = current.fetched_at || "-";
+
+        phPrevBtn.disabled = phCursor === 0;
+        phNextBtn.disabled = phCursor >= priceHistoryData.length - 1;
+      };
+
+      const fetchPriceHistory = async () => {
+        setPhStatus("Chargement…");
+        try {
+          const response = await fetch("/price_history.json");
+          if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+          }
+          const data = await response.json();
+          if (!Array.isArray(data)) {
+            throw new Error("Réponse invalide");
+          }
+          priceHistoryData = data;
+          phCursor = 0;
+          setPhStatus(`Chargé ${priceHistoryData.length} entrée(s)`);
+          renderPriceHistory();
+        } catch (err) {
+          setPhStatus(`Erreur: ${err.message}`);
+          priceHistoryData = [];
+          renderPriceHistory();
+        }
+      };
+
+      loadPhBtn.addEventListener("click", fetchPriceHistory);
+      phPrevBtn.addEventListener("click", () => {
+        if (phCursor > 0) {
+          phCursor -= 1;
+          renderPriceHistory();
+        }
+      });
+      phNextBtn.addEventListener("click", () => {
+        if (phCursor + 1 < priceHistoryData.length) {
+          phCursor += 1;
+          renderPriceHistory();
+        }
+      });
     });
   </script>
 </body>
@@ -377,5 +685,21 @@ def products_json():
     return jsonify(products)
 
 
+@app.route("/product/<int:product_id>/history.json")
+def product_history_json(product_id: int):
+    history, error = fetch_product_history(product_id)
+    if error:
+        return jsonify({"error": error}), 500
+    return jsonify(history)
+
+
+@app.route("/price_history.json")
+def all_price_history_json():
+    history, error = fetch_all_price_history()
+    if error:
+        return jsonify({"error": error}), 500
+    return jsonify(history)
+
+
 if __name__ == "__main__":
     app.run(host="0.0.0.0", port=80)

docker-compose.yml

@@ -33,6 +33,19 @@ services:
     depends_on:
       - postgres
       - redis
+  
+  worker:
+    build: .
+    command: python -m pricewatch.app.cli.main worker
+    env_file:
+      - .env
+    environment:
+      PW_DB_HOST: postgres
+      PW_REDIS_HOST: redis
+      TZ: Europe/Paris
+    depends_on:
+      - postgres
+      - redis
 
   frontend:
     build: ./webui
@@ -75,6 +88,23 @@ services:
     depends_on:
       - postgres
 
+  pgadmin:
+    image: dpage/pgadmin4:latest
+    ports:
+      - "8072:80"
+    environment:
+      TZ: Europe/Paris
+      PGADMIN_DEFAULT_EMAIL: admin@pricewatch.dev
+      PGADMIN_DEFAULT_PASSWORD: pricewatch
+      PGADMIN_CONFIG_SERVER_MODE: "False"
+      PGADMIN_CONFIG_MASTER_PASSWORD_REQUIRED: "False"
+    volumes:
+      - pricewatch_pgadmin:/var/lib/pgadmin
+      - ./pgadmin-servers.json:/pgadmin4/servers.json:ro
+    depends_on:
+      - postgres
+
 volumes:
   pricewatch_pgdata:
   pricewatch_redisdata:
+  pricewatch_pgadmin:

pgadmin-servers.json

@@ -0,0 +1,14 @@
+{
+  "Servers": {
+    "1": {
+      "Name": "PriceWatch PostgreSQL",
+      "Group": "Servers",
+      "Host": "postgres",
+      "Port": 5432,
+      "MaintenanceDB": "pricewatch",
+      "Username": "pricewatch",
+      "PassFile": "/pgadmin4/pgpass",
+      "SSLMode": "prefer"
+    }
+  }
+}

pricewatch.egg-info/PKG-INFO

@@ -196,6 +196,8 @@ Guide de migration JSON -> DB: `MIGRATION_GUIDE.md`
 
 L'API est protegee par un token simple.
 
+Note: l endpoint `/products` expose des champs Amazon explicites (asin, note, badge Choix d Amazon, stock_text/in_stock, model_number/model_name, main_image/gallery_images). Les reductions ne sont plus calculees cote API.
+
 ```bash
 export PW_API_TOKEN=change_me
 docker compose up -d api
@@ -204,8 +206,54 @@ docker compose up -d api
 Exemples:
 
 ```bash
-curl -H "Authorization: Bearer $PW_API_TOKEN" http://localhost:8000/products
-curl http://localhost:8000/health
+curl -H "Authorization: Bearer $PW_API_TOKEN" http://localhost:8001/products
+curl http://localhost:8001/health
+```
+
+Filtres (exemples rapides):
+
+```bash
+curl -H "Authorization: Bearer $PW_API_TOKEN" \\
+  "http://localhost:8001/products?price_min=100&stock_status=in_stock"
+curl -H "Authorization: Bearer $PW_API_TOKEN" \\
+  "http://localhost:8001/products/1/prices?fetch_status=success&fetched_after=2026-01-14T00:00:00"
+curl -H "Authorization: Bearer $PW_API_TOKEN" \\
+  "http://localhost:8001/logs?fetch_status=failed&fetched_before=2026-01-15T00:00:00"
+```
+
+Exports (CSV/JSON):
+
+```bash
+curl -H "Authorization: Bearer $PW_API_TOKEN" \\
+  "http://localhost:8001/products/export?format=csv"
+curl -H "Authorization: Bearer $PW_API_TOKEN" \\
+  "http://localhost:8001/logs/export?format=json"
+```
+
+CRUD (examples rapides):
+
+```bash
+curl -H "Authorization: Bearer $PW_API_TOKEN" -X POST http://localhost:8001/products \\
+  -H "Content-Type: application/json" \\
+  -d '{"source":"amazon","reference":"REF1","url":"https://example.com"}'
+```
+
+Webhooks (exemples rapides):
+
+```bash
+curl -H "Authorization: Bearer $PW_API_TOKEN" -X POST http://localhost:8001/webhooks \\
+  -H "Content-Type: application/json" \\
+  -d '{"event":"price_changed","url":"https://example.com/webhook","enabled":true}'
+curl -H "Authorization: Bearer $PW_API_TOKEN" -X POST http://localhost:8001/webhooks/1/test
+```
+
+## Web UI (Phase 4)
+
+Interface Vue 3 dense avec themes Gruvbox/Monokai, header fixe, sidebar filtres, et split compare.
+
+```bash
+docker compose up -d frontend
+# Acces: http://localhost:3000
 ```
 
 ## Configuration (scrap_url.yaml)

pricewatch.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ pricewatch/app/scraping/pipeline.py
 pricewatch/app/scraping/pw_fetch.py
 pricewatch/app/stores/__init__.py
 pricewatch/app/stores/base.py
+pricewatch/app/stores/price_parser.py
 pricewatch/app/stores/amazon/__init__.py
 pricewatch/app/stores/amazon/store.py
 pricewatch/app/stores/cdiscount/__init__.py

pricewatch/app/api/main.py

@@ -22,6 +22,10 @@ from sqlalchemy.orm import Session
 
 from pricewatch.app.api.schemas import (
     BackendLogEntry,
+    ClassificationOptionsOut,
+    ClassificationRuleCreate,
+    ClassificationRuleOut,
+    ClassificationRuleUpdate,
     EnqueueRequest,
     EnqueueResponse,
     HealthStatus,
@@ -52,7 +56,8 @@ from pricewatch.app.core.config import get_config
 from pricewatch.app.core.logging import get_logger
 from pricewatch.app.core.schema import ProductSnapshot
 from pricewatch.app.db.connection import check_db_connection, get_session
-from pricewatch.app.db.models import PriceHistory, Product, ScrapingLog, Webhook
+from pricewatch.app.db.models import ClassificationRule, PriceHistory, Product, ScrapingLog, Webhook
+from pricewatch.app.db.repository import ProductRepository
 from pricewatch.app.scraping.pipeline import ScrapingPipeline
 from pricewatch.app.tasks.scrape import scrape_product
 from pricewatch.app.tasks.scheduler import RedisUnavailableError, check_redis_connection, ScrapingScheduler
@@ -188,6 +193,7 @@ def create_product(
         url=payload.url,
         title=payload.title,
         category=payload.category,
+        type=payload.type,
         description=payload.description,
         currency=payload.currency,
         msrp=payload.msrp,
@@ -241,6 +247,129 @@ def update_product(
     return _product_to_out(session, product)
 
 
+@app.get(
+    "/classification/rules",
+    response_model=list[ClassificationRuleOut],
+    dependencies=[Depends(require_token)],
+)
+def list_classification_rules(
+    session: Session = Depends(get_db_session),
+) -> list[ClassificationRuleOut]:
+    """Liste les regles de classification."""
+    rules = (
+        session.query(ClassificationRule)
+        .order_by(ClassificationRule.sort_order, ClassificationRule.id)
+        .all()
+    )
+    return [
+        ClassificationRuleOut(
+            id=rule.id,
+            category=rule.category,
+            type=rule.type,
+            keywords=rule.keywords or [],
+            sort_order=rule.sort_order,
+            is_active=rule.is_active,
+        )
+        for rule in rules
+    ]
+
+
+@app.post(
+    "/classification/rules",
+    response_model=ClassificationRuleOut,
+    dependencies=[Depends(require_token)],
+)
+def create_classification_rule(
+    payload: ClassificationRuleCreate,
+    session: Session = Depends(get_db_session),
+) -> ClassificationRuleOut:
+    """Cree une regle de classification."""
+    rule = ClassificationRule(
+        category=payload.category,
+        type=payload.type,
+        keywords=payload.keywords,
+        sort_order=payload.sort_order or 0,
+        is_active=True if payload.is_active is None else payload.is_active,
+    )
+    session.add(rule)
+    session.commit()
+    session.refresh(rule)
+    return ClassificationRuleOut(
+        id=rule.id,
+        category=rule.category,
+        type=rule.type,
+        keywords=rule.keywords or [],
+        sort_order=rule.sort_order,
+        is_active=rule.is_active,
+    )
+
+
+@app.patch(
+    "/classification/rules/{rule_id}",
+    response_model=ClassificationRuleOut,
+    dependencies=[Depends(require_token)],
+)
+def update_classification_rule(
+    rule_id: int,
+    payload: ClassificationRuleUpdate,
+    session: Session = Depends(get_db_session),
+) -> ClassificationRuleOut:
+    """Met a jour une regle de classification."""
+    rule = session.query(ClassificationRule).filter(ClassificationRule.id == rule_id).one_or_none()
+    if not rule:
+        raise HTTPException(status_code=404, detail="Regle non trouvee")
+    updates = payload.model_dump(exclude_unset=True)
+    for key, value in updates.items():
+        setattr(rule, key, value)
+    session.commit()
+    session.refresh(rule)
+    return ClassificationRuleOut(
+        id=rule.id,
+        category=rule.category,
+        type=rule.type,
+        keywords=rule.keywords or [],
+        sort_order=rule.sort_order,
+        is_active=rule.is_active,
+    )
+
+
+@app.delete(
+    "/classification/rules/{rule_id}",
+    dependencies=[Depends(require_token)],
+)
+def delete_classification_rule(
+    rule_id: int,
+    session: Session = Depends(get_db_session),
+) -> dict[str, str]:
+    """Supprime une regle de classification."""
+    rule = session.query(ClassificationRule).filter(ClassificationRule.id == rule_id).one_or_none()
+    if not rule:
+        raise HTTPException(status_code=404, detail="Regle non trouvee")
+    session.delete(rule)
+    session.commit()
+    return {"status": "deleted"}
+
+
+@app.get(
+    "/classification/options",
+    response_model=ClassificationOptionsOut,
+    dependencies=[Depends(require_token)],
+)
+def get_classification_options(
+    session: Session = Depends(get_db_session),
+) -> ClassificationOptionsOut:
+    """Expose la liste des categories et types issus des regles actives."""
+    rules = (
+        session.query(ClassificationRule)
+        .filter(ClassificationRule.is_active == True)
+        .order_by(ClassificationRule.sort_order, ClassificationRule.id)
+        .all()
+    )
+    categories = sorted({rule.category for rule in rules if rule.category})
+    types = sorted({rule.type for rule in rules if rule.type})
+    return ClassificationOptionsOut(categories=categories, types=types)
+
+
 @app.delete("/products/{product_id}", dependencies=[Depends(require_token)])
 def delete_product(
     product_id: int,
@@ -703,6 +832,13 @@ def preview_scrape(payload: ScrapePreviewRequest) -> ScrapePreviewResponse:
     if snapshot is None:
         _add_backend_log("ERROR", f"Preview scraping KO: {payload.url}")
         return ScrapePreviewResponse(success=False, snapshot=None, error=result.get("error"))
+    config = get_config()
+    if config.enable_db:
+        try:
+            with get_session(config) as session:
+                ProductRepository(session).apply_classification(snapshot)
+        except Exception as exc:
+            snapshot.add_note(f"Classification ignoree: {exc}")
     return ScrapePreviewResponse(
         success=bool(result.get("success")),
         snapshot=snapshot.model_dump(mode="json"),
@@ -719,7 +855,9 @@ def commit_scrape(payload: ScrapeCommitRequest) -> ScrapeCommitResponse:
         _add_backend_log("ERROR", "Commit scraping KO: snapshot invalide")
         raise HTTPException(status_code=400, detail="Snapshot invalide") from exc
 
-    product_id = ScrapingPipeline(config=get_config()).process_snapshot(snapshot, save_to_db=True)
+    product_id = ScrapingPipeline(config=get_config()).process_snapshot(
+        snapshot, save_to_db=True, apply_classification=False
+    )
     _add_backend_log("INFO", f"Commit scraping OK: product_id={product_id}")
     return ScrapeCommitResponse(success=True, product_id=product_id)
 
@@ -808,12 +946,9 @@ def _product_to_out(session: Session, product: Product) -> ProductOut:
     )
     images = [image.image_url for image in product.images]
     specs = {spec.spec_key: spec.spec_value for spec in product.specs}
-    discount_amount = None
-    discount_percent = None
-    if latest and latest.price is not None and product.msrp:
-        discount_amount = float(product.msrp) - float(latest.price)
-        if product.msrp > 0:
-            discount_percent = (discount_amount / float(product.msrp)) * 100
+    main_image = images[0] if images else None
+    gallery_images = images[1:] if len(images) > 1 else []
+    asin = product.reference if product.source == "amazon" else None
     history_rows = (
         session.query(PriceHistory)
         .filter(PriceHistory.product_id == product.id, PriceHistory.price != None)
@@ -830,12 +965,23 @@ def _product_to_out(session: Session, product: Product) -> ProductOut:
         id=product.id,
         source=product.source,
         reference=product.reference,
+        asin=asin,
         url=product.url,
         title=product.title,
         category=product.category,
+        type=product.type,
         description=product.description,
         currency=product.currency,
         msrp=float(product.msrp) if product.msrp is not None else None,
+        rating_value=float(product.rating_value) if product.rating_value is not None else None,
+        rating_count=product.rating_count,
+        amazon_choice=product.amazon_choice,
+        amazon_choice_label=product.amazon_choice_label,
+        discount_text=product.discount_text,
+        stock_text=product.stock_text,
+        in_stock=product.in_stock,
+        model_number=product.model_number,
+        model_name=product.model_name,
         first_seen_at=product.first_seen_at,
         last_updated_at=product.last_updated_at,
         latest_price=float(latest.price) if latest and latest.price is not None else None,
@@ -845,9 +991,11 @@ def _product_to_out(session: Session, product: Product) -> ProductOut:
         latest_stock_status=latest.stock_status if latest else None,
         latest_fetched_at=latest.fetched_at if latest else None,
         images=images,
+        main_image=main_image,
+        gallery_images=gallery_images,
         specs=specs,
-        discount_amount=discount_amount,
-        discount_percent=discount_percent,
+        discount_amount=None,
+        discount_percent=None,
         history=history_points,
     )
 

pricewatch/app/api/schemas.py

@@ -22,12 +22,23 @@ class ProductOut(BaseModel):
     id: int
     source: str
     reference: str
+    asin: Optional[str] = None
     url: str
     title: Optional[str] = None
     category: Optional[str] = None
+    type: Optional[str] = None
     description: Optional[str] = None
     currency: Optional[str] = None
     msrp: Optional[float] = None
+    rating_value: Optional[float] = None
+    rating_count: Optional[int] = None
+    amazon_choice: Optional[bool] = None
+    amazon_choice_label: Optional[str] = None
+    discount_text: Optional[str] = None
+    stock_text: Optional[str] = None
+    in_stock: Optional[bool] = None
+    model_number: Optional[str] = None
+    model_name: Optional[str] = None
     first_seen_at: datetime
     last_updated_at: datetime
     latest_price: Optional[float] = None
@@ -35,6 +46,8 @@ class ProductOut(BaseModel):
     latest_stock_status: Optional[str] = None
     latest_fetched_at: Optional[datetime] = None
     images: list[str] = []
+    main_image: Optional[str] = None
+    gallery_images: list[str] = []
     specs: dict[str, str] = {}
     discount_amount: Optional[float] = None
     discount_percent: Optional[float] = None
@@ -47,6 +60,7 @@ class ProductCreate(BaseModel):
     url: str
     title: Optional[str] = None
     category: Optional[str] = None
+    type: Optional[str] = None
     description: Optional[str] = None
     currency: Optional[str] = None
     msrp: Optional[float] = None
@@ -56,6 +70,7 @@ class ProductUpdate(BaseModel):
     url: Optional[str] = None
     title: Optional[str] = None
     category: Optional[str] = None
+    type: Optional[str] = None
     description: Optional[str] = None
     currency: Optional[str] = None
     msrp: Optional[float] = None
@@ -208,6 +223,36 @@ class VersionResponse(BaseModel):
     api_version: str
 
 
+class ClassificationRuleOut(BaseModel):
+    id: int
+    category: Optional[str] = None
+    type: Optional[str] = None
+    keywords: list[str] = Field(default_factory=list)
+    sort_order: int = 0
+    is_active: bool = True
+
+
+class ClassificationRuleCreate(BaseModel):
+    category: Optional[str] = None
+    type: Optional[str] = None
+    keywords: list[str] = Field(default_factory=list)
+    sort_order: Optional[int] = 0
+    is_active: Optional[bool] = True
+
+
+class ClassificationRuleUpdate(BaseModel):
+    category: Optional[str] = None
+    type: Optional[str] = None
+    keywords: Optional[list[str]] = None
+    sort_order: Optional[int] = None
+    is_active: Optional[bool] = None
+
+
+class ClassificationOptionsOut(BaseModel):
+    categories: list[str] = Field(default_factory=list)
+    types: list[str] = Field(default_factory=list)
+
+
 class BackendLogEntry(BaseModel):
     time: datetime
     level: str

pricewatch/app/core/schema.py

@@ -93,13 +93,52 @@ class ProductSnapshot(BaseModel):
     reference: Optional[str] = Field(
         default=None, description="Référence produit (ASIN, SKU, etc.)"
     )
+    asin: Optional[str] = Field(
+        default=None, description="ASIN Amazon si disponible"
+    )
     category: Optional[str] = Field(default=None, description="Catégorie du produit")
+    type: Optional[str] = Field(default=None, description="Type du produit")
     description: Optional[str] = Field(default=None, description="Description produit")
 
+    # Données Amazon explicites (si disponibles)
+    rating_value: Optional[float] = Field(
+        default=None, description="Note moyenne affichée"
+    )
+    rating_count: Optional[int] = Field(
+        default=None, description="Nombre d'évaluations"
+    )
+    amazon_choice: Optional[bool] = Field(
+        default=None, description="Badge Choix d'Amazon présent"
+    )
+    amazon_choice_label: Optional[str] = Field(
+        default=None, description="Libellé du badge Choix d'Amazon"
+    )
+    discount_text: Optional[str] = Field(
+        default=None, description="Texte de réduction affiché"
+    )
+    stock_text: Optional[str] = Field(
+        default=None, description="Texte brut de stock"
+    )
+    in_stock: Optional[bool] = Field(
+        default=None, description="Disponibilité dérivée"
+    )
+    model_number: Optional[str] = Field(
+        default=None, description="Numéro du modèle de l'article"
+    )
+    model_name: Optional[str] = Field(
+        default=None, description="Nom du modèle explicite"
+    )
+
     # Médias
     images: list[str] = Field(
         default_factory=list, description="Liste des URLs d'images du produit"
     )
+    main_image: Optional[str] = Field(
+        default=None, description="Image principale du produit"
+    )
+    gallery_images: list[str] = Field(
+        default_factory=list, description="Images de galerie dédoublonnées"
+    )
 
     # Caractéristiques techniques
     specs: dict[str, str] = Field(
@@ -134,6 +173,12 @@ class ProductSnapshot(BaseModel):
         """Filtre les URLs d'images vides."""
         return [url.strip() for url in v if url and url.strip()]
 
+    @field_validator("gallery_images")
+    @classmethod
+    def validate_gallery_images(cls, v: list[str]) -> list[str]:
+        """Filtre les URLs de galerie vides."""
+        return [url.strip() for url in v if url and url.strip()]
+
     model_config = ConfigDict(
         use_enum_values=True,
         json_schema_extra={

pricewatch/app/db/migrations/versions/0014e51c4927_ajout_champs_amazon_produit.py

@@ -0,0 +1,350 @@
+"""Ajout champs Amazon produit
+
+Revision ID: 0014e51c4927
+Revises: 20260115_02_product_details
+Create Date: 2026-01-17 19:23:01.866891
+"""
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# Revision identifiers, used by Alembic.
+revision = '0014e51c4927'
+down_revision = '20260115_02_product_details'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('price_history', 'price',
+               existing_type=sa.NUMERIC(precision=10, scale=2),
+               comment='Product price',
+               existing_nullable=True)
+    op.alter_column('price_history', 'shipping_cost',
+               existing_type=sa.NUMERIC(precision=10, scale=2),
+               comment='Shipping cost',
+               existing_nullable=True)
+    op.alter_column('price_history', 'stock_status',
+               existing_type=sa.VARCHAR(length=20),
+               comment='Stock status (in_stock, out_of_stock, unknown)',
+               existing_nullable=True)
+    op.alter_column('price_history', 'fetch_method',
+               existing_type=sa.VARCHAR(length=20),
+               comment='Fetch method (http, playwright)',
+               existing_nullable=False)
+    op.alter_column('price_history', 'fetch_status',
+               existing_type=sa.VARCHAR(length=20),
+               comment='Fetch status (success, partial, failed)',
+               existing_nullable=False)
+    op.alter_column('price_history', 'fetched_at',
+               existing_type=postgresql.TIMESTAMP(),
+               comment='Scraping timestamp',
+               existing_nullable=False)
+    op.alter_column('product_images', 'image_url',
+               existing_type=sa.TEXT(),
+               comment='Image URL',
+               existing_nullable=False)
+    op.alter_column('product_images', 'position',
+               existing_type=sa.INTEGER(),
+               comment='Image position (0=main)',
+               existing_nullable=False)
+    op.alter_column('product_specs', 'spec_key',
+               existing_type=sa.VARCHAR(length=200),
+               comment="Specification key (e.g., 'Brand', 'Color')",
+               existing_nullable=False)
+    op.alter_column('product_specs', 'spec_value',
+               existing_type=sa.TEXT(),
+               comment='Specification value',
+               existing_nullable=False)
+    op.add_column('products', sa.Column('rating_value', sa.Numeric(precision=3, scale=2), nullable=True, comment='Note moyenne'))
+    op.add_column('products', sa.Column('rating_count', sa.Integer(), nullable=True, comment="Nombre d'evaluations"))
+    op.add_column('products', sa.Column('amazon_choice', sa.Boolean(), nullable=True, comment="Badge Choix d'Amazon"))
+    op.add_column('products', sa.Column('amazon_choice_label', sa.Text(), nullable=True, comment="Libelle Choix d'Amazon"))
+    op.add_column('products', sa.Column('discount_text', sa.Text(), nullable=True, comment='Texte de reduction affiche'))
+    op.add_column('products', sa.Column('stock_text', sa.Text(), nullable=True, comment='Texte brut du stock'))
+    op.add_column('products', sa.Column('in_stock', sa.Boolean(), nullable=True, comment='Disponibilite derivee'))
+    op.add_column('products', sa.Column('model_number', sa.Text(), nullable=True, comment='Numero du modele'))
+    op.add_column('products', sa.Column('model_name', sa.Text(), nullable=True, comment='Nom du modele'))
+    op.alter_column('products', 'source',
+               existing_type=sa.VARCHAR(length=50),
+               comment='Store ID (amazon, cdiscount, etc.)',
+               existing_nullable=False)
+    op.alter_column('products', 'reference',
+               existing_type=sa.VARCHAR(length=100),
+               comment='Product reference (ASIN, SKU, etc.)',
+               existing_nullable=False)
+    op.alter_column('products', 'url',
+               existing_type=sa.TEXT(),
+               comment='Canonical product URL',
+               existing_nullable=False)
+    op.alter_column('products', 'title',
+               existing_type=sa.TEXT(),
+               comment='Product title',
+               existing_nullable=True)
+    op.alter_column('products', 'category',
+               existing_type=sa.TEXT(),
+               comment='Product category (breadcrumb)',
+               existing_nullable=True)
+    op.alter_column('products', 'description',
+               existing_type=sa.TEXT(),
+               comment='Product description',
+               existing_nullable=True)
+    op.alter_column('products', 'currency',
+               existing_type=sa.VARCHAR(length=3),
+               comment='Currency code (EUR, USD, GBP)',
+               existing_nullable=True)
+    op.alter_column('products', 'msrp',
+               existing_type=sa.NUMERIC(precision=10, scale=2),
+               comment='Recommended price',
+               existing_nullable=True)
+    op.alter_column('products', 'first_seen_at',
+               existing_type=postgresql.TIMESTAMP(),
+               comment='First scraping timestamp',
+               existing_nullable=False)
+    op.alter_column('products', 'last_updated_at',
+               existing_type=postgresql.TIMESTAMP(),
+               comment='Last metadata update',
+               existing_nullable=False)
+    op.alter_column('scraping_logs', 'url',
+               existing_type=sa.TEXT(),
+               comment='Scraped URL',
+               existing_nullable=False)
+    op.alter_column('scraping_logs', 'source',
+               existing_type=sa.VARCHAR(length=50),
+               comment='Store ID (amazon, cdiscount, etc.)',
+               existing_nullable=False)
+    op.alter_column('scraping_logs', 'reference',
+               existing_type=sa.VARCHAR(length=100),
+               comment='Product reference (if extracted)',
+               existing_nullable=True)
+    op.alter_column('scraping_logs', 'fetch_method',
+               existing_type=sa.VARCHAR(length=20),
+               comment='Fetch method (http, playwright)',
+               existing_nullable=False)
+    op.alter_column('scraping_logs', 'fetch_status',
+               existing_type=sa.VARCHAR(length=20),
+               comment='Fetch status (success, partial, failed)',
+               existing_nullable=False)
+    op.alter_column('scraping_logs', 'fetched_at',
+               existing_type=postgresql.TIMESTAMP(),
+               comment='Scraping timestamp',
+               existing_nullable=False)
+    op.alter_column('scraping_logs', 'duration_ms',
+               existing_type=sa.INTEGER(),
+               comment='Fetch duration in milliseconds',
+               existing_nullable=True)
+    op.alter_column('scraping_logs', 'html_size_bytes',
+               existing_type=sa.INTEGER(),
+               comment='HTML response size in bytes',
+               existing_nullable=True)
+    op.alter_column('scraping_logs', 'errors',
+               existing_type=postgresql.JSONB(astext_type=sa.Text()),
+               comment='Error messages (list of strings)',
+               existing_nullable=True)
+    op.alter_column('scraping_logs', 'notes',
+               existing_type=postgresql.JSONB(astext_type=sa.Text()),
+               comment='Debug notes (list of strings)',
+               existing_nullable=True)
+    op.alter_column('webhooks', 'event',
+               existing_type=sa.VARCHAR(length=50),
+               comment='Event name',
+               existing_nullable=False)
+    op.alter_column('webhooks', 'url',
+               existing_type=sa.TEXT(),
+               comment='Webhook URL',
+               existing_nullable=False)
+    op.alter_column('webhooks', 'secret',
+               existing_type=sa.VARCHAR(length=200),
+               comment='Secret optionnel',
+               existing_nullable=True)
+    op.alter_column('webhooks', 'created_at',
+               existing_type=postgresql.TIMESTAMP(),
+               comment='Creation timestamp',
+               existing_nullable=False)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.alter_column('webhooks', 'created_at',
+               existing_type=postgresql.TIMESTAMP(),
+               comment=None,
+               existing_comment='Creation timestamp',
+               existing_nullable=False)
+    op.alter_column('webhooks', 'secret',
+               existing_type=sa.VARCHAR(length=200),
+               comment=None,
+               existing_comment='Secret optionnel',
+               existing_nullable=True)
+    op.alter_column('webhooks', 'url',
+               existing_type=sa.TEXT(),
+               comment=None,
+               existing_comment='Webhook URL',
+               existing_nullable=False)
+    op.alter_column('webhooks', 'event',
+               existing_type=sa.VARCHAR(length=50),
+               comment=None,
+               existing_comment='Event name',
+               existing_nullable=False)
+    op.alter_column('scraping_logs', 'notes',
+               existing_type=postgresql.JSONB(astext_type=sa.Text()),
+               comment=None,
+               existing_comment='Debug notes (list of strings)',
+               existing_nullable=True)
+    op.alter_column('scraping_logs', 'errors',
+               existing_type=postgresql.JSONB(astext_type=sa.Text()),
+               comment=None,
+               existing_comment='Error messages (list of strings)',
+               existing_nullable=True)
+    op.alter_column('scraping_logs', 'html_size_bytes',
+               existing_type=sa.INTEGER(),
+               comment=None,
+               existing_comment='HTML response size in bytes',
+               existing_nullable=True)
+    op.alter_column('scraping_logs', 'duration_ms',
+               existing_type=sa.INTEGER(),
+               comment=None,
+               existing_comment='Fetch duration in milliseconds',
+               existing_nullable=True)
+    op.alter_column('scraping_logs', 'fetched_at',
+               existing_type=postgresql.TIMESTAMP(),
+               comment=None,
+               existing_comment='Scraping timestamp',
+               existing_nullable=False)
+    op.alter_column('scraping_logs', 'fetch_status',
+               existing_type=sa.VARCHAR(length=20),
+               comment=None,
+               existing_comment='Fetch status (success, partial, failed)',
+               existing_nullable=False)
+    op.alter_column('scraping_logs', 'fetch_method',
+               existing_type=sa.VARCHAR(length=20),
+               comment=None,
+               existing_comment='Fetch method (http, playwright)',
+               existing_nullable=False)
+    op.alter_column('scraping_logs', 'reference',
+               existing_type=sa.VARCHAR(length=100),
+               comment=None,
+               existing_comment='Product reference (if extracted)',
+               existing_nullable=True)
+    op.alter_column('scraping_logs', 'source',
+               existing_type=sa.VARCHAR(length=50),
+               comment=None,
+               existing_comment='Store ID (amazon, cdiscount, etc.)',
+               existing_nullable=False)
+    op.alter_column('scraping_logs', 'url',
+               existing_type=sa.TEXT(),
+               comment=None,
+               existing_comment='Scraped URL',
+               existing_nullable=False)
+    op.alter_column('products', 'last_updated_at',
+               existing_type=postgresql.TIMESTAMP(),
+               comment=None,
+               existing_comment='Last metadata update',
+               existing_nullable=False)
+    op.alter_column('products', 'first_seen_at',
+               existing_type=postgresql.TIMESTAMP(),
+               comment=None,
+               existing_comment='First scraping timestamp',
+               existing_nullable=False)
+    op.alter_column('products', 'msrp',
+               existing_type=sa.NUMERIC(precision=10, scale=2),
+               comment=None,
+               existing_comment='Recommended price',
+               existing_nullable=True)
+    op.alter_column('products', 'currency',
+               existing_type=sa.VARCHAR(length=3),
+               comment=None,
+               existing_comment='Currency code (EUR, USD, GBP)',
+               existing_nullable=True)
+    op.alter_column('products', 'description',
+               existing_type=sa.TEXT(),
+               comment=None,
+               existing_comment='Product description',
+               existing_nullable=True)
+    op.alter_column('products', 'category',
+               existing_type=sa.TEXT(),
+               comment=None,
+               existing_comment='Product category (breadcrumb)',
+               existing_nullable=True)
+    op.alter_column('products', 'title',
+               existing_type=sa.TEXT(),
+               comment=None,
+               existing_comment='Product title',
+               existing_nullable=True)
+    op.alter_column('products', 'url',
+               existing_type=sa.TEXT(),
+               comment=None,
+               existing_comment='Canonical product URL',
+               existing_nullable=False)
+    op.alter_column('products', 'reference',
+               existing_type=sa.VARCHAR(length=100),
+               comment=None,
+               existing_comment='Product reference (ASIN, SKU, etc.)',
+               existing_nullable=False)
+    op.alter_column('products', 'source',
+               existing_type=sa.VARCHAR(length=50),
+               comment=None,
+               existing_comment='Store ID (amazon, cdiscount, etc.)',
+               existing_nullable=False)
+    op.drop_column('products', 'model_name')
+    op.drop_column('products', 'model_number')
+    op.drop_column('products', 'in_stock')
+    op.drop_column('products', 'stock_text')
+    op.drop_column('products', 'discount_text')
+    op.drop_column('products', 'amazon_choice_label')
+    op.drop_column('products', 'amazon_choice')
+    op.drop_column('products', 'rating_count')
+    op.drop_column('products', 'rating_value')
+    op.alter_column('product_specs', 'spec_value',
+               existing_type=sa.TEXT(),
+               comment=None,
+               existing_comment='Specification value',
+               existing_nullable=False)
+    op.alter_column('product_specs', 'spec_key',
+               existing_type=sa.VARCHAR(length=200),
+               comment=None,
+               existing_comment="Specification key (e.g., 'Brand', 'Color')",
+               existing_nullable=False)
+    op.alter_column('product_images', 'position',
+               existing_type=sa.INTEGER(),
+               comment=None,
+               existing_comment='Image position (0=main)',
+               existing_nullable=False)
+    op.alter_column('product_images', 'image_url',
+               existing_type=sa.TEXT(),
+               comment=None,
+               existing_comment='Image URL',
+               existing_nullable=False)
+    op.alter_column('price_history', 'fetched_at',
+               existing_type=postgresql.TIMESTAMP(),
+               comment=None,
+               existing_comment='Scraping timestamp',
+               existing_nullable=False)
+    op.alter_column('price_history', 'fetch_status',
+               existing_type=sa.VARCHAR(length=20),
+               comment=None,
+               existing_comment='Fetch status (success, partial, failed)',
+               existing_nullable=False)
+    op.alter_column('price_history', 'fetch_method',
+               existing_type=sa.VARCHAR(length=20),
+               comment=None,
+               existing_comment='Fetch method (http, playwright)',
+               existing_nullable=False)
+    op.alter_column('price_history', 'stock_status',
+               existing_type=sa.VARCHAR(length=20),
+               comment=None,
+               existing_comment='Stock status (in_stock, out_of_stock, unknown)',
+               existing_nullable=True)
+    op.alter_column('price_history', 'shipping_cost',
+               existing_type=sa.NUMERIC(precision=10, scale=2),
+               comment=None,
+               existing_comment='Shipping cost',
+               existing_nullable=True)
+    op.alter_column('price_history', 'price',
+               existing_type=sa.NUMERIC(precision=10, scale=2),
+               comment=None,
+               existing_comment='Product price',
+               existing_nullable=True)
+    # ### end Alembic commands ###

pricewatch/app/db/migrations/versions/1467e98fcbea_ajout_champs_amazon_produit.py

@@ -0,0 +1,28 @@
+"""Ajout champs Amazon produit
+
+Revision ID: 1467e98fcbea
+Revises: 3e68b0f0c9e4
+Create Date: 2026-01-17 20:08:32.991650
+"""
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# Revision identifiers, used by Alembic.
+revision = '1467e98fcbea'
+down_revision = '3e68b0f0c9e4'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###

pricewatch/app/db/migrations/versions/20260117_03_classification_rules.py

@@ -0,0 +1,114 @@
+"""Ajout classification rules et type produit
+
+Revision ID: 20260117_03_classification_rules
+Revises: 3e68b0f0c9e4
+Create Date: 2026-01-17 20:05:00.000000
+"""
+
+from datetime import datetime, timezone
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+
+# Revision identifiers, used by Alembic.
+revision = "20260117_03_classification_rules"
+down_revision = "3e68b0f0c9e4"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "products",
+        sa.Column("type", sa.Text(), nullable=True, comment="Product type"),
+    )
+
+    op.create_table(
+        "classification_rules",
+        sa.Column("id", sa.Integer(), primary_key=True, autoincrement=True),
+        sa.Column("category", sa.String(length=80), nullable=True, comment="Categorie cible"),
+        sa.Column("type", sa.String(length=80), nullable=True, comment="Type cible"),
+        sa.Column(
+            "keywords",
+            postgresql.JSONB(astext_type=sa.Text()),
+            nullable=False,
+            comment="Mots-cles de matching",
+        ),
+        sa.Column("sort_order", sa.Integer(), nullable=False, server_default="0"),
+        sa.Column("is_active", sa.Boolean(), nullable=False, server_default=sa.text("true")),
+        sa.Column(
+            "created_at",
+            sa.TIMESTAMP(),
+            nullable=False,
+            server_default=sa.text("CURRENT_TIMESTAMP"),
+            comment="Creation timestamp",
+        ),
+    )
+    op.create_index("ix_classification_rule_order", "classification_rules", ["sort_order"])
+    op.create_index("ix_classification_rule_active", "classification_rules", ["is_active"])
+
+    rules_table = sa.table(
+        "classification_rules",
+        sa.column("category", sa.String),
+        sa.column("type", sa.String),
+        sa.column("keywords", postgresql.JSONB),
+        sa.column("sort_order", sa.Integer),
+        sa.column("is_active", sa.Boolean),
+        sa.column("created_at", sa.TIMESTAMP),
+    )
+
+    now = datetime.now(timezone.utc)
+    op.bulk_insert(
+        rules_table,
+        [
+            {
+                "category": "Informatique",
+                "type": "Ecran",
+                "keywords": ["ecran", "moniteur", "display"],
+                "sort_order": 0,
+                "is_active": True,
+                "created_at": now,
+            },
+            {
+                "category": "Informatique",
+                "type": "PC portable",
+                "keywords": ["pc portable", "ordinateur portable", "laptop", "notebook"],
+                "sort_order": 1,
+                "is_active": True,
+                "created_at": now,
+            },
+            {
+                "category": "Informatique",
+                "type": "Unite centrale",
+                "keywords": ["unite centrale", "tour", "desktop", "pc fixe"],
+                "sort_order": 2,
+                "is_active": True,
+                "created_at": now,
+            },
+            {
+                "category": "Informatique",
+                "type": "Clavier",
+                "keywords": ["clavier", "keyboard"],
+                "sort_order": 3,
+                "is_active": True,
+                "created_at": now,
+            },
+            {
+                "category": "Informatique",
+                "type": "Souris",
+                "keywords": ["souris", "mouse"],
+                "sort_order": 4,
+                "is_active": True,
+                "created_at": now,
+            },
+        ],
+    )
+
+
+def downgrade() -> None:
+    op.drop_index("ix_classification_rule_active", table_name="classification_rules")
+    op.drop_index("ix_classification_rule_order", table_name="classification_rules")
+    op.drop_table("classification_rules")
+    op.drop_column("products", "type")

pricewatch/app/db/migrations/versions/3e68b0f0c9e4_ajout_champs_amazon_produit.py

@@ -0,0 +1,28 @@
+"""Ajout champs Amazon produit
+
+Revision ID: 3e68b0f0c9e4
+Revises: 0014e51c4927
+Create Date: 2026-01-17 19:45:03.730218
+"""
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# Revision identifiers, used by Alembic.
+revision = '3e68b0f0c9e4'
+down_revision = '0014e51c4927'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    pass
+    # ### end Alembic commands ###

pricewatch/app/db/models.py

@@ -84,6 +84,36 @@ class Product(Base):
     msrp: Mapped[Optional[Decimal]] = mapped_column(
         Numeric(10, 2), nullable=True, comment="Recommended price"
     )
+    type: Mapped[Optional[str]] = mapped_column(
+        Text, nullable=True, comment="Product type"
+    )
+    rating_value: Mapped[Optional[Decimal]] = mapped_column(
+        Numeric(3, 2), nullable=True, comment="Note moyenne"
+    )
+    rating_count: Mapped[Optional[int]] = mapped_column(
+        Integer, nullable=True, comment="Nombre d'evaluations"
+    )
+    amazon_choice: Mapped[Optional[bool]] = mapped_column(
+        Boolean, nullable=True, comment="Badge Choix d'Amazon"
+    )
+    amazon_choice_label: Mapped[Optional[str]] = mapped_column(
+        Text, nullable=True, comment="Libelle Choix d'Amazon"
+    )
+    discount_text: Mapped[Optional[str]] = mapped_column(
+        Text, nullable=True, comment="Texte de reduction affiche"
+    )
+    stock_text: Mapped[Optional[str]] = mapped_column(
+        Text, nullable=True, comment="Texte brut du stock"
+    )
+    in_stock: Mapped[Optional[bool]] = mapped_column(
+        Boolean, nullable=True, comment="Disponibilite derivee"
+    )
+    model_number: Mapped[Optional[str]] = mapped_column(
+        Text, nullable=True, comment="Numero du modele"
+    )
+    model_name: Mapped[Optional[str]] = mapped_column(
+        Text, nullable=True, comment="Nom du modele"
+    )
 
     # Timestamps
     first_seen_at: Mapped[datetime] = mapped_column(
@@ -331,6 +361,45 @@ class ScrapingLog(Base):
         return f"<ScrapingLog(id={self.id}, url={self.url}, status={self.fetch_status}, fetched_at={self.fetched_at})>"
 
 
+class ClassificationRule(Base):
+    """
+    Regles de classification categorie/type basees sur des mots-cles.
+    """
+
+    __tablename__ = "classification_rules"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    category: Mapped[Optional[str]] = mapped_column(
+        String(80), nullable=True, comment="Categorie cible"
+    )
+    type: Mapped[Optional[str]] = mapped_column(
+        String(80), nullable=True, comment="Type cible"
+    )
+    keywords: Mapped[list[str]] = mapped_column(
+        JSON().with_variant(JSONB, "postgresql"),
+        nullable=False,
+        default=list,
+        comment="Mots-cles de matching",
+    )
+    sort_order: Mapped[int] = mapped_column(
+        Integer, nullable=False, default=0, comment="Ordre de priorite (0=haut)"
+    )
+    is_active: Mapped[bool] = mapped_column(
+        Boolean, nullable=False, default=True, comment="Regle active"
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        TIMESTAMP, nullable=False, default=utcnow, comment="Creation timestamp"
+    )
+
+    __table_args__ = (
+        Index("ix_classification_rule_order", "sort_order"),
+        Index("ix_classification_rule_active", "is_active"),
+    )
+
+    def __repr__(self) -> str:
+        return f"<ClassificationRule(id={self.id}, category={self.category}, type={self.type})>"
+
+
 class Webhook(Base):
     """
     Webhooks pour notifications externes.

pricewatch/app/db/repository.py

@@ -13,7 +13,14 @@ from sqlalchemy.orm import Session
 
 from pricewatch.app.core.logging import get_logger
 from pricewatch.app.core.schema import ProductSnapshot
-from pricewatch.app.db.models import PriceHistory, Product, ProductImage, ProductSpec, ScrapingLog
+from pricewatch.app.db.models import (
+    ClassificationRule,
+    PriceHistory,
+    Product,
+    ProductImage,
+    ProductSpec,
+    ScrapingLog,
+)
 
 logger = get_logger("db.repository")
 
@@ -49,12 +56,58 @@ class ProductRepository:
             product.title = snapshot.title
         if snapshot.category:
             product.category = snapshot.category
+        if snapshot.type:
+            product.type = snapshot.type
         if snapshot.description:
             product.description = snapshot.description
         if snapshot.currency:
             product.currency = snapshot.currency
         if snapshot.msrp is not None:
             product.msrp = snapshot.msrp
+        if snapshot.rating_value is not None:
+            product.rating_value = snapshot.rating_value
+        if snapshot.rating_count is not None:
+            product.rating_count = snapshot.rating_count
+        if snapshot.amazon_choice is not None:
+            product.amazon_choice = snapshot.amazon_choice
+        if snapshot.amazon_choice_label:
+            product.amazon_choice_label = snapshot.amazon_choice_label
+        if snapshot.discount_text:
+            product.discount_text = snapshot.discount_text
+        if snapshot.stock_text:
+            product.stock_text = snapshot.stock_text
+        if snapshot.in_stock is not None:
+            product.in_stock = snapshot.in_stock
+        if snapshot.model_number:
+            product.model_number = snapshot.model_number
+        if snapshot.model_name:
+            product.model_name = snapshot.model_name
+
+    def apply_classification(self, snapshot: ProductSnapshot) -> None:
+        """Applique les regles de classification au snapshot."""
+        if not snapshot.title:
+            return
+
+        rules = (
+            self.session.query(ClassificationRule)
+            .filter(ClassificationRule.is_active == True)
+            .order_by(ClassificationRule.sort_order, ClassificationRule.id)
+            .all()
+        )
+        if not rules:
+            return
+
+        title = snapshot.title.lower()
+        for rule in rules:
+            keywords = rule.keywords or []
+            if isinstance(keywords, str):
+                keywords = [keywords]
+            if any(keyword and keyword.lower() in title for keyword in keywords):
+                if rule.category:
+                    snapshot.category = rule.category
+                if rule.type:
+                    snapshot.type = rule.type
+                return
 
     def add_price_history(self, product: Product, snapshot: ProductSnapshot) -> Optional[PriceHistory]:
         """Ajoute une entree d'historique de prix si inexistante."""

pricewatch/app/scraping/pipeline.py

@@ -25,7 +25,12 @@ class ScrapingPipeline:
     def __init__(self, config: Optional[AppConfig] = None) -> None:
         self.config = config
 
-    def process_snapshot(self, snapshot: ProductSnapshot, save_to_db: bool = True) -> Optional[int]:
+    def process_snapshot(
+        self,
+        snapshot: ProductSnapshot,
+        save_to_db: bool = True,
+        apply_classification: bool = True,
+    ) -> Optional[int]:
         """
         Persiste un snapshot en base si active.
 
@@ -39,6 +44,8 @@ class ScrapingPipeline:
         try:
             with get_session(app_config) as session:
                 repo = ProductRepository(session)
+                if apply_classification:
+                    repo.apply_classification(snapshot)
                 product_id = repo.safe_save_snapshot(snapshot)
                 session.commit()
                 return product_id

pricewatch/app/stores/amazon/selectors.yml

@@ -15,6 +15,13 @@ price:
   - "#priceblock_dealprice"
   - ".a-price-range .a-price .a-offscreen"
 
+# Texte de réduction explicite
+discount_text:
+  - "#regularprice_savings"
+  - "#dealprice_savings"
+  - "#savingsPercentage"
+  - "span.savingsPercentage"
+
 # Devise (généralement dans le symbole)
 currency:
   - "span.a-price-symbol"
@@ -32,6 +39,24 @@ stock_status:
   - "#availability"
   - ".a-declarative .a-size-medium"
 
+# Note moyenne
+rating_value:
+  - "#acrPopover"
+  - "#averageCustomerReviews .a-icon-alt"
+  - "#averageCustomerReviews span.a-icon-alt"
+
+# Nombre d'évaluations
+rating_count:
+  - "#acrCustomerReviewText"
+  - "#acrCustomerReviewLink"
+
+# Badge Choix d'Amazon
+amazon_choice:
+  - "#acBadge_feature_div"
+  - "#acBadge_feature_div .ac-badge"
+  - "#acBadge_feature_div .ac-badge-rectangle"
+  - "#acBadge_feature_div .ac-badge-rectangle-icon"
+
 # Images produit
 images:
   - "#landingImage"
@@ -44,6 +69,13 @@ category:
   - "#wayfinding-breadcrumbs_feature_div"
   - ".a-breadcrumb"
 
+# Description (détails de l'article)
+description:
+  - "#detailBullets_feature_div"
+  - "#detailBulletsWrapper_feature_div"
+  - "#productDetails_detailBullets_sections1"
+  - "#feature-bullets"
+
 # Caractéristiques techniques (table specs)
 specs_table:
   - "#productDetails_techSpec_section_1"

pricewatch/app/stores/amazon/store.py

@@ -130,13 +130,19 @@ class AmazonStore(BaseStore):
         title = self._extract_title(soup, debug_info)
         price = self._extract_price(soup, debug_info)
         currency = self._extract_currency(soup, debug_info)
-        stock_status = self._extract_stock(soup, debug_info)
-        images = self._extract_images(soup, debug_info)
+        stock_status, stock_text, in_stock = self._extract_stock_details(soup, debug_info)
+        main_image, gallery_images, images = self._extract_images(soup, debug_info)
         category = self._extract_category(soup, debug_info)
         specs = self._extract_specs(soup, debug_info)
         description = self._extract_description(soup, debug_info)
         msrp = self._extract_msrp(soup, debug_info)
         reference = self.extract_reference(url) or self._extract_asin_from_html(soup)
+        rating_value = self._extract_rating_value(soup, debug_info)
+        rating_count = self._extract_rating_count(soup, debug_info)
+        amazon_choice, amazon_choice_label = self._extract_amazon_choice(soup, debug_info)
+        discount_text = self._extract_discount_text(soup, debug_info)
+        model_number, model_name = self._extract_model_details(specs)
+        asin = reference
 
         # Déterminer le statut final (ne pas écraser FAILED)
         if debug_info.status != DebugStatus.FAILED:
@@ -153,12 +159,24 @@ class AmazonStore(BaseStore):
             currency=currency or "EUR",
             shipping_cost=None,  # Difficile à extraire
             stock_status=stock_status,
+            stock_text=stock_text,
+            in_stock=in_stock,
             reference=reference,
+            asin=asin,
             category=category,
             description=description,
             images=images,
+            main_image=main_image,
+            gallery_images=gallery_images,
             specs=specs,
             msrp=msrp,
+            rating_value=rating_value,
+            rating_count=rating_count,
+            amazon_choice=amazon_choice,
+            amazon_choice_label=amazon_choice_label,
+            discount_text=discount_text,
+            model_number=model_number,
+            model_name=model_name,
             debug=debug_info,
         )
 
@@ -203,14 +221,26 @@ class AmazonStore(BaseStore):
         return None
 
     def _extract_description(self, soup: BeautifulSoup, debug: DebugInfo) -> Optional[str]:
-        """Extrait la description (meta tags)."""
-        meta = soup.find("meta", property="og:description") or soup.find(
-            "meta", attrs={"name": "description"}
-        )
-        if meta:
-            description = meta.get("content", "").strip()
-            if description:
-                return description
+        """Extrait la description depuis les détails de l'article."""
+        selectors = self.get_selector("description", [])
+        if isinstance(selectors, str):
+            selectors = [selectors]
+
+        for selector in selectors:
+            element = soup.select_one(selector)
+            if not element:
+                continue
+            items = [
+                item.get_text(" ", strip=True)
+                for item in element.select("li")
+                if item.get_text(strip=True)
+            ]
+            if items:
+                return "\n".join(items)
+            text = " ".join(element.stripped_strings)
+            if text:
+                return text
+
         return None
 
     def _extract_price(self, soup: BeautifulSoup, debug: DebugInfo) -> Optional[float]:
@@ -271,8 +301,10 @@ class AmazonStore(BaseStore):
         # Défaut basé sur le domaine
         return "EUR"
 
-    def _extract_stock(self, soup: BeautifulSoup, debug: DebugInfo) -> StockStatus:
-        """Extrait le statut de stock."""
+    def _extract_stock_details(
+        self, soup: BeautifulSoup, debug: DebugInfo
+    ) -> tuple[StockStatus, Optional[str], Optional[bool]]:
+        """Extrait le statut de stock avec texte brut."""
         selectors = self.get_selector("stock_status", [])
         if isinstance(selectors, str):
             selectors = [selectors]
@@ -280,22 +312,27 @@ class AmazonStore(BaseStore):
         for selector in selectors:
             element = soup.select_one(selector)
             if element:
-                text = element.get_text(strip=True).lower()
-                if "en stock" in text or "available" in text or "in stock" in text:
-                    return StockStatus.IN_STOCK
+                text = element.get_text(strip=True)
+                normalized = text.lower()
+                if "en stock" in normalized or "available" in normalized or "in stock" in normalized:
+                    return StockStatus.IN_STOCK, text, True
                 elif (
-                    "rupture" in text
-                    or "indisponible" in text
-                    or "out of stock" in text
+                    "rupture" in normalized
+                    or "indisponible" in normalized
+                    or "out of stock" in normalized
                 ):
-                    return StockStatus.OUT_OF_STOCK
+                    return StockStatus.OUT_OF_STOCK, text, False
 
-        return StockStatus.UNKNOWN
+        return StockStatus.UNKNOWN, None, None
 
-    def _extract_images(self, soup: BeautifulSoup, debug: DebugInfo) -> list[str]:
-        """Extrait les URLs d'images."""
-        images = []
-        seen = set()
+    def _extract_images(
+        self, soup: BeautifulSoup, debug: DebugInfo
+    ) -> tuple[Optional[str], list[str], list[str]]:
+        """Extrait l'image principale et la galerie."""
+        images: list[str] = []
+        seen: set[str] = set()
+        main_image: Optional[str] = None
+        max_gallery = 15
         selectors = self.get_selector("images", [])
         if isinstance(selectors, str):
             selectors = [selectors]
@@ -309,6 +346,8 @@ class AmazonStore(BaseStore):
                     if self._is_product_image(url) and url not in seen:
                         images.append(url)
                         seen.add(url)
+                        if main_image is None:
+                            main_image = url
                 dynamic = element.get("data-a-dynamic-image")
                 if dynamic:
                     urls = self._extract_dynamic_images(dynamic)
@@ -316,6 +355,8 @@ class AmazonStore(BaseStore):
                         if self._is_product_image(dyn_url) and dyn_url not in seen:
                             images.append(dyn_url)
                             seen.add(dyn_url)
+                            if main_image is None:
+                                main_image = dyn_url
 
         # Fallback: chercher tous les img tags si aucune image trouvée
         if not images:
@@ -326,8 +367,15 @@ class AmazonStore(BaseStore):
                     if url not in seen:
                         images.append(url)
                         seen.add(url)
+                        if main_image is None:
+                            main_image = url
 
-        return images
+        if main_image is None and images:
+            main_image = images[0]
+        gallery_images = [url for url in images if url != main_image]
+        gallery_images = gallery_images[:max_gallery]
+        final_images = [main_image] + gallery_images if main_image else gallery_images
+        return main_image, gallery_images, final_images
 
     def _extract_dynamic_images(self, raw: str) -> list[str]:
         """Extrait les URLs du JSON data-a-dynamic-image."""
@@ -393,8 +441,111 @@ class AmazonStore(BaseStore):
                         if key and value:
                             specs[key] = value
 
+        # Détails de l'article sous forme de liste
+        detail_list = soup.select("#detailBullets_feature_div li")
+        for item in detail_list:
+            text = item.get_text(" ", strip=True)
+            if ":" not in text:
+                continue
+            key, value = text.split(":", 1)
+            key = key.strip()
+            value = value.strip()
+            if key and value and key not in specs:
+                specs[key] = value
+
         return specs
 
+    def _extract_rating_value(self, soup: BeautifulSoup, debug: DebugInfo) -> Optional[float]:
+        """Extrait la note moyenne."""
+        selectors = self.get_selector("rating_value", [])
+        if isinstance(selectors, str):
+            selectors = [selectors]
+
+        for selector in selectors:
+            element = soup.select_one(selector)
+            if not element:
+                continue
+            text = element.get_text(" ", strip=True) or element.get("title", "").strip()
+            match = re.search(r"([\d.,]+)", text)
+            if match:
+                value = match.group(1).replace(",", ".")
+                try:
+                    return float(value)
+                except ValueError:
+                    continue
+        return None
+
+    def _extract_rating_count(self, soup: BeautifulSoup, debug: DebugInfo) -> Optional[int]:
+        """Extrait le nombre d'évaluations."""
+        selectors = self.get_selector("rating_count", [])
+        if isinstance(selectors, str):
+            selectors = [selectors]
+
+        for selector in selectors:
+            element = soup.select_one(selector)
+            if not element:
+                continue
+            text = element.get_text(" ", strip=True)
+            match = re.search(r"([\d\s\u202f\u00a0]+)", text)
+            if match:
+                numeric = re.sub(r"[^\d]", "", match.group(1))
+                if numeric:
+                    return int(numeric)
+        return None
+
+    def _extract_amazon_choice(
+        self, soup: BeautifulSoup, debug: DebugInfo
+    ) -> tuple[Optional[bool], Optional[str]]:
+        """Extrait le badge Choix d'Amazon."""
+        selectors = self.get_selector("amazon_choice", [])
+        if isinstance(selectors, str):
+            selectors = [selectors]
+
+        for selector in selectors:
+            element = soup.select_one(selector)
+            if element:
+                label_candidates = [
+                    element.get_text(" ", strip=True),
+                    element.get("aria-label", "").strip(),
+                    element.get("title", "").strip(),
+                    element.get("data-a-badge-label", "").strip(),
+                ]
+                label = next((item for item in label_candidates if item), "")
+                normalized = label.lower()
+                if "choix d'amazon" in normalized or "amazon's choice" in normalized:
+                    return True, label
+                if label:
+                    return True, label
+                return True, None
+        return None, None
+
+    def _extract_discount_text(self, soup: BeautifulSoup, debug: DebugInfo) -> Optional[str]:
+        """Extrait le texte de réduction explicite."""
+        selectors = self.get_selector("discount_text", [])
+        if isinstance(selectors, str):
+            selectors = [selectors]
+
+        for selector in selectors:
+            element = soup.select_one(selector)
+            if not element:
+                continue
+            text = element.get_text(" ", strip=True)
+            if text:
+                return text
+        return None
+
+    def _extract_model_details(self, specs: dict[str, str]) -> tuple[Optional[str], Optional[str]]:
+        """Extrait le numero et le nom du modele depuis les specs."""
+        model_number = None
+        model_name = None
+        for key, value in specs.items():
+            normalized = key.lower()
+            if "numéro du modèle de l'article" in normalized or "numero du modele de l'article" in normalized:
+                model_number = value
+            if "nom du modèle" in normalized or "nom du modele" in normalized:
+                model_name = value
+        return model_number, model_name
+
     def _extract_asin_from_html(self, soup: BeautifulSoup) -> Optional[str]:
         """Extrait l'ASIN depuis le HTML (fallback)."""
         selectors = self.get_selector("asin", [])

pricewatch/app/tasks/scheduler.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
+import hashlib
 from typing import Optional
 
 import redis
@@ -127,11 +128,13 @@ class ScrapingScheduler:
         interval_hours: int = 24,
         use_playwright: Optional[bool] = None,
         save_db: bool = True,
+        job_id: Optional[str] = None,
     ) -> ScheduledJobInfo:
         """Planifie un scraping recurrent (intervalle en heures)."""
         interval_seconds = int(timedelta(hours=interval_hours).total_seconds())
         next_run = datetime.now(timezone.utc) + timedelta(seconds=interval_seconds)
 
+        resolved_job_id = job_id or self._job_id_for_url(url)
         job = self.scheduler.schedule(
             scheduled_time=next_run,
             func=scrape_product,
@@ -139,6 +142,13 @@ class ScrapingScheduler:
             kwargs={"use_playwright": use_playwright, "save_db": save_db},
             interval=interval_seconds,
             repeat=None,
+            id=resolved_job_id,
         )
         logger.info(f"Job planifie: {job.id}, prochaine execution: {next_run.isoformat()}")
         return ScheduledJobInfo(job_id=job.id, next_run=next_run)
+
+    @staticmethod
+    def _job_id_for_url(url: str) -> str:
+        """Genere un job_id stable pour eviter les doublons."""
+        fingerprint = hashlib.sha1(url.strip().lower().encode("utf-8")).hexdigest()
+        return f"scrape_{fingerprint}"

pricewatch/app/tasks/scrape.py

@@ -157,6 +157,36 @@ def scrape_product(
             )
             success = False
             fetch_error = str(exc)
+        # Si captcha detecte via HTTP, forcer une tentative Playwright.
+        if (
+            fetch_method == FetchMethod.HTTP
+            and use_playwright
+            and snapshot.debug.errors
+            and any("captcha" in error.lower() for error in snapshot.debug.errors)
+        ):
+            logger.info("[FETCH] Captcha detecte, tentative Playwright")
+            pw_result = fetch_playwright(
+                canonical_url,
+                headless=not headful,
+                timeout_ms=timeout_ms,
+                save_screenshot=save_screenshot,
+            )
+            if pw_result.success and pw_result.html:
+                try:
+                    snapshot = store.parse(pw_result.html, canonical_url)
+                    snapshot.debug.method = FetchMethod.PLAYWRIGHT
+                    snapshot.debug.duration_ms = pw_result.duration_ms
+                    snapshot.debug.html_size_bytes = len(pw_result.html.encode("utf-8"))
+                    snapshot.add_note("Captcha detecte via HTTP, fallback Playwright")
+                    success = snapshot.debug.status != DebugStatus.FAILED
+                except Exception as exc:
+                    snapshot.add_note(f"Fallback Playwright echoue: {exc}")
+                    logger.error(f"[PARSE] Exception fallback Playwright: {exc}")
+                    fetch_error = str(exc)
+            else:
+                error = pw_result.error or "Erreur Playwright"
+                snapshot.add_note(f"Fallback Playwright echoue: {error}")
+                fetch_error = error
     else:
         snapshot = ProductSnapshot(
             source=store.store_id,

webui/dist/favicon.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <rect width="64" height="64" rx="14" fill="#3c3836" />
+  <circle cx="32" cy="32" r="18" fill="#fe8019" />
+  <path d="M18 34c6-6 22-6 28 0" fill="none" stroke="#282828" stroke-width="4" stroke-linecap="round" />
+</svg>

webui/dist/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html lang="fr">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>PriceWatch Web UI</title>
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <script type="module" crossorigin src="/assets/index-ZvFbjZEA.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BURbFjJa.css">
+  </head>
+  <body>
+    <div id="app"></div>
+  </body>
+</html>

webui/node_modules/.bin/autoprefixer

@@ -0,0 +1 @@
+../autoprefixer/bin/autoprefixer

webui/node_modules/.bin/baseline-browser-mapping

@@ -0,0 +1 @@
+../baseline-browser-mapping/dist/cli.js

webui/node_modules/.bin/browserslist

@@ -0,0 +1 @@
+../browserslist/cli.js

webui/node_modules/.bin/cssesc

@@ -0,0 +1 @@
+../cssesc/bin/cssesc

webui/node_modules/.bin/esbuild

@@ -0,0 +1 @@
+../esbuild/bin/esbuild

webui/node_modules/.bin/jiti

@@ -0,0 +1 @@
+../jiti/bin/jiti.js

webui/node_modules/.bin/nanoid

@@ -0,0 +1 @@
+../nanoid/bin/nanoid.cjs

webui/node_modules/.bin/parser

@@ -0,0 +1 @@
+../@babel/parser/bin/babel-parser.js

webui/node_modules/.bin/resolve

@@ -0,0 +1 @@
+../resolve/bin/resolve

webui/node_modules/.bin/rollup

@@ -0,0 +1 @@
+../rollup/dist/bin/rollup

webui/node_modules/.bin/sucrase

@@ -0,0 +1 @@
+../sucrase/bin/sucrase

webui/node_modules/.bin/sucrase-node

@@ -0,0 +1 @@
+../sucrase/bin/sucrase-node

webui/node_modules/.bin/tailwind

@@ -0,0 +1 @@
+../tailwindcss/lib/cli.js

webui/node_modules/.bin/tailwindcss

@@ -0,0 +1 @@
+../tailwindcss/lib/cli.js

webui/node_modules/.bin/tsc

@@ -0,0 +1 @@
+../typescript/bin/tsc

webui/node_modules/.bin/tsserver

@@ -0,0 +1 @@
+../typescript/bin/tsserver

webui/node_modules/.bin/update-browserslist-db

@@ -0,0 +1 @@
+../update-browserslist-db/cli.js

webui/node_modules/.bin/vite

@@ -0,0 +1 @@
+../vite/bin/vite.js

webui/node_modules/.bin/vue-tsc

@@ -0,0 +1 @@
+../vue-tsc/bin/vue-tsc.js

webui/node_modules/@alloc/quick-lru/index.d.ts

@@ -0,0 +1,128 @@
+declare namespace QuickLRU {
+	interface Options<KeyType, ValueType> {
+		/**
+		The maximum number of milliseconds an item should remain in the cache.
+
+		@default Infinity
+
+		By default, `maxAge` will be `Infinity`, which means that items will never expire.
+		Lazy expiration upon the next write or read call.
+
+		Individual expiration of an item can be specified by the `set(key, value, maxAge)` method.
+		*/
+		readonly maxAge?: number;
+
+		/**
+		The maximum number of items before evicting the least recently used items.
+		*/
+		readonly maxSize: number;
+
+		/**
+		Called right before an item is evicted from the cache.
+
+		Useful for side effects or for items like object URLs that need explicit cleanup (`revokeObjectURL`).
+		*/
+		onEviction?: (key: KeyType, value: ValueType) => void;
+	}
+}
+
+declare class QuickLRU<KeyType, ValueType>
+	implements Iterable<[KeyType, ValueType]> {
+	/**
+	The stored item count.
+	*/
+	readonly size: number;
+
+	/**
+	Simple ["Least Recently Used" (LRU) cache](https://en.m.wikipedia.org/wiki/Cache_replacement_policies#Least_Recently_Used_.28LRU.29).
+
+	The instance is [`iterable`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols) so you can use it directly in a [`for…of`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/for...of) loop.
+
+	@example
+	```
+	import QuickLRU = require('quick-lru');
+
+	const lru = new QuickLRU({maxSize: 1000});
+
+	lru.set('🦄', '🌈');
+
+	lru.has('🦄');
+	//=> true
+
+	lru.get('🦄');
+	//=> '🌈'
+	```
+	*/
+	constructor(options: QuickLRU.Options<KeyType, ValueType>);
+
+	[Symbol.iterator](): IterableIterator<[KeyType, ValueType]>;
+
+	/**
+	Set an item. Returns the instance.
+
+	Individual expiration of an item can be specified with the `maxAge` option. If not specified, the global `maxAge` value will be used in case it is specified in the constructor, otherwise the item will never expire.
+
+	@returns The list instance.
+	*/
+	set(key: KeyType, value: ValueType, options?: {maxAge?: number}): this;
+
+	/**
+	Get an item.
+
+	@returns The stored item or `undefined`.
+	*/
+	get(key: KeyType): ValueType | undefined;
+
+	/**
+	Check if an item exists.
+	*/
+	has(key: KeyType): boolean;
+
+	/**
+	Get an item without marking it as recently used.
+
+	@returns The stored item or `undefined`.
+	*/
+	peek(key: KeyType): ValueType | undefined;
+
+	/**
+	Delete an item.
+
+	@returns `true` if the item is removed or `false` if the item doesn't exist.
+	*/
+	delete(key: KeyType): boolean;
+
+	/**
+	Delete all items.
+	*/
+	clear(): void;
+
+	/**
+	Update the `maxSize` in-place, discarding items as necessary. Insertion order is mostly preserved, though this is not a strong guarantee.
+
+	Useful for on-the-fly tuning of cache sizes in live systems.
+	*/
+	resize(maxSize: number): void;
+
+	/**
+	Iterable for all the keys.
+	*/
+	keys(): IterableIterator<KeyType>;
+
+	/**
+	Iterable for all the values.
+	*/
+	values(): IterableIterator<ValueType>;
+
+	/**
+	Iterable for all entries, starting with the oldest (ascending in recency).
+	*/
+	entriesAscending(): IterableIterator<[KeyType, ValueType]>;
+
+	/**
+	Iterable for all entries, starting with the newest (descending in recency).
+	*/
+	entriesDescending(): IterableIterator<[KeyType, ValueType]>;
+}
+
+export = QuickLRU;

webui/node_modules/@alloc/quick-lru/index.js

@@ -0,0 +1,263 @@
+'use strict';
+
+class QuickLRU {
+	constructor(options = {}) {
+		if (!(options.maxSize && options.maxSize > 0)) {
+			throw new TypeError('`maxSize` must be a number greater than 0');
+		}
+
+		if (typeof options.maxAge === 'number' && options.maxAge === 0) {
+			throw new TypeError('`maxAge` must be a number greater than 0');
+		}
+
+		this.maxSize = options.maxSize;
+		this.maxAge = options.maxAge || Infinity;
+		this.onEviction = options.onEviction;
+		this.cache = new Map();
+		this.oldCache = new Map();
+		this._size = 0;
+	}
+
+	_emitEvictions(cache) {
+		if (typeof this.onEviction !== 'function') {
+			return;
+		}
+
+		for (const [key, item] of cache) {
+			this.onEviction(key, item.value);
+		}
+	}
+
+	_deleteIfExpired(key, item) {
+		if (typeof item.expiry === 'number' && item.expiry <= Date.now()) {
+			if (typeof this.onEviction === 'function') {
+				this.onEviction(key, item.value);
+			}
+
+			return this.delete(key);
+		}
+
+		return false;
+	}
+
+	_getOrDeleteIfExpired(key, item) {
+		const deleted = this._deleteIfExpired(key, item);
+		if (deleted === false) {
+			return item.value;
+		}
+	}
+
+	_getItemValue(key, item) {
+		return item.expiry ? this._getOrDeleteIfExpired(key, item) : item.value;
+	}
+
+	_peek(key, cache) {
+		const item = cache.get(key);
+
+		return this._getItemValue(key, item);
+	}
+
+	_set(key, value) {
+		this.cache.set(key, value);
+		this._size++;
+
+		if (this._size >= this.maxSize) {
+			this._size = 0;
+			this._emitEvictions(this.oldCache);
+			this.oldCache = this.cache;
+			this.cache = new Map();
+		}
+	}
+
+	_moveToRecent(key, item) {
+		this.oldCache.delete(key);
+		this._set(key, item);
+	}
+
+	* _entriesAscending() {
+		for (const item of this.oldCache) {
+			const [key, value] = item;
+			if (!this.cache.has(key)) {
+				const deleted = this._deleteIfExpired(key, value);
+				if (deleted === false) {
+					yield item;
+				}
+			}
+		}
+
+		for (const item of this.cache) {
+			const [key, value] = item;
+			const deleted = this._deleteIfExpired(key, value);
+			if (deleted === false) {
+				yield item;
+			}
+		}
+	}
+
+	get(key) {
+		if (this.cache.has(key)) {
+			const item = this.cache.get(key);
+
+			return this._getItemValue(key, item);
+		}
+
+		if (this.oldCache.has(key)) {
+			const item = this.oldCache.get(key);
+			if (this._deleteIfExpired(key, item) === false) {
+				this._moveToRecent(key, item);
+				return item.value;
+			}
+		}
+	}
+
+	set(key, value, {maxAge = this.maxAge === Infinity ? undefined : Date.now() + this.maxAge} = {}) {
+		if (this.cache.has(key)) {
+			this.cache.set(key, {
+				value,
+				maxAge
+			});
+		} else {
+			this._set(key, {value, expiry: maxAge});
+		}
+	}
+
+	has(key) {
+		if (this.cache.has(key)) {
+			return !this._deleteIfExpired(key, this.cache.get(key));
+		}
+
+		if (this.oldCache.has(key)) {
+			return !this._deleteIfExpired(key, this.oldCache.get(key));
+		}
+
+		return false;
+	}
+
+	peek(key) {
+		if (this.cache.has(key)) {
+			return this._peek(key, this.cache);
+		}
+
+		if (this.oldCache.has(key)) {
+			return this._peek(key, this.oldCache);
+		}
+	}
+
+	delete(key) {
+		const deleted = this.cache.delete(key);
+		if (deleted) {
+			this._size--;
+		}
+
+		return this.oldCache.delete(key) || deleted;
+	}
+
+	clear() {
+		this.cache.clear();
+		this.oldCache.clear();
+		this._size = 0;
+	}
+	
+	resize(newSize) {
+		if (!(newSize && newSize > 0)) {
+			throw new TypeError('`maxSize` must be a number greater than 0');
+		}
+
+		const items = [...this._entriesAscending()];
+		const removeCount = items.length - newSize;
+		if (removeCount < 0) {
+			this.cache = new Map(items);
+			this.oldCache = new Map();
+			this._size = items.length;
+		} else {
+			if (removeCount > 0) {
+				this._emitEvictions(items.slice(0, removeCount));
+			}
+
+			this.oldCache = new Map(items.slice(removeCount));
+			this.cache = new Map();
+			this._size = 0;
+		}
+
+		this.maxSize = newSize;
+	}
+
+	* keys() {
+		for (const [key] of this) {
+			yield key;
+		}
+	}
+
+	* values() {
+		for (const [, value] of this) {
+			yield value;
+		}
+	}
+
+	* [Symbol.iterator]() {
+		for (const item of this.cache) {
+			const [key, value] = item;
+			const deleted = this._deleteIfExpired(key, value);
+			if (deleted === false) {
+				yield [key, value.value];
+			}
+		}
+
+		for (const item of this.oldCache) {
+			const [key, value] = item;
+			if (!this.cache.has(key)) {
+				const deleted = this._deleteIfExpired(key, value);
+				if (deleted === false) {
+					yield [key, value.value];
+				}
+			}
+		}
+	}
+
+	* entriesDescending() {
+		let items = [...this.cache];
+		for (let i = items.length - 1; i >= 0; --i) {
+			const item = items[i];
+			const [key, value] = item;
+			const deleted = this._deleteIfExpired(key, value);
+			if (deleted === false) {
+				yield [key, value.value];
+			}
+		}
+
+		items = [...this.oldCache];
+		for (let i = items.length - 1; i >= 0; --i) {
+			const item = items[i];
+			const [key, value] = item;
+			if (!this.cache.has(key)) {
+				const deleted = this._deleteIfExpired(key, value);
+				if (deleted === false) {
+					yield [key, value.value];
+				}
+			}
+		}
+	}
+
+	* entriesAscending() {
+		for (const [key, value] of this._entriesAscending()) {
+			yield [key, value.value];
+		}
+	}
+
+	get size() {
+		if (!this._size) {
+			return this.oldCache.size;
+		}
+
+		let oldCacheSize = 0;
+		for (const key of this.oldCache.keys()) {
+			if (!this.cache.has(key)) {
+				oldCacheSize++;
+			}
+		}
+
+		return Math.min(this._size + oldCacheSize, this.maxSize);
+	}
+}
+
+module.exports = QuickLRU;

webui/node_modules/@alloc/quick-lru/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

webui/node_modules/@alloc/quick-lru/package.json

@@ -0,0 +1,43 @@
+{
+	"name": "@alloc/quick-lru",
+	"version": "5.2.0",
+	"description": "Simple “Least Recently Used” (LRU) cache",
+	"license": "MIT",
+	"repository": "sindresorhus/quick-lru",
+	"funding": "https://github.com/sponsors/sindresorhus",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "https://sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=10"
+	},
+	"scripts": {
+		"test": "xo && nyc ava && tsd"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"lru",
+		"quick",
+		"cache",
+		"caching",
+		"least",
+		"recently",
+		"used",
+		"fast",
+		"map",
+		"hash",
+		"buffer"
+	],
+	"devDependencies": {
+		"ava": "^2.0.0",
+		"coveralls": "^3.0.3",
+		"nyc": "^15.0.0",
+		"tsd": "^0.11.0",
+		"xo": "^0.26.0"
+	}
+}

webui/node_modules/@alloc/quick-lru/readme.md

@@ -0,0 +1,139 @@
+# quick-lru [![Build Status](https://travis-ci.org/sindresorhus/quick-lru.svg?branch=master)](https://travis-ci.org/sindresorhus/quick-lru) [![Coverage Status](https://coveralls.io/repos/github/sindresorhus/quick-lru/badge.svg?branch=master)](https://coveralls.io/github/sindresorhus/quick-lru?branch=master)
+
+> Simple [“Least Recently Used” (LRU) cache](https://en.m.wikipedia.org/wiki/Cache_replacement_policies#Least_Recently_Used_.28LRU.29)
+
+Useful when you need to cache something and limit memory usage.
+
+Inspired by the [`hashlru` algorithm](https://github.com/dominictarr/hashlru#algorithm), but instead uses [`Map`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Map) to support keys of any type, not just strings, and values can be `undefined`.
+
+## Install
+
+```
+$ npm install quick-lru
+```
+
+## Usage
+
+```js
+const QuickLRU = require('quick-lru');
+
+const lru = new QuickLRU({maxSize: 1000});
+
+lru.set('🦄', '🌈');
+
+lru.has('🦄');
+//=> true
+
+lru.get('🦄');
+//=> '🌈'
+```
+
+## API
+
+### new QuickLRU(options?)
+
+Returns a new instance.
+
+### options
+
+Type: `object`
+
+#### maxSize
+
+*Required*\
+Type: `number`
+
+The maximum number of items before evicting the least recently used items.
+
+#### maxAge
+
+Type: `number`\
+Default: `Infinity`
+
+The maximum number of milliseconds an item should remain in cache.
+By default maxAge will be Infinity, which means that items will never expire.
+
+Lazy expiration happens upon the next `write` or `read` call.
+
+Individual expiration of an item can be specified by the `set(key, value, options)` method.
+
+#### onEviction
+
+*Optional*\
+Type: `(key, value) => void`
+
+Called right before an item is evicted from the cache.
+
+Useful for side effects or for items like object URLs that need explicit cleanup (`revokeObjectURL`).
+
+### Instance
+
+The instance is [`iterable`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Iteration_protocols) so you can use it directly in a [`for…of`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/for...of) loop.
+
+Both `key` and `value` can be of any type.
+
+#### .set(key, value, options?)
+
+Set an item. Returns the instance.
+
+Individual expiration of an item can be specified with the `maxAge` option. If not specified, the global `maxAge` value will be used in case it is specified on the constructor, otherwise the item will never expire.
+
+#### .get(key)
+
+Get an item.
+
+#### .has(key)
+
+Check if an item exists.
+
+#### .peek(key)
+
+Get an item without marking it as recently used.
+
+#### .delete(key)
+
+Delete an item.
+
+Returns `true` if the item is removed or `false` if the item doesn't exist.
+
+#### .clear()
+
+Delete all items.
+
+#### .resize(maxSize)
+
+Update the `maxSize`, discarding items as necessary. Insertion order is mostly preserved, though this is not a strong guarantee.
+
+Useful for on-the-fly tuning of cache sizes in live systems.
+
+#### .keys()
+
+Iterable for all the keys.
+
+#### .values()
+
+Iterable for all the values.
+
+#### .entriesAscending()
+
+Iterable for all entries, starting with the oldest (ascending in recency).
+
+#### .entriesDescending()
+
+Iterable for all entries, starting with the newest (descending in recency).
+
+#### .size
+
+The stored item count.
+
+---
+
+<div align="center">
+	<b>
+		<a href="https://tidelift.com/subscription/pkg/npm-quick-lru?utm_source=npm-quick-lru&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
+	</b>
+	<br>
+	<sub>
+		Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
+	</sub>
+</div>

webui/node_modules/@babel/helper-string-parser/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

webui/node_modules/@babel/helper-string-parser/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-string-parser
+
+> A utility package to parse strings
+
+See our website [@babel/helper-string-parser](https://babeljs.io/docs/babel-helper-string-parser) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-string-parser
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-string-parser
+```

webui/node_modules/@babel/helper-string-parser/lib/index.js

@@ -0,0 +1,295 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readCodePoint = readCodePoint;
+exports.readInt = readInt;
+exports.readStringContents = readStringContents;
+var _isDigit = function isDigit(code) {
+  return code >= 48 && code <= 57;
+};
+const forbiddenNumericSeparatorSiblings = {
+  decBinOct: new Set([46, 66, 69, 79, 95, 98, 101, 111]),
+  hex: new Set([46, 88, 95, 120])
+};
+const isAllowedNumericSeparatorSibling = {
+  bin: ch => ch === 48 || ch === 49,
+  oct: ch => ch >= 48 && ch <= 55,
+  dec: ch => ch >= 48 && ch <= 57,
+  hex: ch => ch >= 48 && ch <= 57 || ch >= 65 && ch <= 70 || ch >= 97 && ch <= 102
+};
+function readStringContents(type, input, pos, lineStart, curLine, errors) {
+  const initialPos = pos;
+  const initialLineStart = lineStart;
+  const initialCurLine = curLine;
+  let out = "";
+  let firstInvalidLoc = null;
+  let chunkStart = pos;
+  const {
+    length
+  } = input;
+  for (;;) {
+    if (pos >= length) {
+      errors.unterminated(initialPos, initialLineStart, initialCurLine);
+      out += input.slice(chunkStart, pos);
+      break;
+    }
+    const ch = input.charCodeAt(pos);
+    if (isStringEnd(type, ch, input, pos)) {
+      out += input.slice(chunkStart, pos);
+      break;
+    }
+    if (ch === 92) {
+      out += input.slice(chunkStart, pos);
+      const res = readEscapedChar(input, pos, lineStart, curLine, type === "template", errors);
+      if (res.ch === null && !firstInvalidLoc) {
+        firstInvalidLoc = {
+          pos,
+          lineStart,
+          curLine
+        };
+      } else {
+        out += res.ch;
+      }
+      ({
+        pos,
+        lineStart,
+        curLine
+      } = res);
+      chunkStart = pos;
+    } else if (ch === 8232 || ch === 8233) {
+      ++pos;
+      ++curLine;
+      lineStart = pos;
+    } else if (ch === 10 || ch === 13) {
+      if (type === "template") {
+        out += input.slice(chunkStart, pos) + "\n";
+        ++pos;
+        if (ch === 13 && input.charCodeAt(pos) === 10) {
+          ++pos;
+        }
+        ++curLine;
+        chunkStart = lineStart = pos;
+      } else {
+        errors.unterminated(initialPos, initialLineStart, initialCurLine);
+      }
+    } else {
+      ++pos;
+    }
+  }
+  return {
+    pos,
+    str: out,
+    firstInvalidLoc,
+    lineStart,
+    curLine,
+    containsInvalid: !!firstInvalidLoc
+  };
+}
+function isStringEnd(type, ch, input, pos) {
+  if (type === "template") {
+    return ch === 96 || ch === 36 && input.charCodeAt(pos + 1) === 123;
+  }
+  return ch === (type === "double" ? 34 : 39);
+}
+function readEscapedChar(input, pos, lineStart, curLine, inTemplate, errors) {
+  const throwOnInvalid = !inTemplate;
+  pos++;
+  const res = ch => ({
+    pos,
+    ch,
+    lineStart,
+    curLine
+  });
+  const ch = input.charCodeAt(pos++);
+  switch (ch) {
+    case 110:
+      return res("\n");
+    case 114:
+      return res("\r");
+    case 120:
+      {
+        let code;
+        ({
+          code,
+          pos
+        } = readHexChar(input, pos, lineStart, curLine, 2, false, throwOnInvalid, errors));
+        return res(code === null ? null : String.fromCharCode(code));
+      }
+    case 117:
+      {
+        let code;
+        ({
+          code,
+          pos
+        } = readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors));
+        return res(code === null ? null : String.fromCodePoint(code));
+      }
+    case 116:
+      return res("\t");
+    case 98:
+      return res("\b");
+    case 118:
+      return res("\u000b");
+    case 102:
+      return res("\f");
+    case 13:
+      if (input.charCodeAt(pos) === 10) {
+        ++pos;
+      }
+    case 10:
+      lineStart = pos;
+      ++curLine;
+    case 8232:
+    case 8233:
+      return res("");
+    case 56:
+    case 57:
+      if (inTemplate) {
+        return res(null);
+      } else {
+        errors.strictNumericEscape(pos - 1, lineStart, curLine);
+      }
+    default:
+      if (ch >= 48 && ch <= 55) {
+        const startPos = pos - 1;
+        const match = /^[0-7]+/.exec(input.slice(startPos, pos + 2));
+        let octalStr = match[0];
+        let octal = parseInt(octalStr, 8);
+        if (octal > 255) {
+          octalStr = octalStr.slice(0, -1);
+          octal = parseInt(octalStr, 8);
+        }
+        pos += octalStr.length - 1;
+        const next = input.charCodeAt(pos);
+        if (octalStr !== "0" || next === 56 || next === 57) {
+          if (inTemplate) {
+            return res(null);
+          } else {
+            errors.strictNumericEscape(startPos, lineStart, curLine);
+          }
+        }
+        return res(String.fromCharCode(octal));
+      }
+      return res(String.fromCharCode(ch));
+  }
+}
+function readHexChar(input, pos, lineStart, curLine, len, forceLen, throwOnInvalid, errors) {
+  const initialPos = pos;
+  let n;
+  ({
+    n,
+    pos
+  } = readInt(input, pos, lineStart, curLine, 16, len, forceLen, false, errors, !throwOnInvalid));
+  if (n === null) {
+    if (throwOnInvalid) {
+      errors.invalidEscapeSequence(initialPos, lineStart, curLine);
+    } else {
+      pos = initialPos - 1;
+    }
+  }
+  return {
+    code: n,
+    pos
+  };
+}
+function readInt(input, pos, lineStart, curLine, radix, len, forceLen, allowNumSeparator, errors, bailOnError) {
+  const start = pos;
+  const forbiddenSiblings = radix === 16 ? forbiddenNumericSeparatorSiblings.hex : forbiddenNumericSeparatorSiblings.decBinOct;
+  const isAllowedSibling = radix === 16 ? isAllowedNumericSeparatorSibling.hex : radix === 10 ? isAllowedNumericSeparatorSibling.dec : radix === 8 ? isAllowedNumericSeparatorSibling.oct : isAllowedNumericSeparatorSibling.bin;
+  let invalid = false;
+  let total = 0;
+  for (let i = 0, e = len == null ? Infinity : len; i < e; ++i) {
+    const code = input.charCodeAt(pos);
+    let val;
+    if (code === 95 && allowNumSeparator !== "bail") {
+      const prev = input.charCodeAt(pos - 1);
+      const next = input.charCodeAt(pos + 1);
+      if (!allowNumSeparator) {
+        if (bailOnError) return {
+          n: null,
+          pos
+        };
+        errors.numericSeparatorInEscapeSequence(pos, lineStart, curLine);
+      } else if (Number.isNaN(next) || !isAllowedSibling(next) || forbiddenSiblings.has(prev) || forbiddenSiblings.has(next)) {
+        if (bailOnError) return {
+          n: null,
+          pos
+        };
+        errors.unexpectedNumericSeparator(pos, lineStart, curLine);
+      }
+      ++pos;
+      continue;
+    }
+    if (code >= 97) {
+      val = code - 97 + 10;
+    } else if (code >= 65) {
+      val = code - 65 + 10;
+    } else if (_isDigit(code)) {
+      val = code - 48;
+    } else {
+      val = Infinity;
+    }
+    if (val >= radix) {
+      if (val <= 9 && bailOnError) {
+        return {
+          n: null,
+          pos
+        };
+      } else if (val <= 9 && errors.invalidDigit(pos, lineStart, curLine, radix)) {
+        val = 0;
+      } else if (forceLen) {
+        val = 0;
+        invalid = true;
+      } else {
+        break;
+      }
+    }
+    ++pos;
+    total = total * radix + val;
+  }
+  if (pos === start || len != null && pos - start !== len || invalid) {
+    return {
+      n: null,
+      pos
+    };
+  }
+  return {
+    n: total,
+    pos
+  };
+}
+function readCodePoint(input, pos, lineStart, curLine, throwOnInvalid, errors) {
+  const ch = input.charCodeAt(pos);
+  let code;
+  if (ch === 123) {
+    ++pos;
+    ({
+      code,
+      pos
+    } = readHexChar(input, pos, lineStart, curLine, input.indexOf("}", pos) - pos, true, throwOnInvalid, errors));
+    ++pos;
+    if (code !== null && code > 0x10ffff) {
+      if (throwOnInvalid) {
+        errors.invalidCodePoint(pos, lineStart, curLine);
+      } else {
+        return {
+          code: null,
+          pos
+        };
+      }
+    }
+  } else {
+    ({
+      code,
+      pos
+    } = readHexChar(input, pos, lineStart, curLine, 4, false, throwOnInvalid, errors));
+  }
+  return {
+    code,
+    pos
+  };
+}
+
+//# sourceMappingURL=index.js.map

webui/node_modules/@babel/helper-string-parser/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@babel/helper-string-parser",
+  "version": "7.27.1",
+  "description": "A utility package to parse strings",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-string-parser"
+  },
+  "homepage": "https://babel.dev/docs/en/next/babel-helper-string-parser",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "devDependencies": {
+    "charcodes": "^0.2.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "type": "commonjs"
+}

webui/node_modules/@babel/helper-validator-identifier/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2014-present Sebastian McKenzie and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

webui/node_modules/@babel/helper-validator-identifier/README.md

@@ -0,0 +1,19 @@
+# @babel/helper-validator-identifier
+
+> Validate identifier/keywords name
+
+See our website [@babel/helper-validator-identifier](https://babeljs.io/docs/babel-helper-validator-identifier) for more information.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save @babel/helper-validator-identifier
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/helper-validator-identifier
+```

webui/node_modules/@babel/helper-validator-identifier/lib/identifier.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isIdentifierChar = isIdentifierChar;
+exports.isIdentifierName = isIdentifierName;
+exports.isIdentifierStart = isIdentifierStart;
+let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088f\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5c\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdc-\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c8a\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7dc\ua7f1-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
+let nonASCIIidentifierChars = "\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0897-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0cf3\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1add\u1ae0-\u1aeb\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\u30fb\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f\uff65";
+const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
+const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
+nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
+const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 4, 51, 13, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 7, 25, 39, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 39, 27, 10, 22, 251, 41, 7, 1, 17, 5, 57, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 20, 1, 64, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 31, 9, 2, 0, 3, 0, 2, 37, 2, 0, 26, 0, 2, 0, 45, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 200, 32, 32, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 24, 43, 261, 18, 16, 0, 2, 12, 2, 33, 125, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1071, 18, 5, 26, 3994, 6, 582, 6842, 29, 1763, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 433, 44, 212, 63, 33, 24, 3, 24, 45, 74, 6, 0, 67, 12, 65, 1, 2, 0, 15, 4, 10, 7381, 42, 31, 98, 114, 8702, 3, 2, 6, 2, 1, 2, 290, 16, 0, 30, 2, 3, 0, 15, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 7, 5, 262, 61, 147, 44, 11, 6, 17, 0, 322, 29, 19, 43, 485, 27, 229, 29, 3, 0, 208, 30, 2, 2, 2, 1, 2, 6, 3, 4, 10, 1, 225, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4381, 3, 5773, 3, 7472, 16, 621, 2467, 541, 1507, 4938, 6, 8489];
+const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 7, 9, 32, 4, 318, 1, 78, 5, 71, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 3, 0, 158, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 68, 8, 2, 0, 3, 0, 2, 3, 2, 4, 2, 0, 15, 1, 83, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 7, 19, 58, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 199, 7, 137, 9, 54, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 55, 9, 266, 3, 10, 1, 2, 0, 49, 6, 4, 4, 14, 10, 5350, 0, 7, 14, 11465, 27, 2343, 9, 87, 9, 39, 4, 60, 6, 26, 9, 535, 9, 470, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4178, 9, 519, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 101, 0, 161, 6, 10, 9, 357, 0, 62, 13, 499, 13, 245, 1, 2, 9, 233, 0, 3, 0, 8, 1, 6, 0, 475, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
+function isInAstralSet(code, set) {
+  let pos = 0x10000;
+  for (let i = 0, length = set.length; i < length; i += 2) {
+    pos += set[i];
+    if (pos > code) return false;
+    pos += set[i + 1];
+    if (pos >= code) return true;
+  }
+  return false;
+}
+function isIdentifierStart(code) {
+  if (code < 65) return code === 36;
+  if (code <= 90) return true;
+  if (code < 97) return code === 95;
+  if (code <= 122) return true;
+  if (code <= 0xffff) {
+    return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
+  }
+  return isInAstralSet(code, astralIdentifierStartCodes);
+}
+function isIdentifierChar(code) {
+  if (code < 48) return code === 36;
+  if (code < 58) return true;
+  if (code < 65) return false;
+  if (code <= 90) return true;
+  if (code < 97) return code === 95;
+  if (code <= 122) return true;
+  if (code <= 0xffff) {
+    return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
+  }
+  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
+}
+function isIdentifierName(name) {
+  let isFirst = true;
+  for (let i = 0; i < name.length; i++) {
+    let cp = name.charCodeAt(i);
+    if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) {
+      const trail = name.charCodeAt(++i);
+      if ((trail & 0xfc00) === 0xdc00) {
+        cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);
+      }
+    }
+    if (isFirst) {
+      isFirst = false;
+      if (!isIdentifierStart(cp)) {
+        return false;
+      }
+    } else if (!isIdentifierChar(cp)) {
+      return false;
+    }
+  }
+  return !isFirst;
+}
+
+//# sourceMappingURL=identifier.js.map

webui/node_modules/@babel/helper-validator-identifier/lib/index.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "isIdentifierChar", {
+  enumerable: true,
+  get: function () {
+    return _identifier.isIdentifierChar;
+  }
+});
+Object.defineProperty(exports, "isIdentifierName", {
+  enumerable: true,
+  get: function () {
+    return _identifier.isIdentifierName;
+  }
+});
+Object.defineProperty(exports, "isIdentifierStart", {
+  enumerable: true,
+  get: function () {
+    return _identifier.isIdentifierStart;
+  }
+});
+Object.defineProperty(exports, "isKeyword", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isKeyword;
+  }
+});
+Object.defineProperty(exports, "isReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isStrictBindOnlyReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictBindReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isStrictBindReservedWord;
+  }
+});
+Object.defineProperty(exports, "isStrictReservedWord", {
+  enumerable: true,
+  get: function () {
+    return _keyword.isStrictReservedWord;
+  }
+});
+var _identifier = require("./identifier.js");
+var _keyword = require("./keyword.js");
+
+//# sourceMappingURL=index.js.map

webui/node_modules/@babel/helper-validator-identifier/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_identifier","require","_keyword"],"sources":["../src/index.ts"],"sourcesContent":["export {\n  isIdentifierName,\n  isIdentifierChar,\n  isIdentifierStart,\n} from \"./identifier.ts\";\nexport {\n  isReservedWord,\n  isStrictBindOnlyReservedWord,\n  isStrictBindReservedWord,\n  isStrictReservedWord,\n  isKeyword,\n} from \"./keyword.ts\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,WAAA,GAAAC,OAAA;AAKA,IAAAC,QAAA,GAAAD,OAAA","ignoreList":[]}

webui/node_modules/@babel/helper-validator-identifier/lib/keyword.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isKeyword = isKeyword;
+exports.isReservedWord = isReservedWord;
+exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
+exports.isStrictBindReservedWord = isStrictBindReservedWord;
+exports.isStrictReservedWord = isStrictReservedWord;
+const reservedWords = {
+  keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
+  strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
+  strictBind: ["eval", "arguments"]
+};
+const keywords = new Set(reservedWords.keyword);
+const reservedWordsStrictSet = new Set(reservedWords.strict);
+const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
+function isReservedWord(word, inModule) {
+  return inModule && word === "await" || word === "enum";
+}
+function isStrictReservedWord(word, inModule) {
+  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
+}
+function isStrictBindOnlyReservedWord(word) {
+  return reservedWordsStrictBindSet.has(word);
+}
+function isStrictBindReservedWord(word, inModule) {
+  return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
+}
+function isKeyword(word) {
+  return keywords.has(word);
+}
+
+//# sourceMappingURL=keyword.js.map

webui/node_modules/@babel/helper-validator-identifier/lib/keyword.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["reservedWords","keyword","strict","strictBind","keywords","Set","reservedWordsStrictSet","reservedWordsStrictBindSet","isReservedWord","word","inModule","isStrictReservedWord","has","isStrictBindOnlyReservedWord","isStrictBindReservedWord","isKeyword"],"sources":["../src/keyword.ts"],"sourcesContent":["const reservedWords = {\n  keyword: [\n    \"break\",\n    \"case\",\n    \"catch\",\n    \"continue\",\n    \"debugger\",\n    \"default\",\n    \"do\",\n    \"else\",\n    \"finally\",\n    \"for\",\n    \"function\",\n    \"if\",\n    \"return\",\n    \"switch\",\n    \"throw\",\n    \"try\",\n    \"var\",\n    \"const\",\n    \"while\",\n    \"with\",\n    \"new\",\n    \"this\",\n    \"super\",\n    \"class\",\n    \"extends\",\n    \"export\",\n    \"import\",\n    \"null\",\n    \"true\",\n    \"false\",\n    \"in\",\n    \"instanceof\",\n    \"typeof\",\n    \"void\",\n    \"delete\",\n  ],\n  strict: [\n    \"implements\",\n    \"interface\",\n    \"let\",\n    \"package\",\n    \"private\",\n    \"protected\",\n    \"public\",\n    \"static\",\n    \"yield\",\n  ],\n  strictBind: [\"eval\", \"arguments\"],\n};\nconst keywords = new Set(reservedWords.keyword);\nconst reservedWordsStrictSet = new Set(reservedWords.strict);\nconst reservedWordsStrictBindSet = new Set(reservedWords.strictBind);\n\n/**\n * Checks if word is a reserved word in non-strict mode\n */\nexport function isReservedWord(word: string, inModule: boolean): boolean {\n  return (inModule && word === \"await\") || word === \"enum\";\n}\n\n/**\n * Checks if word is a reserved word in non-binding strict mode\n *\n * Includes non-strict reserved words\n */\nexport function isStrictReservedWord(word: string, inModule: boolean): boolean {\n  return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);\n}\n\n/**\n * Checks if word is a reserved word in binding strict mode, but it is allowed as\n * a normal identifier.\n */\nexport function isStrictBindOnlyReservedWord(word: string): boolean {\n  return reservedWordsStrictBindSet.has(word);\n}\n\n/**\n * Checks if word is a reserved word in binding strict mode\n *\n * Includes non-strict reserved words and non-binding strict reserved words\n */\nexport function isStrictBindReservedWord(\n  word: string,\n  inModule: boolean,\n): boolean {\n  return (\n    isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word)\n  );\n}\n\nexport function isKeyword(word: string): boolean {\n  return keywords.has(word);\n}\n"],"mappings":";;;;;;;;;;AAAA,MAAMA,aAAa,GAAG;EACpBC,OAAO,EAAE,CACP,OAAO,EACP,MAAM,EACN,OAAO,EACP,UAAU,EACV,UAAU,EACV,SAAS,EACT,IAAI,EACJ,MAAM,EACN,SAAS,EACT,KAAK,EACL,UAAU,EACV,IAAI,EACJ,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,KAAK,EACL,KAAK,EACL,OAAO,EACP,OAAO,EACP,MAAM,EACN,KAAK,EACL,MAAM,EACN,OAAO,EACP,OAAO,EACP,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,MAAM,EACN,OAAO,EACP,IAAI,EACJ,YAAY,EACZ,QAAQ,EACR,MAAM,EACN,QAAQ,CACT;EACDC,MAAM,EAAE,CACN,YAAY,EACZ,WAAW,EACX,KAAK,EACL,SAAS,EACT,SAAS,EACT,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,OAAO,CACR;EACDC,UAAU,EAAE,CAAC,MAAM,EAAE,WAAW;AAClC,CAAC;AACD,MAAMC,QAAQ,GAAG,IAAIC,GAAG,CAACL,aAAa,CAACC,OAAO,CAAC;AAC/C,MAAMK,sBAAsB,GAAG,IAAID,GAAG,CAACL,aAAa,CAACE,MAAM,CAAC;AAC5D,MAAMK,0BAA0B,GAAG,IAAIF,GAAG,CAACL,aAAa,CAACG,UAAU,CAAC;AAK7D,SAASK,cAAcA,CAACC,IAAY,EAAEC,QAAiB,EAAW;EACvE,OAAQA,QAAQ,IAAID,IAAI,KAAK,OAAO,IAAKA,IAAI,KAAK,MAAM;AAC1D;AAOO,SAASE,oBAAoBA,CAACF,IAAY,EAAEC,QAAiB,EAAW;EAC7E,OAAOF,cAAc,CAACC,IAAI,EAAEC,QAAQ,CAAC,IAAIJ,sBAAsB,CAACM,GAAG,CAACH,IAAI,CAAC;AAC3E;AAMO,SAASI,4BAA4BA,CAACJ,IAAY,EAAW;EAClE,OAAOF,0BAA0B,CAACK,GAAG,CAACH,IAAI,CAAC;AAC7C;AAOO,SAASK,wBAAwBA,CACtCL,IAAY,EACZC,QAAiB,EACR;EACT,OACEC,oBAAoB,CAACF,IAAI,EAAEC,QAAQ,CAAC,IAAIG,4BAA4B,CAACJ,IAAI,CAAC;AAE9E;AAEO,SAASM,SAASA,CAACN,IAAY,EAAW;EAC/C,OAAOL,QAAQ,CAACQ,GAAG,CAACH,IAAI,CAAC;AAC3B","ignoreList":[]}

webui/node_modules/@babel/helper-validator-identifier/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@babel/helper-validator-identifier",
+  "version": "7.28.5",
+  "description": "Validate identifier/keywords name",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-helper-validator-identifier"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "devDependencies": {
+    "@unicode/unicode-17.0.0": "^1.6.10",
+    "charcodes": "^0.2.0"
+  },
+  "engines": {
+    "node": ">=6.9.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)",
+  "type": "commonjs"
+}

webui/node_modules/@babel/parser/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012-2014 by various contributors (see AUTHORS)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

webui/node_modules/@babel/parser/README.md

@@ -0,0 +1,19 @@
+# @babel/parser
+
+> A JavaScript parser
+
+See our website [@babel/parser](https://babeljs.io/docs/babel-parser) for more information or the [issues](https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A%20parser%22+is%3Aopen) associated with this package.
+
+## Install
+
+Using npm:
+
+```sh
+npm install --save-dev @babel/parser
+```
+
+or using yarn:
+
+```sh
+yarn add @babel/parser --dev
+```

webui/node_modules/@babel/parser/bin/babel-parser.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/* eslint-disable no-var, unicorn/prefer-node-protocol */
+
+var parser = require("..");
+var fs = require("fs");
+
+var filename = process.argv[2];
+if (!filename) {
+  console.error("no filename specified");
+} else {
+  var file = fs.readFileSync(filename, "utf8");
+  var ast = parser.parse(file);
+
+  console.log(JSON.stringify(ast, null, "  "));
+}

webui/node_modules/@babel/parser/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@babel/parser",
+  "version": "7.28.6",
+  "description": "A JavaScript parser",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-parser",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A+parser+%28babylon%29%22+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "babel",
+    "javascript",
+    "parser",
+    "tc39",
+    "ecmascript",
+    "@babel/parser"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-parser"
+  },
+  "main": "./lib/index.js",
+  "types": "./typings/babel-parser.d.ts",
+  "files": [
+    "bin",
+    "lib",
+    "typings/babel-parser.d.ts",
+    "index.cjs"
+  ],
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "# dependencies": "This package doesn't actually have runtime dependencies. @babel/types is only needed for type definitions.",
+  "dependencies": {
+    "@babel/types": "^7.28.6"
+  },
+  "devDependencies": {
+    "@babel/code-frame": "^7.28.6",
+    "@babel/helper-check-duplicate-nodes": "^7.28.6",
+    "@babel/helper-fixtures": "^7.28.6",
+    "@babel/helper-string-parser": "^7.27.1",
+    "@babel/helper-validator-identifier": "^7.28.5",
+    "charcodes": "^0.2.0"
+  },
+  "bin": "./bin/babel-parser.js",
+  "type": "commonjs"
+}